using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using Csla;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Reflection;

namespace VEPROMS.CSLA.Library
{
	public delegate void VETreeNodeEvent(object sender, VETreeNodeEventArgs args);
	public class VETreeNodeEventArgs : EventArgs 
	{
		public VETreeNodeEventArgs() { ; }
		public VETreeNodeEventArgs(string info)
		{
			_Info = info;
		}
		public VETreeNodeEventArgs(int value)
		{
			_Value = value;
		}
		public VETreeNodeEventArgs(string info, int value)
		{
			_Info = info;
			_Value = value;
		}
		private int _Value;

		public int Value
		{
			get { return _Value; }
			set { _Value = value; }
		}
		private string _Info;

		public string Info
		{
			get { return _Info; }
			set { _Info = value; }
		}
	
	}
	public class VETreeNode : TreeNode
	{
		#region Events
		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
		public event VETreeNodeEvent LoadingChildrenSQL;
		public event VETreeNodeEvent LoadingChildrenMax;
		public event VETreeNodeEvent LoadingChildrenValue;
		public event VETreeNodeEvent LoadingChildrenDone;
		private void OnLoadingChildrenSQL(object sender, VETreeNodeEventArgs args)
		{
			if (LoadingChildrenSQL != null) LoadingChildrenSQL(sender, args);
		}
		private void OnLoadingChildrenMax(object sender, VETreeNodeEventArgs args)
		{
			if (LoadingChildrenMax != null) LoadingChildrenMax(sender, args);
		}
		private void OnLoadingChildrenValue(object sender, VETreeNodeEventArgs args)
		{
			if (LoadingChildrenValue != null) LoadingChildrenValue(sender, args);
		}
		private void OnLoadingChildrenDone(object sender, VETreeNodeEventArgs args)
		{
			if (LoadingChildrenDone != null) LoadingChildrenDone(sender, args);
		}
		#endregion
		#region Business Methods
		protected IVEDrillDownReadOnly _VEObject;
		public IVEDrillDownReadOnly VEObject
		{
			get { return _VEObject; }
			set
			{
				_VEObject = value;
				base.Text = _VEObject.ToString();
				ResetNode("Dummy Set_VEObject");
			}
		}
		//public void Refresh()
		//{
		//  if (_VEObject != null)
		//    Text = _VEObject.ToString();
		//}
		// Only load the Children Once
		protected bool _ChildrenLoaded = false;
		public bool ChildrenLoaded
		{
			get { return _ChildrenLoaded; }
			set { _ChildrenLoaded = value; }
		}
		protected bool _MovedToSeparateWindow = false; // C2015-022 tells us this tree node and childern are now in a child window (separate Window) - used on Parent window side for a folder context menu
		public bool MovedToSeparateWindow
		{
			get { return _MovedToSeparateWindow; }
			set { _MovedToSeparateWindow = value; }
		}
		protected bool _InChildWindow = false; // C2015-022 tells us this tree node is in the child window - used on child window side for folder context menu
		public bool InChildWindow
		{
			get { return _InChildWindow; }
			set { _InChildWindow = value; }
		}
		// Reset Node
		//public void CloseNode()
		//{
		//  ResetNode();
		//}
		private void SetProperty(string name)
		{
			PropertyInfo propertyInfoObj = _VEObject.GetType().GetProperty(name);
			if (propertyInfoObj == null) return;
			PropertyInfo propertyInfoThis = this.GetType().GetProperty(name);
			if (propertyInfoThis == null) return;
			try
			{
				propertyInfoThis.SetValue(this, propertyInfoObj.GetValue(_VEObject, null), null);
			}
			catch (Exception ex)
			{
				Console.WriteLine("Error: {0}", ex.Message);
			}
		}
		public void ResetNode(string dummy)
		{
			if (_VEObject!=null && _VEObject.HasChildren && _ChildrenLoaded == false && CheckForParts())
			{
				_ChildrenLoaded = false;// Reset the children loaded flag
				this.Nodes.Add(dummy);// Add a Dummy Node so that the item will appear to be expanable.
			}
			else
			{
				_ChildrenLoaded = true;// Reset the children loaded flag
			}
			if (base.Text != _VEObject.ToString()) base.Text = _VEObject.ToString();
			SetProperty("ForeColor");
			SetProperty("BackColor");
			SetProperty("ImageIndex");
			SetProperty("IsVisible");
			SetProperty("SelectedImageIndex");
			// ToDo: Need to reset object as well
		}

