using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.VisualBasic;
using Microsoft.VisualBasic.CompilerServices;

namespace Dongke.IBOSS.PRD.Framework.Controls
{

	[EditorBrowsable(EditorBrowsableState.Never)]
	public class mytree : IDisposable
	{
		private int iNodeLevels;

		private int iCellHeight;

		private IList<TreeNode> ColLists;

		private TreeView _ColHeaderTreeView;

		private DataGridView mydgv;

		private float[] columnwidth;

		private bool disposedValue;

		public void SetDVGHeaderText()
		{
			checked
			{
				try
				{
					int num = 0;
					int num2 = mydgv.ColumnCount - 1;
					for (int i = num; i <= num2; i++)
					{
						mydgv.Columns[i].HeaderText = Strings.Trim(ColLists[i].Text ?? "");
						try
						{
							mydgv.Columns[i].Name = Strings.Trim(ColLists[i].Text ?? "");
						}
						catch (Exception projectError)
						{
							ProjectData.SetProjectError(projectError);
							mydgv.Columns[i].Name = "第" + Conversions.ToString(i + 1) + "列";
							ProjectData.ClearProjectError();
						}
					}
				}
				catch (Exception projectError2)
				{
					ProjectData.SetProjectError(projectError2);
					ProjectData.ClearProjectError();
				}
			}
		}

		public mytree(TreeView Tre, DataGridView DGV)
		{
			ColLists = new List<TreeNode>();
			mydgv = DGV;
			iNodeLevels = 1;
			_ColHeaderTreeView = Tre;
			myNodeLevels();
		}

		public mytree(TreeView Tre, DataGridView DGV, float[] colwidth)
		{
			ColLists = new List<TreeNode>();
			mydgv = DGV;
			iNodeLevels = 1;
			_ColHeaderTreeView = Tre;
			columnwidth = colwidth;
			myNodeLevels();
		}

		public mytree(TreeView Tre, DataGridView DGV, float[] colwidth, int columnheaderheight)
		{
			ColLists = new List<TreeNode>();
			mydgv = DGV;
			iNodeLevels = 1;
			_ColHeaderTreeView = Tre;
			columnwidth = colwidth;
			myNodeLevels(columnheaderheight);
		}

		public int GetColumns()
		{
			return ColLists.Count;
		}

		public int GetLeves()
		{
			return iNodeLevels;
		}

		public int GetSingleHeight()
		{
			return iCellHeight;
		}

		private TreeNode GetLevelNode(TreeNode node, int mylevel)
		{
			if (node == null)
			{
				return null;
			}
			checked
			{
				if (node.Level + 1 == mylevel)
				{
					return node;
				}
				if (node.Level + 1 < mylevel)
				{
					return null;
				}
				return GetLevelNode(node.Parent, mylevel);
			}
		}

		public float GetCellHeight(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			TreeNode levelNode = GetLevelNode(nodeByColIndex, mylevel);
			if (levelNode == null)
			{
				return 0f;
			}
			if (nodeByColIndex.Equals(levelNode))
			{
				return checked((iNodeLevels - mylevel + 1) * iCellHeight);
			}
			return iCellHeight;
		}

		public string GetNodeText(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			TreeNode levelNode = GetLevelNode(nodeByColIndex, mylevel);
			if (levelNode == null)
			{
				return "";
			}
			return levelNode.Text;
		}

		public Color GetNodeForeColor(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			return GetLevelNode(nodeByColIndex, mylevel)?.ForeColor ?? Color.Empty;
		}

		public Color GetNodeBackColor(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			return GetLevelNode(nodeByColIndex, mylevel)?.BackColor ?? Color.Empty;
		}

		public Font GetNodeFont(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			return GetLevelNode(nodeByColIndex, mylevel)?.NodeFont;
		}

		public float GetCellWidth(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			TreeNode levelNode = GetLevelNode(nodeByColIndex, mylevel);
			if (levelNode == null)
			{
				return 0f;
			}
			if (levelNode.Nodes.Count <= 0)
			{
				return GetUnitHeaderWidth(levelNode);
			}
			TreeNode firstNode = GetFirstNode(levelNode.FirstNode);
			if (firstNode.Equals(nodeByColIndex))
			{
				return GetUnitHeaderWidth(levelNode);
			}
			return 0f;
		}

