private void SetRootNode(EvaluationWrapper evaluation) {
_rootNode = new ObservableTreeNode(
new VariableNode(_settings, evaluation),
Comparer<ITreeNode>.Create(Comparison));
RootTreeGrid.ItemsSource = new TreeNodeCollection(_rootNode).ItemList;
}
public void CleanupTest()
{
_rootNode.CollectionChanged -= Target_CollectionChanged;
_rootNode = null;
_linearized = null;
}
public void RebuildList(bool overrideIncludeRoot = false) {
this.RemoveAllHandlers();
// Build the list from scratch - add the rootItem and its handlers, and then all the children if any.
this.excludedRootItem = null;
this.itemList.Clear();
ObservableTreeNode rootItem = _rootNode;
if (rootItem != null) {
this.AddHandlers(rootItem);
if (this.includeRoot && !overrideIncludeRoot) {
this.itemList.Add(rootItem);
} else {
this.excludedRootItem = rootItem;
}
// if not including the root, always expand
if (rootItem.IsExpanded || !this.includeRoot) {
// if we're including the root in the list, we want to start
// inserting children after it (so index 1, root is in 0);
// if no root, start adding children at the beginning of the list
int index = this.includeRoot ? 1 : 0;
this.InsertChildrenInList(rootItem, ref index);
}
}
}
public ObservableTreeNodeTest()
{
_testNodeComparer = Comparer <ITreeNode> .Create(TestNode.Comparison);
_rootNode = new ObservableTreeNode(new TestNode(0), _testNodeComparer);
_linearized = new TreeNodeCollection(_rootNode);
}
private void SetRootNode() {
_rootNode = new ObservableTreeNode(
new TestNode(null, "0"),
Comparer<ITreeNode>.Create(Comparison));
_nodeCollection = new TreeNodeCollection(_rootNode);
RootTreeGrid.ItemsSource = _nodeCollection.ItemList;
}
public void InitializeTest()
{
_linearized = new List<ObservableTreeNode>();
_rootNode = new ObservableTreeNode(new TestNode(0));
_rootNode.CollectionChanged += Target_CollectionChanged;
_linearized.Add(_rootNode);
}
public void ObservableTreeNodeConstructorTest()
{
var target = new ObservableTreeNode(new TestNode(1234), _testNodeComparer);
target.HasChildren.Should().BeFalse("It is default HasChildren value");
target.Children.Should().BeEmpty();
target.Model.Content.Should().Be("1234");
}
private void SetRootNode()
{
_rootNode = new ObservableTreeNode(
new TestNode(null, "0"),
Comparer <ITreeNode> .Create(Comparison));
_nodeCollection = new TreeNodeCollection(_rootNode);
RootTreeGrid.ItemsSource = _nodeCollection.ItemList;
}
public TreeNodeCollection(
ObservableTreeNode rootNode,
bool includeRoot = false) {
_rootNode = rootNode;
this.itemList = new ObservableCollection<ObservableTreeNode>();
this.readonlyList = new ReadOnlyObservableCollection<ObservableTreeNode>(this.itemList);
this.includeRoot = includeRoot;
this.RebuildList();
// Expand root node always
_rootNode.IsExpanded = true;
}
private void InsertChildrenInList(ObservableTreeNode parentItem, ref int index) {
foreach (var childItem in parentItem.Children) {
if (childItem.IsVisible) {
this.AddHandlers(childItem);
this.itemList.Insert(index, childItem);
index++;
if (childItem.IsExpanded) {
this.InsertChildrenInList(childItem, ref index);
}
}
}
}
public void AddChildTest()
{
var target = _rootNode;
target.AddChild(new ObservableTreeNode(new TestNode(10)));
var added = new ObservableTreeNode(new TestNode(11));
added.AddChild(new ObservableTreeNode(new TestNode(111)));
added.AddChild(new ObservableTreeNode(new TestNode(112)));
target.AddChild(added);
target.AddChild(new ObservableTreeNode(new TestNode(12)));
int[] expected = { 0, 10, 11, 111, 112, 12 };
AssertLinearized(expected, _linearized, target);
}
public void AddTreeTest()
{
var target = _rootNode;
target.AddChild(new ObservableTreeNode(new TestNode(12), _testNodeComparer));
target.AddChild(new ObservableTreeNode(new TestNode(10), _testNodeComparer));
var tree = new ObservableTreeNode(new TestNode(11), _testNodeComparer);
tree.IsExpanded = true;
tree.AddChild(new ObservableTreeNode(new TestNode(111), _testNodeComparer));
tree.AddChild(new ObservableTreeNode(new TestNode(112), _testNodeComparer));
target.AddChild(tree);
int[] expected = { 10, 11, 111, 112, 12 };
_linearized.ItemList.Should().Equal(expected, (a, e) => Equals(a.Model.Content, e.ToString()));
}
private ObservableTreeNode GetTestTree()
{
var n1 = new ObservableTreeNode(new TestNode(11), _testNodeComparer);
var n11 = new ObservableTreeNode(new TestNode(111), _testNodeComparer);
var n12 = new ObservableTreeNode(new TestNode(112), _testNodeComparer);
n1.AddChild(n11);
n1.AddChild(n12);
var n2 = new ObservableTreeNode(new TestNode(12), _testNodeComparer);
var n21 = new ObservableTreeNode(new TestNode(121), _testNodeComparer);
var n22 = new ObservableTreeNode(new TestNode(122), _testNodeComparer);
n2.AddChild(n21);
n2.AddChild(n22);
var n3 = new ObservableTreeNode(new TestNode(13), _testNodeComparer);
var n311 = new ObservableTreeNode(new TestNode(1311), _testNodeComparer);
var n312 = new ObservableTreeNode(new TestNode(1312), _testNodeComparer);
var n31 = new ObservableTreeNode(new TestNode(131), _testNodeComparer);
n31.AddChild(n311);
n31.AddChild(n312);
var n32 = new ObservableTreeNode(new TestNode(132), _testNodeComparer);
n3.AddChild(n31);
n3.AddChild(n32);
var n = new ObservableTreeNode(new TestNode(1), _testNodeComparer);
n.AddChild(n1);
n.AddChild(n2);
n.AddChild(n3);
return(n);
}
private void AssertLinearized(int[] expected, IList<ObservableTreeNode> target, ObservableTreeNode targetTree)
{
Assert.AreEqual(expected.Length, targetTree.Count);
Assert.AreEqual(expected.Length, target.Count);
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], target[i].Content, string.Format("{0}th item is different", i));
}
}
private void RemoveHandlers(ObservableTreeNode treeItem) {
treeItem.PropertyChanged -= VirtualizingTreeItem_PropertyChanged;
treeItem.Children.CollectionChanged -= VirtualizingTreeItem_ChildrenCollectionChanged;
}
private void OnCreateLocation(object sender, EventArgs args)
{
// check if an item is already created
IEnumerator iter = Locations.Inventory.Items.GetEnumerator();
if(!iter.MoveNext()){
Console.WriteLine("You need to create an item first in order to add a location.");
return;
}
// create the new location
Location loc = Locations.New((Model.Item)iter.Current);
ObservableTreeNode<Location> otn = new ObservableTreeNode<Location>(loc,null);
// add the new item as a sibling of the first selection
TreePath[] selections = locationsView.Selection.GetSelectedRows();
TreeModelFilter filter = (TreeModelFilter)locationsView.Model;
if(selections != null && selections.Length != 0){
// something is selected
TreePath pos = filter.ConvertPathToChildPath(selections[0]);
pos.Next();
Locations.Positions.InsertItemAt(pos.Indices,otn);
}
else {
// nothing is selected
Locations.Positions.Add(otn);
}
}
public void AddChildInOrderTest() {
var target = _rootNode;
target.AddChild(new ObservableTreeNode(new TestNode(10), _testNodeComparer));
var added = new ObservableTreeNode(new TestNode(11), _testNodeComparer);
added.IsExpanded = true;
added.AddChild(new ObservableTreeNode(new TestNode(111), _testNodeComparer));
added.AddChild(new ObservableTreeNode(new TestNode(112), _testNodeComparer));
target.AddChild(added);
target.AddChild(new ObservableTreeNode(new TestNode(12), _testNodeComparer));
int[] expected = { 10, 11, 111, 112, 12 };
_linearized.ItemList.Should().Equal(expected, (a, e) => Equals(a.Model.Content, e.ToString()));
}
public void ObservableTreeNodeConstructorTest() {
var target = new ObservableTreeNode(new TestNode(1234), _testNodeComparer);
target.HasChildren.Should().BeFalse("It is default HasChildren value");
target.Children.Should().BeEmpty();
target.Model.Content.Should().Be("1234");
}
private ObservableTreeNode GetTestTree() {
var n1 = new ObservableTreeNode(new TestNode(11), _testNodeComparer);
var n11 = new ObservableTreeNode(new TestNode(111), _testNodeComparer);
var n12 = new ObservableTreeNode(new TestNode(112), _testNodeComparer);
n1.AddChild(n11);
n1.AddChild(n12);
var n2 = new ObservableTreeNode(new TestNode(12), _testNodeComparer);
var n21 = new ObservableTreeNode(new TestNode(121), _testNodeComparer);
var n22 = new ObservableTreeNode(new TestNode(122), _testNodeComparer);
n2.AddChild(n21);
n2.AddChild(n22);
var n3 = new ObservableTreeNode(new TestNode(13), _testNodeComparer);
var n311 = new ObservableTreeNode(new TestNode(1311), _testNodeComparer);
var n312 = new ObservableTreeNode(new TestNode(1312), _testNodeComparer);
var n31 = new ObservableTreeNode(new TestNode(131), _testNodeComparer);
n31.AddChild(n311);
n31.AddChild(n312);
var n32 = new ObservableTreeNode(new TestNode(132), _testNodeComparer);
n3.AddChild(n31);
n3.AddChild(n32);
var n = new ObservableTreeNode(new TestNode(1), _testNodeComparer);
n.AddChild(n1);
n.AddChild(n2);
n.AddChild(n3);
return n;
}
public void ObservableTreeNodeConstructorTest()
{
var target = new ObservableTreeNode(new TestNode(1234));
Assert.AreEqual(false, target.HasChildren, "Default HasChildren value");
Assert.AreEqual(1234, target.Content);
Assert.AreEqual(1, target.Count);
Assert.AreEqual(0, target.Children.Count);
}
private ObservableTreeNode GetTestTree()
{
var n1 = new ObservableTreeNode(new TestNode(11));
var n11 = new ObservableTreeNode(new TestNode(111));
var n12 = new ObservableTreeNode(new TestNode(112));
n1.InsertChildAt(0, n11);
n1.InsertChildAt(1, n12);
var n2 = new ObservableTreeNode(new TestNode(12));
var n21 = new ObservableTreeNode(new TestNode(121));
var n22 = new ObservableTreeNode(new TestNode(122));
n2.InsertChildAt(0, n21);
n2.InsertChildAt(1, n22);
var n3 = new ObservableTreeNode(new TestNode(13));
var n311 = new ObservableTreeNode(new TestNode(1311));
var n312 = new ObservableTreeNode(new TestNode(1312));
var n31 = new ObservableTreeNode(new TestNode(131));
n31.InsertChildAt(0, n311);
n31.InsertChildAt(1, n312);
var n32 = new ObservableTreeNode(new TestNode(132));
n3.InsertChildAt(0, n31);
n3.InsertChildAt(1, n32);
var n = new ObservableTreeNode(new TestNode(1));
n.InsertChildAt(0, n1);
n.InsertChildAt(1, n2);
n.InsertChildAt(2, n3);
return n;
}
private void RemoveChildrenFromList(ObservableTreeNode parentItem) {
int startIndex = this.itemList.IndexOf(parentItem) + 1;
int endIndex = startIndex;
while (endIndex < this.itemList.Count && this.itemList[endIndex].Depth > parentItem.Depth) {
++endIndex;
}
for (int i = endIndex - 1; i >= startIndex; --i) {
this.RemoveHandlers(this.itemList[i]);
this.itemList.RemoveAt(i);
}
}
public ObservableTreeNodeTest() {
_testNodeComparer = Comparer<ITreeNode>.Create(TestNode.Comparison);
_rootNode = new ObservableTreeNode(new TestNode(0), _testNodeComparer);
_linearized = new TreeNodeCollection(_rootNode);
}