		private bool CheckForParts()
		{
			if (_allParts) return true;
			// only has 'children' if parts are steps or sections
			if (_VEObject.GetType() == typeof(StepInfo) || _VEObject.GetType() == typeof(SectionInfo) || _VEObject.GetType() == typeof(ItemInfo))
			{
				IList ol = ((ItemInfo)_VEObject).GetChildren(_allParts);
				if (ol == null || ol.Count == 0) return false;
			}
			return true;
		}
		public void RefreshNode()
		{
			ResetNode("Dummy RefreshNode");// Drop Children
			LoadChildren();// Load Children
		}
		public static VETreeNode GetFolder(int folderID)
		{
			VETreeNode tn = new VETreeNode(FolderInfo.Get(folderID));
			//tn.Nodes.Add("Dummy");
			tn.ResetNode("Dummy GetFolder");
			return tn;
		}
//		public abstract void LoadChildren();
		//private long _Start;
		//private Dictionary<string, long> _Timings=new Dictionary<string,long>();
		//private void tReset()
		//{
		//  _Timings = new Dictionary<string, long>();
		//  _Start = DateTime.Now.Ticks;
		//}
		//private void tNext(string msg)
		//{
		//  long tEnd = DateTime.Now.Ticks;
		//  long tDiff = tEnd - _Start;
		//  if (_Timings.ContainsKey(msg)) tDiff += _Timings[msg];
		//  _Timings[msg] = tDiff;
		//  _Start = DateTime.Now.Ticks;
		//}
		//private void tShowResults()
		//{
		//  Console.WriteLine("Timings");
		//  long total=0;
		//  foreach (string msg in _Timings.Keys)
		//  {
		//    total += _Timings[msg];
		//    Console.WriteLine("{0}\t\"{1}\"", TimeSpan.FromTicks(_Timings[msg]).TotalMilliseconds, msg);
		//  }
		//  Console.WriteLine("{0}\t\"Total\"", TimeSpan.FromTicks(total).TotalMilliseconds);
		//}
		public virtual void LoadChildren()
		{
			LoadChildren(true);
		}
		private bool _allParts = true;
		private bool _excludeTablesFigsEqu = false; // used for inserting Step Text transitions (BNPP)
		public virtual void LoadChildren(bool allParts, bool excldTablesFigEq = false)
		{
			_allParts = allParts;
			// B2024-019 don't show Tables, Figures, or Equations in step tree when inserting Text Transitions
			_excludeTablesFigsEqu = excldTablesFigEq;
			if (!_ChildrenLoaded)
			{
				this.Nodes.Clear();
				//tReset();
				DateTime tStart = DateTime.Now;
				//TVAddChildren(_VEObject, this);
				OnLoadingChildrenSQL(this, new VETreeNodeEventArgs());
				IList ol;
				ItemInfo item = _VEObject as ItemInfo;
				if (item != null) item.RefreshItemParts();
				if (_VEObject.GetType() == typeof(StepInfo) || _VEObject.GetType() == typeof(SectionInfo) || _VEObject.GetType() == typeof(ItemInfo))
					ol = ((ItemInfo)_VEObject).GetChildren(allParts);
				else
					ol = _VEObject.GetChildren();
				//tNext("GetChildren");
				if (ol != null)
				{
					OnLoadingChildrenMax(this, new VETreeNodeEventArgs(ol.Count));
					//this.TreeView.BeginUpdate();
					if (this.TreeView != null) this.TreeView.BeginUpdate();
					else _MyLog.WarnFormat("TreeView.BeginUpdate - Null");
					ExpandChildren(ol);
					//}
					//tNext("Set Nodes");
					//this.TreeView.EndUpdate();
					if (this.TreeView != null) this.TreeView.EndUpdate();
					else _MyLog.WarnFormat("TreeView.EndUpdate - Null");
					//tNext("End Update");
					//tShowResults();
				}
				_ChildrenLoaded = true;
				OnLoadingChildrenDone(this, new VETreeNodeEventArgs(TimeSpan.FromTicks(DateTime.Now.Ticks - tStart.Ticks).TotalSeconds.ToString()));
			}
		}