		public float GetCellWidth2(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			TreeNode levelNode = GetLevelNode(nodeByColIndex, mylevel);
			if (levelNode == null)
			{
				return columnwidth[colindex];
			}
			if (levelNode.Nodes.Count <= 0)
			{
				return GetUnitHeaderWidth(levelNode);
			}
			return GetUnitHeaderWidth(levelNode);
		}

		private TreeNode GetFirstNode(TreeNode tt)
		{
			if (tt == null)
			{
				return null;
			}
			if (tt.Parent == null)
			{
				return tt;
			}
			TreeNode prevNode = tt.PrevNode;
			TreeNode treeNode = null;
			if (prevNode == null)
			{
				treeNode = tt;
			}
			else
			{
				while (prevNode != null)
				{
					treeNode = prevNode;
					prevNode = prevNode.PrevNode;
				}
			}
			if (treeNode == null)
			{
				return null;
			}
			int num = 100000;
			if (treeNode.Nodes.Count > 0)
			{
				TreeNode result = null;
				while (treeNode != null)
				{
					TreeNode treeNode2 = ((treeNode.Nodes.Count <= 0) ? treeNode : GetFirstNode(treeNode.FirstNode));
					int columnListNodeIndex = GetColumnListNodeIndex(treeNode2);
					if (columnListNodeIndex >= 0 && mydgv.Columns[columnListNodeIndex].Visible && mydgv.Columns[columnListNodeIndex].DisplayIndex < num)
					{
						num = mydgv.Columns[columnListNodeIndex].DisplayIndex;
						result = treeNode2;
					}
					treeNode = treeNode.NextNode;
				}
				return result;
			}
			tt = treeNode;
			num = 100000;
			TreeNode result2 = null;
			try
			{
				while (tt != null)
				{
					TreeNode treeNode3 = tt;
					int columnListNodeIndex2 = GetColumnListNodeIndex(tt);
					if (columnListNodeIndex2 < 0)
					{
						TreeNode firstNode = GetFirstNode(tt.FirstNode);
						columnListNodeIndex2 = GetColumnListNodeIndex(firstNode);
						treeNode3 = firstNode;
					}
					if (columnListNodeIndex2 >= 0 && mydgv.Columns[columnListNodeIndex2].Visible && mydgv.Columns[columnListNodeIndex2].DisplayIndex < num)
					{
						num = mydgv.Columns[columnListNodeIndex2].DisplayIndex;
						result2 = treeNode3;
					}
					tt = tt.NextNode;
				}
			}
			catch (Exception projectError)
			{
				ProjectData.SetProjectError(projectError);
				TreeNode result3 = null;
				ProjectData.ClearProjectError();
				return result3;
			}
			return result2;
		}

		private TreeNode GetNodeByColIndex(int colindex)
		{
			return ColLists[colindex];
		}

		private int myGetNodeLevels(TreeNodeCollection tnc)
		{
			if (tnc == null)
			{
				return 0;
			}
			checked
			{
				try
				{
					IEnumerator enumerator = tnc.GetEnumerator();
					while (enumerator.MoveNext())
					{
						TreeNode treeNode = (TreeNode)enumerator.Current;
						if (treeNode.Level + 1 > iNodeLevels)
						{
							iNodeLevels = treeNode.Level + 1;
						}
						if (treeNode.Nodes.Count > 0)
						{
							myGetNodeLevels(treeNode.Nodes);
						}
						else
						{
							ColLists.Add(treeNode);
						}
					}
				}
				finally
				{
					IEnumerator enumerator2 = null;
					if (enumerator2 is IDisposable)
					{
						(enumerator2 as IDisposable).Dispose();
					}
				}
				return iNodeLevels;
			}
		}

		private void myNodeLevels()
		{
			iNodeLevels = 1;
			ColLists.Clear();
			if (_ColHeaderTreeView == null)
			{
				iCellHeight = mydgv.ColumnHeadersHeight;
				return;
			}
			int num = myGetNodeLevels(_ColHeaderTreeView.Nodes);
			if (num != 0)
			{
				iCellHeight = checked((int)Math.Round((double)mydgv.ColumnHeadersHeight / (double)num));
			}
			else
			{
				iCellHeight = mydgv.ColumnHeadersHeight;
			}
		}

