UltimateFishing/Assets/Scripts/Assembly-CSharp/UIWidgetsSamples/TestTreeView.cs

using System;
using System.Collections.Generic;
using System.Linq;
using UIWidgets;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace UIWidgetsSamples
{
	public class TestTreeView : MonoBehaviour
	{
		public TreeView Tree;

		private ObservableList<TreeNode<TreeViewItem>> nodes;

		private Comparison<TreeNode<TreeViewItem>> comparisonAsc = (TreeNode<TreeViewItem> x, TreeNode<TreeViewItem> y) => (x.Item.LocalizedName ?? x.Item.Name).CompareTo(y.Item.LocalizedName ?? y.Item.Name);

		private Comparison<TreeNode<TreeViewItem>> comparisonDesc = (TreeNode<TreeViewItem> x, TreeNode<TreeViewItem> y) => -(x.Item.LocalizedName ?? x.Item.Name).CompareTo(y.Item.LocalizedName ?? y.Item.Name);

		private Dictionary<string, ObservableList<TreeNode<TreeViewItem>>> dNodes;

		private ObservableList<TreeNode<TreeViewItem>> nodes5k;

		private ObservableList<TreeNode<TreeViewItem>> nodes10k;

		private ObservableList<TreeNode<TreeViewItem>> nodes50k;

		public TestTreeView()
		{
			List<int> items = new List<int> { 5, 5, 2 };
			nodes = GenerateTreeNodes(items);
		}

		private void Start()
		{
			Tree.Start();
			Tree.Nodes = nodes;
		}

		public void SetComparison()
		{
			(nodes[0].Nodes as ObservableList<TreeNode<TreeViewItem>>).Comparison = comparisonDesc;
			nodes.Comparison = comparisonDesc;
		}

		public void AddSubNodes()
		{
			if (nodes.Count != 0)
			{
				TreeNode<TreeViewItem> treeNode = nodes[0];
				if (treeNode.Nodes == null)
				{
					treeNode.Nodes = new ObservableList<TreeNode<TreeViewItem>>();
				}
				TreeViewItem nodeItem = new TreeViewItem("Subnode 1");
				TreeNode<TreeViewItem> item = new TreeNode<TreeViewItem>(nodeItem);
				TreeViewItem nodeItem2 = new TreeViewItem("Subnode 2");
				TreeNode<TreeViewItem> item2 = new TreeNode<TreeViewItem>(nodeItem2);
				TreeViewItem nodeItem3 = new TreeViewItem("Subnode 3");
				TreeNode<TreeViewItem> item3 = new TreeNode<TreeViewItem>(nodeItem3);
				treeNode.Nodes.BeginUpdate();
				treeNode.Nodes.Add(item);
				treeNode.Nodes.Add(item2);
				treeNode.Nodes.Add(item3);
				treeNode.Nodes.EndUpdate();
			}
		}

		public void SetListeners()
		{
			Tree.NodeSelected.AddListener(NodeSelected);
			Tree.NodeDeselected.AddListener(NodeDeselected);
		}

		public void NodeSelected(TreeNode<TreeViewItem> node)
		{
			Debug.Log(node.Item.Name + " selected");
		}

		public void NodeDeselected(TreeNode<TreeViewItem> node)
		{
			Debug.Log(node.Item.Name + " deselected");
		}

		public void GetSelectedNodes()
		{
			List<TreeNode<TreeViewItem>> selectedNodes = Tree.SelectedNodes;
			if (selectedNodes != null)
			{
				selectedNodes.ForEach(delegate(TreeNode<TreeViewItem> node)
				{
					Debug.Log(node.Item.Name);
				});
			}
		}

		public void SetOnlyOnSelectable()
		{
			Tree.Multiple = false;
		}

		public void SetMultipleSelectable()
		{
			Tree.Multiple = true;
		}

		public void SortAsc()
		{
			nodes.BeginUpdate();
			ApplyNodesSort(nodes, comparisonAsc);
			nodes.EndUpdate();
		}

		public void SortDesc()
		{
			nodes.BeginUpdate();
			ApplyNodesSort(nodes, comparisonDesc);
			nodes.EndUpdate();
		}

		private void ApplyNodesSort<T>(ObservableList<TreeNode<T>> nodes, Comparison<TreeNode<T>> comparison)
		{
			nodes.Sort(comparison);
			nodes.ForEach(delegate(TreeNode<T> node)
			{
				if (node.Nodes != null)
				{
					ApplyNodesSort(node.Nodes as ObservableList<TreeNode<T>>, comparison);
				}
			});
		}

		public void TestRemove(string name)
		{
			RemoveByName(nodes, name);
		}

		public void RemoveByName(ObservableList<TreeNode<TreeViewItem>> nodes, string name)
		{
			Remove(nodes, (TreeNode<TreeViewItem> x) => x.Item.Name == name);
		}

		public bool Remove<T>(ObservableList<TreeNode<T>> nodes, Predicate<TreeNode<T>> match)
		{
			TreeNode<T> treeNode = nodes.Find(match);
			if (treeNode != null)
			{
				treeNode.Parent = null;
				return true;
			}
			foreach (TreeNode<T> item in (IEnumerable<TreeNode<T>>)nodes)
			{
				if (item.Nodes == null || !Remove(item.Nodes as ObservableList<TreeNode<T>>, match))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		public void TestReorder(string name)
		{
			ChangePositionByName(nodes, name, 0);
		}

		public void ChangePositionByName(ObservableList<TreeNode<TreeViewItem>> nodes, string name, int position)
		{
			ChangePosition(nodes, (TreeNode<TreeViewItem> x) => x.Item.Name == name, position);
		}

		public bool ChangePosition<T>(ObservableList<TreeNode<T>> nodes, Predicate<TreeNode<T>> match, int position)
		{
			TreeNode<T> treeNode = nodes.Find(match);
			if (treeNode != null)
			{
				nodes.BeginUpdate();
				nodes.Remove(treeNode);
				nodes.Insert(position, treeNode);
				nodes.EndUpdate();
				return true;
			}
			foreach (TreeNode<T> item in (IEnumerable<TreeNode<T>>)nodes)
			{
				if (item.Nodes == null || !ChangePosition(item.Nodes as ObservableList<TreeNode<T>>, match, position))
				{
					continue;
				}
				return true;
			}
			return false;
		}

		public void Test10K()
		{
			List<int> list = new List<int>();
			list.Add(10);
			list.Add(10);
			list.Add(10);
			list.Add(10);
			List<int> items = list;
			nodes = GenerateTreeNodes(items);
			Tree.Nodes = nodes;
		}

		public void LongNames()
		{
			List<int> list = new List<int>();
			list.Add(2);
			list.Add(2);
			list.Add(2);
			list.Add(2);
			list.Add(2);
			list.Add(2);
			list.Add(2);
			list.Add(2);
			list.Add(2);
			List<int> items = list;
			nodes = GenerateTreeNodes(items);
			Tree.Nodes = nodes;
		}

		public void PerformanceCheck(string k)
		{
			if (dNodes == null)
			{
				dNodes = new Dictionary<string, ObservableList<TreeNode<TreeViewItem>>>();
				List<int> list = new List<int>();
				list.Add(10);
				list.Add(10);
				list.Add(10);
				List<int> items = list;
				dNodes.Add("1k", GenerateTreeNodes(items));
				list = new List<int>();
				list.Add(5);
				list.Add(10);
				list.Add(10);
				list.Add(10);
				List<int> items2 = list;
				dNodes.Add("5k", GenerateTreeNodes(items2));
				list = new List<int>();
				list.Add(10);
				list.Add(10);
				list.Add(10);
				list.Add(10);
				List<int> items3 = list;
				dNodes.Add("10k", GenerateTreeNodes(items3));
				list = new List<int>();
				list.Add(5);
				list.Add(10);
				list.Add(10);
				list.Add(10);
				list.Add(10);
				List<int> items4 = list;
				dNodes.Add("50k", GenerateTreeNodes(items4));
			}
			nodes = dNodes[k];
			Tree.Nodes = dNodes[k];
		}

		public void SetTreeNodes()
		{
			Tree.Nodes = nodes;
			nodes.BeginUpdate();
			TreeViewItem nodeItem = new TreeViewItem("added");
			TreeNode<TreeViewItem> item = new TreeNode<TreeViewItem>(nodeItem);
			nodes.Add(item);
			nodes[1].IsVisible = false;
			nodes[2].Nodes[1].IsVisible = false;
			nodes.EndUpdate();
		}

		public void AddNode()
		{
			TreeViewItem nodeItem = new TreeViewItem("New node");
			TreeNode<TreeViewItem> item = new TreeNode<TreeViewItem>(nodeItem);
			nodes.Add(item);
		}

		public void ToggleNode()
		{
			nodes[0].Nodes[0].IsExpanded = !nodes[0].Nodes[0].IsExpanded;
		}

		public void ChangeNodesName()
		{
			nodes[0].Item.Name = "Node renamed from code";
			nodes[0].Nodes[1].Item.Name = "Another node renamed from code";
		}

		public void ResetFilter()
		{
			nodes.BeginUpdate();
			nodes.ForEach(SetVisible);
			nodes.EndUpdate();
		}

		private void SetVisible(TreeNode<TreeViewItem> node)
		{
			if (node.Nodes != null)
			{
				node.Nodes.ForEach(SetVisible);
			}
			node.IsVisible = true;
		}

		public void Filter(string nameContains)
		{
			nodes.BeginUpdate();
			SampleFilter(nodes, (TreeViewItem x) => x.Name.Contains(nameContains));
			nodes.EndUpdate();
		}

		public void Clear()
		{
			nodes = new ObservableList<TreeNode<TreeViewItem>>();
			Tree.Nodes = nodes;
		}

		private bool SampleFilter(IObservableList<TreeNode<TreeViewItem>> nodes, Func<TreeViewItem, bool> filterFunc)
		{
			return nodes.Count(delegate(TreeNode<TreeViewItem> x)
			{
				bool flag = x.Nodes != null && SampleFilter(x.Nodes, filterFunc);
				x.IsVisible = flag || filterFunc(x.Item);
				return x.IsVisible;
			}) > 0;
		}

		public static ObservableList<TreeNode<TreeViewItem>> GenerateTreeNodes(List<int> items, string nameStartsWith = "Node ", bool isExpanded = true)
		{
			return Enumerable.Range(1, items[0]).Select(delegate(int x)
			{
				string text = nameStartsWith + x;
				TreeViewItem nodeItem = new TreeViewItem(text);
				ObservableList<TreeNode<TreeViewItem>> nodeNodes = ((items.Count <= 1) ? null : GenerateTreeNodes(items.GetRange(1, items.Count - 1), text + " - ", isExpanded));
				return new TreeNode<TreeViewItem>(nodeItem, nodeNodes, isExpanded);
			}).ToObservableList();
		}

		public void ReloadScene()
		{
			SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
		}
	}
}