		private void ExpandChildren(IList ol)
		{
			int icnt = 0;
			bool lastWasSection = false;
			foreach (IVEDrillDownReadOnly o in ol)
			{
				OnLoadingChildrenValue(this, new VETreeNodeEventArgs(++icnt));
				//tNext("Cycle");
				try
				{
					bool skipIt = false;
					bool isStepPart = (o is PartInfo && (o as PartInfo).PartType == E_FromType.Step);
					if (isStepPart)
					{
						
						// get parent section and see if it has the Editable flag set.  Only skip
						// if this flag is set to "N".
						ItemInfo sectInfo = (ItemInfo)(o as PartInfo).ActiveParent;
						bool hasMetaSubs = sectInfo != null && sectInfo.Sections != null && sectInfo.Sections.Count > 0;
						bool editSteps = !hasMetaSubs || (sectInfo.MyConfig is SectionConfig && (sectInfo.MyConfig as SectionConfig).SubSection_Edit == "Y");
						if (!editSteps) skipIt = true;
					}
					if (!skipIt)
					{
						VETreeNode tmp = new VETreeNode(o, _allParts);
						// B2024-019 don't show Tables, Figures, or Equations in step tree when inserting Text Transitions
						bool isTableFigEqu = tmp.Text.Equals("Table") ||
									tmp.Text.Equals("Figure") ||
									tmp.Text.Equals("Equation");
						if (o.HasChildren)
						{
							if (o is PartInfo)
							{
								tmp.Nodes.Clear();
								tmp.ExpandChildren(o.GetChildren());
								tmp._ChildrenLoaded = true;
							}
							// OLD: RHM 20100115 : I don't think that the following lines are necessary since the "new VETreeNode(o)" 
							// above includes a similar function.
							//else
							//	tmp.Nodes.Add(string.Format("dummy: {0}", o.GetType().Name));// Add a Dummy Node so that the item will appear to be expanable.
						}
						else
							tmp._ChildrenLoaded = true;// Reset the children loaded flag
						if (lastWasSection)
							this.Nodes.Insert(0, tmp);
						// B2024-019 don't show Tables, Figures, or Equations in step tree when inserting Text Transitions
						else if (!_excludeTablesFigsEqu || !isTableFigEqu)
							this.Nodes.Add(tmp);
						// if last thing was section & this is step, do insert - i.e. so that steps go before sections.
						lastWasSection = (o is PartInfo && (o as PartInfo).PartType == E_FromType.Section);
					}
				}
				catch (Exception ex)
				{
					Console.WriteLine("{0}\r\n{1}", ex.Message, ex.InnerException);
				}
			}
		}
		private void TVAddChildren(IVEDrillDownReadOnly veobj, VETreeNode tn)
		{
			OnLoadingChildrenSQL(tn, new VETreeNodeEventArgs());
			IList ol;
			ItemInfo item = veobj as ItemInfo;
			if (veobj.GetType() == typeof(StepInfo) || veobj.GetType() == typeof(SectionInfo) || veobj.GetType() == typeof(ItemInfo))
				ol = ((ItemInfo)veobj).GetChildren(true);
			else
				ol = veobj.GetChildren();
			if (ol != null)
			{
				OnLoadingChildrenMax(this, new VETreeNodeEventArgs(ol.Count));
				this.TreeView.BeginUpdate();
				int icnt = 0;
				foreach (IVEDrillDownReadOnly o in ol)
				{
					OnLoadingChildrenValue(this, new VETreeNodeEventArgs(++icnt));
					try
					{
						VETreeNode tmp = new VETreeNode(o);
						PartInfo pi = o as PartInfo;
						if (pi == null && o.HasChildren)
							tmp.Nodes.Add("Dummy");// Add a Dummy Node so that the item will appear to be expanable.
						else
							tmp._ChildrenLoaded = true;// Reset the children loaded flag
						tn.Nodes.Add(tmp);
						if (pi != null && o.HasChildren)
							TVAddChildren(o, tmp);
					}
					catch (Exception ex)
					{
						Console.WriteLine("{0}\r\n{1}", ex.Message, ex.InnerException);
					}
				}
				
				//}
				this.TreeView.EndUpdate();
			}
		}
		void myItemInfo_Deleted(object sender)
		{
			VETreeNode parnode = Parent as VETreeNode;
			if (parnode == null) return;
			PartInfo pi = parnode.VEObject as PartInfo;
			Remove();
			// get rid of 'Steps', 'RNOs', i.e. grouping nodes, if there are no children.
			if (pi != null && parnode.Nodes.Count == 0)
			{
				VETreeNode grndparnode = parnode.Parent as VETreeNode;
				parnode.Remove();
				// if only 'Steps' node is left, move steps 'up' a level.
				if (grndparnode != null && grndparnode.Nodes.Count == 1)
				{
					VETreeNode sibnode = grndparnode.Nodes[0] as VETreeNode;
					PartInfo pisib = sibnode.VEObject as PartInfo;
					if (pisib != null &&  (pisib.ToString() == "Steps"))
					{
						if (!sibnode.ChildrenLoaded) sibnode.LoadChildren();
						while (sibnode.Nodes.Count > 0)
						{
							VETreeNode tmp = sibnode.Nodes[0] as VETreeNode;
							tmp.Remove();
							grndparnode.Nodes.Add(tmp);
						}
						sibnode.Remove();
					}
				}
			}
		}