		private void myNodeLevels(int Columnheaderheight)
		{
			iNodeLevels = 1;
			ColLists.Clear();
			if (_ColHeaderTreeView == null)
			{
				iCellHeight = Columnheaderheight;
				return;
			}
			int num = myGetNodeLevels(_ColHeaderTreeView.Nodes);
			if (num != 0)
			{
				iCellHeight = checked((int)Math.Round((double)Columnheaderheight / (double)num));
			}
			else
			{
				iCellHeight = Columnheaderheight;
			}
		}

		private float GetUnitHeaderWidth(TreeNode node)
		{
			float num = 0f;
			int columnListNodeIndex = GetColumnListNodeIndex(node);
			if (node.Nodes == null)
			{
				if (mydgv.Columns[columnListNodeIndex].Visible)
				{
					return columnwidth[columnListNodeIndex];
				}
				return 0f;
			}
			if (node.Nodes.Count == 0)
			{
				if (mydgv.Columns[columnListNodeIndex].Visible)
				{
					return columnwidth[columnListNodeIndex];
				}
				return 0f;
			}
			int num2 = 0;
			checked
			{
				int num3 = node.Nodes.Count - 1;
				for (int i = num2; i <= num3; i++)
				{
					num += GetUnitHeaderWidth(node.Nodes[i]);
				}
				return num;
			}
		}

		private int GetColumnListNodeIndex(TreeNode node)
		{
			if (node == null)
			{
				return -1;
			}
			int num = 0;
			checked
			{
				int num2 = ColLists.Count - 1;
				for (int i = num; i <= num2; i++)
				{
					if (ColLists[i].Equals(node))
					{
						return i;
					}
				}
				return -1;
			}
		}

		private int GetUnitHeaderWidthCols(TreeNode node)
		{
			int num = 0;
			int columnListNodeIndex = GetColumnListNodeIndex(node);
			if (node.Nodes == null)
			{
				if (mydgv.Columns[columnListNodeIndex].Visible)
				{
					return 1;
				}
				return 0;
			}
			if (node.Nodes.Count == 0)
			{
				if (mydgv.Columns[columnListNodeIndex].Visible)
				{
					return 1;
				}
				return 0;
			}
			int num2 = 0;
			checked
			{
				int num3 = node.Nodes.Count - 1;
				for (int i = num2; i <= num3; i++)
				{
					num += GetUnitHeaderWidthCols(node.Nodes[i]);
				}
				return num;
			}
		}

		public int GetCellWidthCols(int colindex, int mylevel)
		{
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			TreeNode levelNode = GetLevelNode(nodeByColIndex, mylevel);
			if (levelNode == null)
			{
				return 0;
			}
			if (levelNode.Nodes.Count <= 0)
			{
				return GetUnitHeaderWidthCols(levelNode);
			}
			TreeNode firstNode = GetFirstNode(levelNode.FirstNode);
			if (firstNode.Equals(nodeByColIndex))
			{
				return GetUnitHeaderWidthCols(levelNode);
			}
			return 0;
		}

		public int GetCellHeightLevels(int colindex, int mylevel, bool isTopNodeFill, out bool flag)
		{
			flag = true;
			TreeNode nodeByColIndex = GetNodeByColIndex(colindex);
			TreeNode levelNode = GetLevelNode(nodeByColIndex, mylevel);
			int num;
			if (levelNode == null)
			{
				num = 0;
			}
			else if (nodeByColIndex.Equals(levelNode))
			{
				num = checked(iNodeLevels - mylevel + 1);
				if (isTopNodeFill && nodeByColIndex.Level < iNodeLevels - 1 && levelNode.FullPath.IndexOf("\\") >= 0)
				{
					num--;
					flag = false;
				}
			}
			else
			{
				num = 1;
				if (isTopNodeFill && levelNode != nodeByColIndex && nodeByColIndex.Level < iNodeLevels - 1)
				{
					num = 1 + iNodeLevels - 1 - nodeByColIndex.Level;
				}
			}
			return num;
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!disposedValue && disposing)
			{
				try
				{
					mydgv = null;
					columnwidth = null;
					_ColHeaderTreeView = null;
					ColLists.Clear();
					ColLists = null;
				}
				catch (Exception projectError)
				{
					ProjectData.SetProjectError(projectError);
					ProjectData.ClearProjectError();
				}
			}
			disposedValue = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
}