mirror of
https://github.com/ZuneDev/ZuneShell.dll.git
synced 2026-07-27 13:11:51 -07:00
Add decompiled projects for UIX and UIXControls
This commit is contained in:
Joshua Askharoun
@@ -0,0 +1,444 @@
|
||||
// Decompiled with JetBrains decompiler
|
||||
// Type: Microsoft.Iris.IndexedTree
|
||||
// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
|
||||
// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
|
||||
// Assembly location: C:\Program Files\Zune\UIX.dll
|
||||
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace Microsoft.Iris
|
||||
{
|
||||
internal class IndexedTree
|
||||
{
|
||||
private object _lockObj;
|
||||
private IndexedTree.TreeNode _root;
|
||||
private IndexedTree.TreeNode _poolHead;
|
||||
private int _lastSearchedIndex;
|
||||
|
||||
public IndexedTree()
|
||||
{
|
||||
this._lastSearchedIndex = -1;
|
||||
this._lockObj = new object();
|
||||
}
|
||||
|
||||
private void SetRoot(IndexedTree.TreeNode newValue)
|
||||
{
|
||||
if (this._root == newValue)
|
||||
return;
|
||||
this._root = newValue;
|
||||
this._lastSearchedIndex = -1;
|
||||
}
|
||||
|
||||
private IndexedTree.TreeNode AcquireTreeNode()
|
||||
{
|
||||
IndexedTree.TreeNode treeNode = this._poolHead;
|
||||
if (this._poolHead != null)
|
||||
{
|
||||
this._poolHead = this._poolHead.parent;
|
||||
treeNode.parent = (IndexedTree.TreeNode)null;
|
||||
}
|
||||
else
|
||||
treeNode = new IndexedTree.TreeNode();
|
||||
return treeNode;
|
||||
}
|
||||
|
||||
private void ReclaimTreeNode(IndexedTree.TreeNode node)
|
||||
{
|
||||
node.parent = this._poolHead;
|
||||
node.left = (IndexedTree.TreeNode)null;
|
||||
node.right = (IndexedTree.TreeNode)null;
|
||||
this._poolHead = node;
|
||||
}
|
||||
|
||||
public void Store(int index, object data)
|
||||
{
|
||||
lock (this._lockObj)
|
||||
{
|
||||
IndexedTree.TreeNode newValue = this.Find(index);
|
||||
if (newValue == null)
|
||||
{
|
||||
newValue = this.AcquireTreeNode();
|
||||
newValue.delta = index;
|
||||
newValue.parent = (IndexedTree.TreeNode)null;
|
||||
if (this._root != null)
|
||||
{
|
||||
this._root.parent = newValue;
|
||||
if (this._root.delta < index)
|
||||
{
|
||||
newValue.left = this._root;
|
||||
if (this._root.right != null && this._root.right.delta + this._root.delta > index)
|
||||
{
|
||||
this._root.right.parent = newValue;
|
||||
newValue.right = this._root.right;
|
||||
newValue.right.delta = this._root.right.delta + this._root.delta - index;
|
||||
this._root.right = (IndexedTree.TreeNode)null;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
newValue.right = this._root;
|
||||
if (this._root.left != null && this._root.left.delta + this._root.delta < index)
|
||||
{
|
||||
this._root.left.parent = newValue;
|
||||
newValue.left = this._root.left;
|
||||
newValue.left.delta = this._root.left.delta + this._root.delta - index;
|
||||
this._root.left = (IndexedTree.TreeNode)null;
|
||||
}
|
||||
}
|
||||
this._root.delta -= index;
|
||||
}
|
||||
this.SetRoot(newValue);
|
||||
}
|
||||
newValue.data = data;
|
||||
}
|
||||
}
|
||||
|
||||
public void Remove(int index)
|
||||
{
|
||||
lock (this._lockObj)
|
||||
{
|
||||
IndexedTree.TreeNode node = this.Find(index);
|
||||
if (node == null)
|
||||
return;
|
||||
IndexedTree.TreeNode treeNode;
|
||||
for (; node.left != null; node = treeNode)
|
||||
{
|
||||
if (node.right == null)
|
||||
{
|
||||
IndexedTree.TreeNode left = node.left;
|
||||
if (node == this._root)
|
||||
this.SetRoot(left);
|
||||
else if (node.IsRightBranch)
|
||||
node.parent.right = left;
|
||||
else
|
||||
node.parent.left = left;
|
||||
left.delta += node.delta;
|
||||
left.parent = node.parent;
|
||||
this.ReclaimTreeNode(node);
|
||||
return;
|
||||
}
|
||||
treeNode = node.left;
|
||||
int num1 = index + treeNode.delta;
|
||||
while (treeNode.right != null)
|
||||
{
|
||||
treeNode = treeNode.right;
|
||||
num1 += treeNode.delta;
|
||||
}
|
||||
node.data = treeNode.data;
|
||||
node.delta = num1;
|
||||
if (node == this._root)
|
||||
this._lastSearchedIndex = -1;
|
||||
int num2 = num1 - index;
|
||||
node.left.delta -= num2;
|
||||
node.right.delta -= num2;
|
||||
}
|
||||
IndexedTree.TreeNode right = node.right;
|
||||
if (node == this._root)
|
||||
this.SetRoot(right);
|
||||
else if (node.IsRightBranch)
|
||||
node.parent.right = right;
|
||||
else
|
||||
node.parent.left = right;
|
||||
if (right != null)
|
||||
{
|
||||
right.delta += node.delta;
|
||||
right.parent = node.parent;
|
||||
}
|
||||
this.ReclaimTreeNode(node);
|
||||
}
|
||||
}
|
||||
|
||||
public bool TryGetData(int index, out object data)
|
||||
{
|
||||
lock (this._lockObj)
|
||||
{
|
||||
IndexedTree.TreeNode treeNode = this.Find(index);
|
||||
data = treeNode == null ? (object)null : treeNode.data;
|
||||
return treeNode != null;
|
||||
}
|
||||
}
|
||||
|
||||
public void InsertRange(int index, int count)
|
||||
{
|
||||
lock (this._lockObj)
|
||||
{
|
||||
this.Find(index);
|
||||
if (this._root == null)
|
||||
return;
|
||||
IndexedTree.TreeNode node = this._root;
|
||||
if (this._root.delta < index)
|
||||
node = this._root.right;
|
||||
this.ChangeIndex(node, count);
|
||||
}
|
||||
}
|
||||
|
||||
private void ChangeIndex(IndexedTree.TreeNode node, int amount)
|
||||
{
|
||||
if (node == null)
|
||||
return;
|
||||
node.delta += amount;
|
||||
if (node.left == null)
|
||||
return;
|
||||
node.left.delta -= amount;
|
||||
}
|
||||
|
||||
public void Insert(int index, bool setValue, object data)
|
||||
{
|
||||
lock (this._lockObj)
|
||||
{
|
||||
this.InsertRange(index, 1);
|
||||
if (!setValue)
|
||||
return;
|
||||
this.Store(index, data);
|
||||
}
|
||||
}
|
||||
|
||||
public void RemoveIndex(int index)
|
||||
{
|
||||
lock (this._lockObj)
|
||||
{
|
||||
IndexedTree.TreeNode treeNode = this.Find(index);
|
||||
if (treeNode != null)
|
||||
{
|
||||
if (treeNode.right != null)
|
||||
--treeNode.right.delta;
|
||||
this.Remove(index);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (this._root == null)
|
||||
return;
|
||||
IndexedTree.TreeNode node = this._root;
|
||||
if (this._root.delta < index)
|
||||
node = this._root.right;
|
||||
this.ChangeIndex(node, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void Clear()
|
||||
{
|
||||
lock (this._lockObj)
|
||||
this.SetRoot((IndexedTree.TreeNode)null);
|
||||
}
|
||||
|
||||
public bool Contains(int index)
|
||||
{
|
||||
lock (this._lockObj)
|
||||
return this.Find(index) != null;
|
||||
}
|
||||
|
||||
public object this[int index]
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (this._lockObj)
|
||||
{
|
||||
object data;
|
||||
this.TryGetData(index, out data);
|
||||
return data;
|
||||
}
|
||||
}
|
||||
set
|
||||
{
|
||||
lock (this._lockObj)
|
||||
this.Store(index, value);
|
||||
}
|
||||
}
|
||||
|
||||
private IndexedTree.TreeNode Find(int index)
|
||||
{
|
||||
if (this._lastSearchedIndex == index && this._root != null)
|
||||
return this._root.delta != index ? (IndexedTree.TreeNode)null : this._root;
|
||||
this._lastSearchedIndex = index;
|
||||
IndexedTree.TreeNode treeNode = this._root;
|
||||
IndexedTree.TreeNode node = (IndexedTree.TreeNode)null;
|
||||
int num = 0;
|
||||
bool flag = false;
|
||||
while (!flag && treeNode != null)
|
||||
{
|
||||
num += treeNode.delta;
|
||||
node = treeNode;
|
||||
if (num == index)
|
||||
flag = true;
|
||||
else
|
||||
treeNode = num <= index ? treeNode.right : treeNode.left;
|
||||
}
|
||||
if (node != null)
|
||||
this.Splay(node);
|
||||
this._lastSearchedIndex = index;
|
||||
return !flag ? (IndexedTree.TreeNode)null : treeNode;
|
||||
}
|
||||
|
||||
private void Splay(IndexedTree.TreeNode node)
|
||||
{
|
||||
for (IndexedTree.TreeNode parent = node.parent; parent != null; parent = node.parent)
|
||||
{
|
||||
if (parent.parent == null)
|
||||
this.Zig(node);
|
||||
else if (node.IsLeftBranch == parent.IsLeftBranch)
|
||||
this.ZigZig(node, parent);
|
||||
else
|
||||
this.ZigZag(node);
|
||||
}
|
||||
this.SetRoot(node);
|
||||
}
|
||||
|
||||
private void Zig(IndexedTree.TreeNode item) => this.Rotate(item);
|
||||
|
||||
private void ZigZig(IndexedTree.TreeNode item, IndexedTree.TreeNode parent)
|
||||
{
|
||||
this.Rotate(parent);
|
||||
this.Rotate(item);
|
||||
}
|
||||
|
||||
private void ZigZag(IndexedTree.TreeNode item)
|
||||
{
|
||||
this.Rotate(item);
|
||||
this.Rotate(item);
|
||||
}
|
||||
|
||||
private void Rotate(IndexedTree.TreeNode child)
|
||||
{
|
||||
IndexedTree.TreeNode parent = child.parent;
|
||||
int num1 = -child.delta;
|
||||
int num2 = child.delta + parent.delta;
|
||||
IndexedTree.TreeNode treeNode;
|
||||
if (child.IsLeftBranch)
|
||||
{
|
||||
treeNode = child.right;
|
||||
parent.left = treeNode;
|
||||
child.parent = parent.parent;
|
||||
child.right = parent;
|
||||
}
|
||||
else
|
||||
{
|
||||
treeNode = child.left;
|
||||
parent.right = treeNode;
|
||||
child.parent = parent.parent;
|
||||
child.left = parent;
|
||||
}
|
||||
if (treeNode != null)
|
||||
{
|
||||
treeNode.parent = parent;
|
||||
treeNode.delta += child.delta;
|
||||
}
|
||||
if (child.parent != null)
|
||||
{
|
||||
if (num2 < 0)
|
||||
child.parent.left = child;
|
||||
else
|
||||
child.parent.right = child;
|
||||
}
|
||||
child.delta = num2;
|
||||
parent.delta = num1;
|
||||
parent.parent = child;
|
||||
}
|
||||
|
||||
public IndexedTree.TreeNode Root => this._root;
|
||||
|
||||
public IndexedTree.TreeEnumerator GetEnumerator() => new IndexedTree.TreeEnumerator(this);
|
||||
|
||||
[Conditional("DEBUG")]
|
||||
private void DEBUG_BumpGeneration()
|
||||
{
|
||||
}
|
||||
|
||||
public class TreeNode
|
||||
{
|
||||
public int delta;
|
||||
public IndexedTree.TreeNode left;
|
||||
public IndexedTree.TreeNode right;
|
||||
public IndexedTree.TreeNode parent;
|
||||
public object data;
|
||||
|
||||
public bool IsLeftBranch => this.delta < 0;
|
||||
|
||||
public bool IsRightBranch => this.delta > 0;
|
||||
}
|
||||
|
||||
public struct TreeEntry
|
||||
{
|
||||
private int _index;
|
||||
private object _data;
|
||||
|
||||
public TreeEntry(int index, object data)
|
||||
{
|
||||
this._index = index;
|
||||
this._data = data;
|
||||
}
|
||||
|
||||
public int Index => this._index;
|
||||
|
||||
public object Value => this._data;
|
||||
}
|
||||
|
||||
public struct TreeEnumerator
|
||||
{
|
||||
private IndexedTree _tree;
|
||||
private bool _started;
|
||||
private IndexedTree.TreeNode _current;
|
||||
private int _index;
|
||||
|
||||
public TreeEnumerator(IndexedTree tree)
|
||||
{
|
||||
this._tree = tree;
|
||||
this._current = this._tree._root;
|
||||
this._started = false;
|
||||
this._index = this._current != null ? this._current.delta : -1;
|
||||
}
|
||||
|
||||
[Conditional("DEBUG")]
|
||||
private void DEBUG_CheckGeneration()
|
||||
{
|
||||
}
|
||||
|
||||
private void MoveToLeftmostChild()
|
||||
{
|
||||
if (this._current == null)
|
||||
return;
|
||||
while (this._current.left != null)
|
||||
{
|
||||
this._current = this._current.left;
|
||||
this._index += this._current.delta;
|
||||
}
|
||||
}
|
||||
|
||||
public bool MoveNext()
|
||||
{
|
||||
lock (this._tree._lockObj)
|
||||
{
|
||||
if (!this._started)
|
||||
{
|
||||
this._started = true;
|
||||
this.MoveToLeftmostChild();
|
||||
}
|
||||
else if (this._current.right != null)
|
||||
{
|
||||
this._current = this._current.right;
|
||||
this._index += this._current.delta;
|
||||
this.MoveToLeftmostChild();
|
||||
}
|
||||
else if (this._current.IsLeftBranch)
|
||||
{
|
||||
this._index -= this._current.delta;
|
||||
this._current = this._current.parent;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (; this._current != null && this._current.IsRightBranch; this._current = this._current.parent)
|
||||
this._index -= this._current.delta;
|
||||
if (this._current != null)
|
||||
{
|
||||
this._index -= this._current.delta;
|
||||
this._current = this._current.parent;
|
||||
}
|
||||
}
|
||||
return this._current != null;
|
||||
}
|
||||
}
|
||||
|
||||
public IndexedTree.TreeEntry Current => new IndexedTree.TreeEntry(this._index, this._current.data);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user