		//public IVEReadOnlyItem GetCsla()
		//{
		//  return _VEObject;
		//}
		#endregion
		#region Factory Methods
		// Constructors
		public VETreeNode() : base("NoText") { ; }
		public VETreeNode(IVEDrillDownReadOnly o, bool allParts)
			: base(o.ToString())
		{
			_allParts = allParts;
			_VEObject = o;// Save the BusinessObject
			ResetNode("Dummy VETreeNode(IVEDrillDownReadOnly o)");
			ItemInfo myItemInfo = o as ItemInfo;
			if (myItemInfo != null)
			{
				myItemInfo.Deleted += new ItemInfoEvent(myItemInfo_Deleted);
				myItemInfo.ChildrenDeleted += new ItemInfoEvent(myItemInfo_ChildrenDeleted);
				myItemInfo.MyContent.Changed += new ContentInfoEvent(NodeText_Changed);
				myItemInfo.OrdinalChanged += new ItemInfoEvent(NodeText_Changed);
				myItemInfo.NewSiblingAfter += new ItemInfoInsertEvent(myItemInfo_NewSiblingAfter);
				myItemInfo.NewSiblingBefore += new ItemInfoInsertEvent(myItemInfo_NewSiblingBefore);
				myItemInfo.NewChild += new ItemInfoInsertEvent(myItemInfo_NewChild);
			}
		}
		void NodeText_Changed(object sender)
		{
			Text = _VEObject.ToString();
			ItemInfo myItemInfo = _VEObject as ItemInfo;
			if (myItemInfo != null && myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave > 0)
			{
				int k = myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave;
				myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave = 0;
				Text = myItemInfo.ToString();
				myItemInfo.MyDocVersion.DocVersionConfig.SelectedSlave = k;
			}
			if (myItemInfo != null && myItemInfo.IsSection)
			{
				myItemInfo.RefreshConfig();
				// check if metasection & has subsections.  This could be a change in config
				// item, i.e. Editable Data, that would add or remove any step nodes, i.e. requires a
				// tree refresh.
				if (myItemInfo.Sections != null && myItemInfo.Sections.Count > 0 && myItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseMetaSections)
				{
					// see if change in children tree nodes.
					this.Nodes.Clear();
					_ChildrenLoaded = false;
					LoadChildren(true);
				}
			}
		}
		public VETreeNode(IVEDrillDownReadOnly o)
			: base(o.ToString())
		{
			_VEObject = o;// Save the BusinessObject
			ResetNode("Dummy VETreeNode(IVEDrillDownReadOnly o)");
			ItemInfo myItemInfo = o as ItemInfo;
			if (myItemInfo != null)
			{
				myItemInfo.Deleted += new ItemInfoEvent(myItemInfo_Deleted);
				myItemInfo.ChildrenDeleted += new ItemInfoEvent(myItemInfo_ChildrenDeleted);
				myItemInfo.MyContent.Changed += new ContentInfoEvent(NodeText_Changed);
				myItemInfo.OrdinalChanged += new ItemInfoEvent(NodeText_Changed);
				myItemInfo.NewSiblingAfter += new ItemInfoInsertEvent(myItemInfo_NewSiblingAfter);
				myItemInfo.NewSiblingBefore += new ItemInfoInsertEvent(myItemInfo_NewSiblingBefore);
				myItemInfo.NewChild += new ItemInfoInsertEvent(myItemInfo_NewChild);
			}
		}

