public void Init(Rect rect, BackendData backendData)
{
if (this.m_TreeView != null)
return;
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState();
treeViewState.columnWidths = new float[6]
{
250f,
90f,
93f,
98f,
74f,
78f
};
this.m_TreeView = new TreeView(this.m_EditorWindow, treeViewState);
ITreeViewGUI gui = (ITreeViewGUI) new TestGUI(this.m_TreeView);
ITreeViewDragging dragging = (ITreeViewDragging) new TestDragging(this.m_TreeView, this.m_BackendData);
ITreeViewDataSource data = !this.m_Lazy ? (ITreeViewDataSource) new TestDataSource(this.m_TreeView, this.m_BackendData) : (ITreeViewDataSource) new LazyTestDataSource(this.m_TreeView, this.m_BackendData);
this.m_TreeView.Init(rect, data, gui, dragging);
this.m_ColumnHeader = new TreeViewColumnHeader();
this.m_ColumnHeader.columnWidths = treeViewState.columnWidths;
this.m_ColumnHeader.minColumnWidth = 30f;
this.m_ColumnHeader.columnRenderer += new System.Action<int, Rect>(this.OnColumnRenderer);
}
private void AddVisibleChildrenRecursive(BackendData.Foo source, TreeViewItem dest)
{
if (this.IsExpanded(source.id))
{
if (source.children == null || source.children.Count <= 0)
return;
dest.children = new List<TreeViewItem>(source.children.Count);
for (int index = 0; index < source.children.Count; ++index)
{
BackendData.Foo child = source.children[index];
dest.children.Add((TreeViewItem) new FooTreeViewItem(child.id, dest.depth + 1, dest, child.name, child));
++this.itemCounter;
this.AddVisibleChildrenRecursive(child, dest.children[index]);
}
}
else
{
if (!source.hasChildren)
return;
dest.children = new List<TreeViewItem>()
{
new TreeViewItem(-1, -1, (TreeViewItem) null, string.Empty)
};
}
}
private void TestTreeWithCustomItemHeights()
{
Rect rect = new Rect(0.0f, 0.0f, this.position.width, this.position.height);
if (this.m_TreeViewWithCustomHeight == null)
{
this.m_BackendData2 = new BackendData();
this.m_BackendData2.GenerateData(300);
this.m_TreeViewWithCustomHeight = new TreeViewTestWithCustomHeight((EditorWindow) this, this.m_BackendData2, rect);
}
this.m_TreeViewWithCustomHeight.OnGUI(rect);
}
private static void GetParentsBelowRecursive(BackendData.Foo item, HashSet<int> parentIDs)
{
if (!item.hasChildren)
return;
parentIDs.Add(item.id);
using (List<BackendData.Foo>.Enumerator enumerator = item.children.GetEnumerator())
{
while (enumerator.MoveNext())
BackendData.GetParentsBelowRecursive(enumerator.Current, parentIDs);
}
}
protected override HashSet <int> GetParentsAbove(int id)
{
HashSet <int> intSet = new HashSet <int>();
for (BackendData.Foo foo = BackendData.FindNodeRecursive(this.m_Backend.root, id); foo != null; foo = foo.parent)
{
if (foo.parent != null)
{
intSet.Add(foo.parent.id);
}
}
return(intSet);
}
public HashSet <int> GetParentsBelow(int id)
{
BackendData.Foo foo = BackendData.FindItemRecursive(this.root, id);
if (foo == null)
{
return(new HashSet <int>());
}
if (this.m_RecursiveFindParentsBelow)
{
return(this.GetParentsBelowRecursive(foo));
}
return(this.GetParentsBelowStackBased(foo));
}
private void AddChildrenRecursive(BackendData.Foo source, TreeViewItem dest)
{
if (!source.hasChildren)
return;
dest.children = new List<TreeViewItem>(source.children.Count);
for (int index = 0; index < source.children.Count; ++index)
{
BackendData.Foo child = source.children[index];
dest.children.Add((TreeViewItem) new FooTreeViewItem(child.id, dest.depth + 1, dest, child.name, child));
++this.itemCounter;
this.AddChildrenRecursive(child, dest.children[index]);
}
}
public TreeViewTestWithCustomHeight(EditorWindow editorWindow, BackendData backendData, Rect rect)
{
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState();
this.m_TreeView = new TreeView(editorWindow, treeViewState);
TestGUICustomItemHeights customItemHeights = new TestGUICustomItemHeights(this.m_TreeView);
TestDragging testDragging = new TestDragging(this.m_TreeView, this.m_BackendData);
TestDataSource testDataSource1 = new TestDataSource(this.m_TreeView, this.m_BackendData);
TestDataSource testDataSource2 = testDataSource1;
System.Action action = testDataSource2.onVisibleRowsChanged + new System.Action(((TreeViewGUIWithCustomItemsHeights) customItemHeights).CalculateRowRects);
testDataSource2.onVisibleRowsChanged = action;
this.m_TreeView.Init(rect, (ITreeViewDataSource) testDataSource1, (ITreeViewGUI) customItemHeights, (ITreeViewDragging) testDragging);
testDataSource1.SetExpanded(testDataSource1.root, true);
}
public TreeViewTestWithCustomHeight(EditorWindow editorWindow, BackendData backendData, Rect rect)
{
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState();
this.m_TreeView = new TreeView(editorWindow, treeViewState);
TestGUICustomItemHeights testGUICustomItemHeights = new TestGUICustomItemHeights(this.m_TreeView);
TestDragging dragging = new TestDragging(this.m_TreeView, this.m_BackendData);
TestDataSource testDataSource = new TestDataSource(this.m_TreeView, this.m_BackendData);
TestDataSource expr_51 = testDataSource;
expr_51.onVisibleRowsChanged = (Action)Delegate.Combine(expr_51.onVisibleRowsChanged, new Action(testGUICustomItemHeights.CalculateRowRects));
this.m_TreeView.Init(rect, testDataSource, testGUICustomItemHeights, dragging);
testDataSource.SetExpanded(testDataSource.root, true);
}
private static void GetParentsBelowRecursive(BackendData.Foo item, HashSet <int> parentIDs)
{
if (!item.hasChildren)
{
return;
}
parentIDs.Add(item.id);
using (List <BackendData.Foo> .Enumerator enumerator = item.children.GetEnumerator())
{
while (enumerator.MoveNext())
{
BackendData.GetParentsBelowRecursive(enumerator.Current, parentIDs);
}
}
}
public TreeViewTestWithCustomHeight(EditorWindow editorWindow, BackendData backendData, Rect rect)
{
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState();
this.m_TreeView = new TreeView(editorWindow, treeViewState);
TestGUICustomItemHeights customItemHeights = new TestGUICustomItemHeights(this.m_TreeView);
TestDragging testDragging = new TestDragging(this.m_TreeView, this.m_BackendData);
TestDataSource testDataSource1 = new TestDataSource(this.m_TreeView, this.m_BackendData);
TestDataSource testDataSource2 = testDataSource1;
System.Action action = testDataSource2.onVisibleRowsChanged + new System.Action(((TreeViewGUIWithCustomItemsHeights)customItemHeights).CalculateRowRects);
testDataSource2.onVisibleRowsChanged = action;
this.m_TreeView.Init(rect, (ITreeViewDataSource)testDataSource1, (ITreeViewGUI)customItemHeights, (ITreeViewDragging)testDragging);
testDataSource1.SetExpanded(testDataSource1.root, true);
}
private void TestLargeTreesWithFixedItemHeightAndPingingAndFraming()
{
Rect rect1 = new Rect(0.0f, 0.0f, this.position.width / 2f, this.position.height);
Rect rect2 = new Rect(this.position.width / 2f, 0.0f, this.position.width / 2f, this.position.height);
if (this.m_TreeViewTest == null)
{
this.m_BackendData = new BackendData();
this.m_BackendData.GenerateData(1000000);
this.m_TreeViewTest = new TreeViewTest((EditorWindow) this, false);
this.m_TreeViewTest.Init(rect1, this.m_BackendData);
this.m_TreeViewTest2 = new TreeViewTest((EditorWindow) this, true);
this.m_TreeViewTest2.Init(rect2, this.m_BackendData);
}
this.m_TreeViewTest.OnGUI(rect1);
this.m_TreeViewTest2.OnGUI(rect2);
EditorGUI.DrawRect(new Rect(rect1.xMax - 1f, 0.0f, 2f, this.position.height), new Color(0.4f, 0.4f, 0.4f, 0.8f));
}
public TreeViewTestWithCustomHeight(EditorWindow editorWindow, BackendData backendData, Rect rect)
{
TestDataSource source;
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState();
this.m_TreeView = new TreeView(editorWindow, treeViewState);
TestGUICustomItemHeights gui = new TestGUICustomItemHeights(this.m_TreeView);
TestDragging dragging = new TestDragging(this.m_TreeView, this.m_BackendData);
source = new TestDataSource(this.m_TreeView, this.m_BackendData)
{
onVisibleRowsChanged = (Action)Delegate.Combine(source.onVisibleRowsChanged, new Action(gui.CalculateRowRects))
};
this.m_TreeView.Init(rect, source, gui, dragging);
source.SetExpanded(source.root, true);
}
private void TestLargeTreesWithFixedItemHeightAndPingingAndFraming()
{
Rect rect = new Rect(0f, 0f, base.position.width / 2f, base.position.height);
Rect rect2 = new Rect(base.position.width / 2f, 0f, base.position.width / 2f, base.position.height);
if (this.m_TreeViewTest == null)
{
this.m_BackendData = new BackendData();
this.m_BackendData.GenerateData(0xf4240);
bool lazy = false;
this.m_TreeViewTest = new TreeViewTest(this, lazy);
this.m_TreeViewTest.Init(rect, this.m_BackendData);
lazy = true;
this.m_TreeViewTest2 = new TreeViewTest(this, lazy);
this.m_TreeViewTest2.Init(rect2, this.m_BackendData);
}
this.m_TreeViewTest.OnGUI(rect);
this.m_TreeViewTest2.OnGUI(rect2);
EditorGUI.DrawRect(new Rect(rect.xMax - 1f, 0f, 2f, base.position.height), new Color(0.4f, 0.4f, 0.4f, 0.8f));
}
public void Init(Rect rect, BackendData backendData)
{
if (this.m_TreeView != null)
{
return;
}
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState();
treeViewState.columnWidths = new float[]
{
250f,
90f,
93f,
98f,
74f,
78f
};
this.m_TreeView = new TreeView(this.m_EditorWindow, treeViewState);
ITreeViewGUI gui = new TestGUI(this.m_TreeView);
ITreeViewDragging dragging = new TestDragging(this.m_TreeView, this.m_BackendData);
ITreeViewDataSource data;
if (this.m_Lazy)
{
data = new LazyTestDataSource(this.m_TreeView, this.m_BackendData);
}
else
{
data = new TestDataSource(this.m_TreeView, this.m_BackendData);
}
this.m_TreeView.Init(rect, data, gui, dragging);
this.m_ColumnHeader = new TreeViewColumnHeader();
this.m_ColumnHeader.columnWidths = treeViewState.columnWidths;
this.m_ColumnHeader.minColumnWidth = 30f;
TreeViewColumnHeader expr_D5 = this.m_ColumnHeader;
expr_D5.columnRenderer = (Action <int, Rect>)Delegate.Combine(expr_D5.columnRenderer, new Action <int, Rect>(this.OnColumnRenderer));
}
private HashSet<int> GetParentsBelowStackBased(BackendData.Foo searchFromThis)
{
Stack<BackendData.Foo> fooStack = new Stack<BackendData.Foo>();
fooStack.Push(searchFromThis);
HashSet<int> intSet = new HashSet<int>();
while (fooStack.Count > 0)
{
BackendData.Foo foo = fooStack.Pop();
if (foo.hasChildren)
{
intSet.Add(foo.id);
using (List<BackendData.Foo>.Enumerator enumerator = foo.children.GetEnumerator())
{
while (enumerator.MoveNext())
{
BackendData.Foo current = enumerator.Current;
fooStack.Push(current);
}
}
}
}
return intSet;
}
public static BackendData.Foo FindItemRecursive(BackendData.Foo item, int id)
{
if (item == null)
{
return(null);
}
if (item.id == id)
{
return(item);
}
if (item.children == null)
{
return(null);
}
foreach (BackendData.Foo current in item.children)
{
BackendData.Foo foo = BackendData.FindItemRecursive(current, id);
if (foo != null)
{
return(foo);
}
}
return(null);
}
public TestDragging(TreeView treeView, BackendData data)
: base(treeView)
{
this.m_BackendData = data;
}
public TestDragging(TreeView treeView, BackendData data) : base(treeView)
{
this.m_BackendData = data;
}
public void ReparentSelection(BackendData.Foo parentItem, BackendData.Foo insertAfterItem, List<BackendData.Foo> draggedItems)
{
using (List<BackendData.Foo>.Enumerator enumerator = draggedItems.GetEnumerator())
{
while (enumerator.MoveNext())
{
BackendData.Foo current = enumerator.Current;
current.parent.children.Remove(current);
current.parent = parentItem;
}
}
if (!parentItem.hasChildren)
parentItem.children = new List<BackendData.Foo>();
List<BackendData.Foo> fooList = new List<BackendData.Foo>((IEnumerable<BackendData.Foo>) parentItem.children);
int index = 0;
if (parentItem == insertAfterItem)
{
index = 0;
}
else
{
int num = parentItem.children.IndexOf(insertAfterItem);
if (num >= 0)
index = num + 1;
else
Debug.LogError((object) "Did not find insertAfterItem, should be a child of parentItem!!");
}
fooList.InsertRange(index, (IEnumerable<BackendData.Foo>) draggedItems);
parentItem.children = fooList;
}
private void AddChildrenRecursive(BackendData.Foo foo, int numChildren, bool force)
{
if (this.IDCounter > this.m_MaxItems || foo.depth >= 12 || !force && (double) Random.value < 0.5)
return;
if (foo.children == null)
foo.children = new List<BackendData.Foo>(numChildren);
for (int index = 0; index < numChildren; ++index)
foo.children.Add(new BackendData.Foo("Tud" + (object) this.IDCounter, foo.depth + 1, ++this.IDCounter)
{
parent = foo
});
if (this.IDCounter > this.m_MaxItems)
return;
using (List<BackendData.Foo>.Enumerator enumerator = foo.children.GetEnumerator())
{
while (enumerator.MoveNext())
this.AddChildrenRecursive(enumerator.Current, Random.Range(3, 15), false);
}
}
public LazyTestDataSource(TreeView treeView, BackendData data)
: base(treeView)
{
this.m_Backend = data;
this.FetchData();
}
public static BackendData.Foo FindNodeRecursive(BackendData.Foo item, int id)
{
if (item == null)
return (BackendData.Foo) null;
if (item.id == id)
return item;
if (item.children == null)
return (BackendData.Foo) null;
using (List<BackendData.Foo>.Enumerator enumerator = item.children.GetEnumerator())
{
while (enumerator.MoveNext())
{
BackendData.Foo nodeRecursive = BackendData.FindNodeRecursive(enumerator.Current, id);
if (nodeRecursive != null)
return nodeRecursive;
}
}
return (BackendData.Foo) null;
}
public LazyTestDataSource(TreeView treeView, BackendData data) : base(treeView)
{
this.m_Backend = data;
this.FetchData();
}
private HashSet<int> GetParentsBelowRecursive(BackendData.Foo searchFromThis)
{
HashSet<int> parentIDs = new HashSet<int>();
BackendData.GetParentsBelowRecursive(searchFromThis, parentIDs);
return parentIDs;
}