		void myItemInfo_ChildrenDeleted(object sender)
		{
			//Console.WriteLine("Fix Children");
			ItemInfo myItemInfo = VEObject as ItemInfo;
			//if (Nodes.Count > 1)
			//    Console.WriteLine("{0}, {1}",Nodes[0], Nodes[1]);

			if (!myItemInfo.HasChildren && Nodes.Count>0 && !(Nodes[0] is VETreeNode))
				Nodes.Clear();
		}
		void myItemInfo_NewChild(object sender, ItemInfoInsertEventArgs args)
		{
			if (args.ItemInserted.NextItem != null)   // insert before
			{
				int nextItemID = args.ItemInserted.NextItem.ItemID;
				VETreeNode nextNode = FindChildOrGrandChild(nextItemID);
				if(nextNode != null)
					nextNode.myItemInfo_NewSiblingBefore(sender, args);
				return;
			}
			if (args.ItemInserted.MyPrevious != null)	// insert after
			{
				int prevItemID = args.ItemInserted.MyPrevious.ItemID;
				VETreeNode prevNode = FindChildOrGrandChild(prevItemID);
				prevNode.myItemInfo_NewSiblingAfter(sender, args);
				return;
			}
			bool isExpanded = IsExpanded;
			// Restore the tree as it currently is expanded.
			Collapse();
			Nodes.Clear();
			_ChildrenLoaded = false;
			ResetNode("Dummy myItemInfo_NewChild");
			ItemInfo item = VEObject as ItemInfo;
			if (isExpanded && item != null && item.MyContent.ContentPartCount > 1) // || args.ItemInserted.NextItem != null || args.ItemInserted.MyPrevious != null)) 
				Expand();
			else
				Collapse();
		}
		private VETreeNode FindChildOrGrandChild(int itemID)
		{
			foreach (TreeNode childNode in Nodes)
			{
				VETreeNode child = childNode as VETreeNode;
				if (child != null)
				{
					ItemInfo item = child.VEObject as ItemInfo;
					if (item != null && item.ItemID == itemID)
						return child;
				}
			}
			foreach (TreeNode childNode in Nodes)
			{
				VETreeNode child = childNode as VETreeNode;
				if (child != null && child.VEObject is PartInfo)
					foreach (VETreeNode grandchild in child.Nodes)
					{
						ItemInfo item = grandchild.VEObject as ItemInfo;
						if (item != null && item.ItemID == itemID)
							return grandchild;
					}
			}
			return null;
		}
		void myItemInfo_NewSiblingBefore(object sender, ItemInfoInsertEventArgs args)
		{
			if (this.Parent != null) // Only do this if the node has a parent - RHM 20100106
			{
				ItemInfo ii = args.ItemInserted as ItemInfo;
				if (ii == null)
					this.Parent.Nodes.Insert(Index, (new VETreeNode(args.ItemInserted)));
				else  // B2020-142: Can't get properties of restored item (no treeview context menu would be correct after restore)
				{
					if (ii.IsProcedure) this.Parent.Nodes.Insert(Index, (new VETreeNode(ProcedureInfo.Get(ii.ItemID))));
					if (ii.IsSection) this.Parent.Nodes.Insert(Index, (new VETreeNode(SectionInfo.Get(ii.ItemID))));
					if (ii.IsStep) this.Parent.Nodes.Insert(Index, (new VETreeNode(StepInfo.Get(ii.ItemID))));
				}
			}
		}
		void myItemInfo_NewSiblingAfter(object sender, ItemInfoInsertEventArgs args)
		{
			if (this.Parent != null) // Only do this if the node has a parent - RHM 20100106
			{
				ItemInfo ii = args.ItemInserted as ItemInfo;
				if (ii == null)
					this.Parent.Nodes.Insert(Index + 1, (new VETreeNode(args.ItemInserted)));
				else  // B2020-142: Can't get properties of restored item (no treeview context menu would be correct after restore)
				{
					if (ii.IsProcedure) this.Parent.Nodes.Insert(Index + 1, (new VETreeNode(ProcedureInfo.Get(ii.ItemID))));
					if (ii.IsSection) this.Parent.Nodes.Insert(Index + 1, (new VETreeNode(SectionInfo.Get(ii.ItemID))));
					if (ii.IsStep) this.Parent.Nodes.Insert(Index + 1, (new VETreeNode(StepInfo.Get(ii.ItemID))));
				}
			}
		}
		public VETreeNode(string s)
			: base(s)
		{
			_VEObject = null;// Save the BusinessObject
			//ResetNode();
		}
		#endregion
	}
	//public class VETreeNodeBase<T> : VETreeNode
	//where T : VETreeNode, new()
	//{
	//  #region Factory Methods
	//  private static int _ICount = 0;
	//  public VETreeNodeBase(string s) : base(s) { ;}
	//  public VETreeNodeBase(IVEReadOnlyItem o) : base(o) { ;}
	//  protected VETreeNodeBase() : base() { 
	//  }
	//  private DateTime tNext(DateTime tStart, string msg)
	//  {
	//    DateTime tEnd = DateTime.Now;
	//    TimeSpan ts = new TimeSpan(tEnd.Ticks-tStart.Ticks);
	//    Console.WriteLine("{0} - {1}", ts.TotalMilliseconds, msg);
	//    return tEnd;
	//  }
	//  public override void LoadChildren()
	//  {
	//    if (!_ChildrenLoaded)
	//    {
	//      this.Nodes.Clear();
	//      "".TrimEnd("\r\n".ToCharArray());
	//      IList ol = _VEObject.GetChildren();
	//      if (ol != null)
	//      {
	//        this.TreeView.BeginUpdate();
	//        DateTime tStart = DateTime.Now;
	//        T[] tmpa = new T[ol.Count];
	//        tStart = tNext(tStart, "Allocate Array");
	//        for (int i = 0; i < ol.Count; i++) tmpa[i] = new T();
	//        tStart = tNext(tStart, "Allocate Nodes");
	//        int ii = 0;
	//        foreach (IVEReadOnlyItem o in ol)
	//        {
	//          try
	//          {
	//            tmpa[ii++].VEObject = o;
	//          }
	//          catch (Exception ex)
	//          {
	//            Console.WriteLine("{0}\r\n{1}", ex.Message, ex.InnerException);
	//          }
	//        }
	//        tStart = tNext(tStart, "Set Nodes");
	//        for (int i = 0; i < ol.Count; i++) tmpa[i].ResetNode();
	//        tStart = tNext(tStart, "Reset Nodes");
	//        this.Nodes.AddRange(tmpa);
	//        tStart = tNext(tStart, "Add Range");
	//        //foreach (IVEReadOnlyItem o in ol)
	//        //{
	//        //  try
	//        //  {
	//        //    T tmp = new T();
	//        //    tmp.VEObject = o;
	//        //    this.Nodes.Add(tmp);
	//        //  }
	//        //  catch (Exception ex)
	//        //  {
	//        //    Console.WriteLine("{0}\r\n{1}", ex.Message, ex.InnerException);
	//        //  }
	//        //}
	//        this.TreeView.EndUpdate();
	//      }
	//      _ChildrenLoaded = true;
	//    }
	//  }
	//#endregion
	//}
	/*
	public class VEFolder : VETreeNodeBase<VEVersion>
	{
		public static VEFolder GetFolder(int folderID)
		{
			return new VEFolder(FolderInfo.Get(folderID));
		}
		//public static VEFolder LoadTree()
		//{
		//  VEFolder root = null;
		//  FolderInfoList fil = FolderInfoList.Get();
		//  Dictionary<int, VEFolder> dicMissing = new Dictionary<int, VEFolder>();
		//  Dictionary<int, VEFolder> dicExists = new Dictionary<int, VEFolder>();
		//  foreach (FolderInfo fi in fil)
		//  {
		//    VEFolder ftp = null;
		//    if (dicExists.ContainsKey(fi.ParentID))
		//    {
		//      ftp = dicExists[fi.ParentID];
		//    }
		//    else
		//    {
		//      if (fi.ParentID != fi.FolderID)
		//      {
		//        ftp = new VEFolder(fi.ParentID.ToString());
		//        dicMissing.Add(fi.ParentID, ftp);
		//        dicExists.Add(fi.ParentID, ftp);
		//      }
		//    }
		//    VEFolder ft = null;
		//    if (dicMissing.ContainsKey(fi.FolderID))
		//    {
		//      ft = dicMissing[fi.FolderID];
		//      ft.VEObject = fi;
		//      dicMissing.Remove(fi.FolderID);
		//    }
		//    else
		//    {
		//      ft = new VEFolder(fi);
		//      dicExists.Add(fi.FolderID, ft);
		//    }
		//    if (fi.ParentID == fi.FolderID)
		//      root = ft;
		//    else
		//      ftp.Nodes.Add(ft);
		//  }
		//  //root.FindTree = dicExists;
		//  return root;
		//}
		private VEFolder(string s) : base(s) { ;}
		public VEFolder(IVEReadOnlyItem o) : base(o) { ;}
	}
	public class VEVersion : VETreeNodeBase<VEProcedure> { }
	public class VEProcedure : VETreeNodeBase<VESection>
	{
		//public override void LoadChildren()
		//{
		//  if (!_ChildrenLoaded)
		//  {
		//    this.Nodes.Clear();
		//    Dictionary<string, VESection> dicSect = new Dictionary<string, VESection>();
		//    SectionInfoList ol = (SectionInfoList)_VEObject.GetChildren();
		//    if (ol != null)
		//    {
		//      foreach (SectionInfo o in ol)
		//      {
		//        try
		//        {
		//          VESection tmp = new VESection();
		//          tmp.VEObject = o;
		//          if (dicSect.ContainsKey(o.PPath))
		//            dicSect[o.PPath].Nodes.Add(tmp);
		//          else 
		//            this.Nodes.Add(tmp);
		//          dicSect[o.Path] = tmp;
		//        }
		//        catch (Exception ex)
		//        {
		//          Console.WriteLine("{0}\r\n{1}", ex.Message, ex.InnerException);
		//        }
		//      }
		//    }
		//    _ChildrenLoaded = true;
		//  }
		//}
	}
	public class VESection : VETreeNodeBase<VEStep> { }
	public class VEStep : VETreeNodeBase<VEStep> { }
	*/
	//public class VETree : VETreeNodeBase<VETree>
	//{
	//  public VETree() { ;}
	//  public static VETree GetFolder(int folderID)
	//  {
	//    return new VETree(FolderInfo.Get(folderID));
	//  }
	//  //private VEFolder(string s) : base(s) { ;}
	//  public VETree(IVEReadOnlyItem o) : base(o) { ;}
	//}
	//public class VETree : VETreeNode
	//{
	//  public VETree() { ;}
	//  public static VETree GetFolder(int folderID)
	//  {
	//    VETree tn = new VETree(FolderInfo.Get(folderID));
	//    tn.ResetNode();
	//    return tn;
	//  }
	//  //private VEFolder(string s) : base(s) { ;}
	//  public VETree(IVEReadOnlyItem o) : base(o) { ;}
	//  private DateTime tNext(DateTime tStart, string msg)
	//  {
	//    DateTime tEnd = DateTime.Now;
	//    TimeSpan ts = new TimeSpan(tEnd.Ticks - tStart.Ticks);
	//    Console.WriteLine("{0} - {1}", ts.TotalMilliseconds, msg);
	//    return tEnd;
	//  }
	//  public override void LoadChildren()
	//  {
	//    if (!_ChildrenLoaded)
	//    {
	//      this.Nodes.Clear();
	//      "".TrimEnd("\r\n".ToCharArray());
	//      IList ol = _VEObject.GetChildren();
	//      if (ol != null)
	//      {
	//        this.TreeView.BeginUpdate();
	//        DateTime tStart = DateTime.Now;
	//        //VETree[] tmpa = new VETree[ol.Count];
	//        //tStart = tNext(tStart, "Allocate Array");
	//        ////for (int i = 0; i < ol.Count; i++) tmpa[i] = new VETree();
	//        ////tStart = tNext(tStart, "Allocate Nodes");
	//        //int ii = 0;
	//        //foreach (IVEReadOnlyItem o in ol)
	//        //{
	//        //  try
	//        //  {
	//        //    tmpa[ii++] = new VETree(o);
	//        //    //tmpa[ii++].VEObject = o;
	//        //  }
	//        //  catch (Exception ex)
	//        //  {
	//        //    Console.WriteLine("{0}\r\n{1}", ex.Message, ex.InnerException);
	//        //  }
	//        //}
	//        //tStart = tNext(tStart, "Set Nodes");
	//        //for (int i = 0; i < ol.Count; i++) tmpa[i].ResetNode();
	//        //tStart = tNext(tStart, "Reset Nodes");
	//        //this.Nodes.AddRange(tmpa);
	//        //tStart = tNext(tStart, "Add Range");
	//        this.TreeView.DrawMode = TreeViewDrawMode.OwnerDrawAll;
	//        foreach (IVEReadOnlyItem o in ol)
	//        {
	//          try
	//          {
	//            VETree tmp = new VETree(o);
	//            //tmp.VEObject = o;
	//            this.Nodes.Add(tmp);
	//          }
	//          catch (Exception ex)
	//          {
	//            Console.WriteLine("{0}\r\n{1}", ex.Message, ex.InnerException);
	//          }
	//        }
	//        tStart = tNext(tStart, "Set Nodes");
	//        this.TreeView.DrawMode = TreeViewDrawMode.Normal;
	//        tStart = tNext(tStart, "DrawMode");
	//        this.TreeView.EndUpdate();
	//        tStart = tNext(tStart, "End Update");
	//        this.TreeView.Refresh();
	//        tStart = tNext(tStart, "Refresh");
	//      }
	//      _ChildrenLoaded = true;
	//    }
	//  }
	//}
}