private static int compareDirectoryTrees(ObservableSortedTree <DirectoryInfo> tree1,
ObservableSortedTree <DirectoryInfo> tree2)
{
if (ReferenceEquals(tree1, tree2))
{
return(0);
}
else if (tree1 == null)
{
return(-1);
}
else if (tree2 == null)
{
return(1);
}
if (ReferenceEquals(tree1.Value, tree2.Value))
{
return(0);
}
else if (tree1.Value == null)
{
return(-1);
}
else if (tree2.Value == null)
{
return(1);
}
return(string.Compare(tree1.Value.Name, tree2.Value.Name, StringComparison.InvariantCultureIgnoreCase));
}
public virtual ObservableSortedTree <ValueClass> CreateTestTree()
{
Random rand = new Random(0x11111111);
var comparer = Comparer <ValueClass> .Create((v1, v2) =>
{
int compare = v1.Number.CompareTo(v2.Number);
if (compare == 0)
{
compare = string.Compare(v1.Text, v2.Text, StringComparison.InvariantCulture);
}
return(compare);
});
var root = new ObservableSortedTree <ValueClass>(
new ValueClass(rand), comparer);
int numChildren = rand.Next(5, 10);
for (int i = 0; i < numChildren; i++)
{
root.Children.Add(new ObservableSortedTree <ValueClass>(new ValueClass(rand)));
}
var stack = new Stack <ObservableSortedTree <ValueClass> >(root.Children.Reverse());
while (stack.Count > 0)
{
var cTree = stack.Pop();
int maxChildren = 5;
int depth = cTree.EnumerateAncestorsAndSelf().Count() - 1;
if (depth > 5)
{
continue;
}
if (depth > 4)
{
maxChildren = 2;
}
else if (depth > 3)
{
maxChildren = 3;
}
numChildren = rand.Next(0, maxChildren);
for (int i = 0; i < numChildren; i++)
{
cTree.Children.Add(new ObservableSortedTree <ValueClass>(new ValueClass(rand)));
//stack.Push(cTree.Children[i]);
}
foreach (var child in cTree.Children.Reverse())
{
stack.Push(child);
}
}
return(root);
}
protected override void OnDetachChildOverride(ObservableSortedTree <DirectoryInfo> sender, ObservableSortedTree <DirectoryInfo> child)
{
base.OnDetachChildOverride(sender, child);
var dirTree = sender as LazyDirectoryTree;
if (dirTree == null)
{
return;
}
dirTree.IsSelectedChanged -= OnChildIsSelectedChanged;
}
private void Source_ChildTreeDetached(ObservableSortedTree <DirectoryInfo> sender, ObservableSortedTree <DirectoryInfo> child)
{
RemoveDirectoryFromDest(child.Value);
child.ChildTreeAttached -= Source_ChildTreeAttached;
child.ChildTreeDetached -= Source_ChildTreeDetached;
var tmp = child as LazyDirectoryTree;
if (tmp != null)
{
tmp.IsSelectedChanged -= Tree_IsSelectedChanged;
}
}
private ObservableSortedTree <DirectoryInfo> cloneSource(LazyDirectoryTree cloneTree)
{
var root = new ObservableSortedTree <DirectoryInfo>(cloneTree.Value);
if (!cloneTree.AreChildrenGenerated)
{
return(root);
}
var newChildren = cloneTree.Children
.Cast <LazyDirectoryTree>()
.Select(child => cloneSource(child));
root.Children.AddRange(newChildren);
return(root);
}
private void Source_ChildTreeAttached(ObservableSortedTree <DirectoryInfo> sender, ObservableSortedTree <DirectoryInfo> child)
{
var tmp = child as LazyDirectoryTree;
if (tmp != null)
{
tmp.IsSelectedChanged += Tree_IsSelectedChanged;
if (tmp.IsSelected != false)
{
FindOrAddDirectoryToDest(child.Value);
}
}
child.ChildTreeAttached += Source_ChildTreeAttached;
child.ChildTreeDetached += Source_ChildTreeDetached;
}
protected override void OnAttachChild(ObservableSortedTree <DirectoryInfo> sender, ObservableSortedTree <DirectoryInfo> child)
{
base.OnAttachChild(sender, child);
var dirTree = child as LazyDirectoryTree;
if (dirTree == null)
{
return;
}
if (this.IsSelected == false)
{
dirTree.IsSelected = false;
}
else
{
dirTree.IsSelected = true;
}
dirTree.IsSelectedChanged += OnChildIsSelectedChanged;
}
public void TestComparerChangedEvent()
{
var root = CreateTestTree();
var oldComparer = root.Comparer;
var valueComparer = Comparer <ValueClass> .Create((v1, v2) =>
v1.GetHashCode().CompareTo(v2.GetHashCode()));
var comparer = ObservableSortedTree <ValueClass> .TransformValueToTreeComparer(valueComparer);
bool comparerChanged_raised = false;
root.ComparerChanged += (sender, oldComp) =>
{
comparerChanged_raised = true;
Assert.IsTrue(ReferenceEquals(root, sender));
Assert.IsTrue(ReferenceEquals(oldComparer, oldComp));
};
root.Comparer = comparer;
Assert.IsTrue(comparerChanged_raised);
}
private LazyDirectoryTree FindDirectoryInSource(DirectoryInfo dir)
{
var sComparer = DefaultComparers.NoCaseStringEquals;
var splitPath = dir.SplitDirectoryPath();
ObservableSortedTree <DirectoryInfo> cTree = Source;
if (!sComparer.Equals(cTree.Value.FullName.TrimEnd('\\'), splitPath[0]))
{
return(null);
}
for (int i = 1; i < splitPath.Length; i++)
{
var matchTree = cTree.Children.FirstOrDefault(
child => sComparer.Equals(child.Value.Name, splitPath[i]));
if (matchTree == null)
{
return(null);
}
cTree = matchTree;
}
return(cTree as LazyDirectoryTree);
}
public void TestComparersEqualAfterUpdate()
{
var root = CreateTestTree();
var oldComparer = root.Comparer;
var valueComparer = Comparer <ValueClass> .Create((v1, v2) =>
v1.GetHashCode().CompareTo(v2.GetHashCode()));
var comparer = ObservableSortedTree <ValueClass> .TransformValueToTreeComparer(valueComparer);
root.Comparer = comparer;
foreach (var tree in root.AsEnumerable())
{
Assert.IsTrue(ReferenceEquals(tree.Comparer, comparer));
Assert.IsTrue(ReferenceEquals(tree.Children.Comparer, comparer));
}
root.Comparer = oldComparer;
foreach (var tree in root.AsEnumerable())
{
Assert.IsTrue(ReferenceEquals(tree.Comparer, oldComparer));
Assert.IsTrue(ReferenceEquals(tree.Children.Comparer, oldComparer));
}
}
private void Source_ChildTreeAttached(ObservableSortedTree <DirectoryInfo> sender, ObservableSortedTree <DirectoryInfo> child)
{
Logger.WriteLine($"{nameof(Source_ChildTreeAttached)}: Sender= {sender.Value.FullName} Child= {child.Value.FullName} this= {this.Value.FullName}");
var lchild = child as LazyDirectoryTree;
if (lchild != null)
{
lchild.IsSelectedChanged += SourceChild_IsSelectedChanged;
if (lchild.IsSelected != false)
{
if (this.AreChildrenGenerated)
{
var newChild = new LinkedLayTree(lchild);
this.Children.Add(newChild);
}
//FindOrAddDirectoryToDest(child.Value);
}
//child.ChildTreeAttached += Source_ChildTreeAttached;
//child.ChildTreeDetached += Source_ChildTreeDetached;
}
}
/// <summary>
/// Finds and returns the node for a given directory from the destination tree. Creates the node if it doesnt exist.
/// </summary>
/// <param name="dirToAdd">The directory to add the destination tree</param>
private ObservableSortedTree <DirectoryInfo> FindOrAddDirectoryToDest(DirectoryInfo dirToAdd)
{
var sComparer = DefaultComparers.NoCaseStringEquals;
var splitPath = dirToAdd.SplitDirectoryPath();
var cTree = DestRoot;
if (!sComparer.Equals(cTree.Value.FullName.TrimEnd('\\'), splitPath[0]))
{
return(null);
}
for (int i = 1; i < splitPath.Length; i++)
{
var matchTree = cTree.Children.FirstOrDefault(
child => sComparer.Equals(child.Value.Name, splitPath[i]));
if (matchTree == null)
{
var tmpDir = new DirectoryInfo(splitPath[i]);
matchTree = new ObservableSortedTree <DirectoryInfo>(tmpDir);
cTree.Children.Add(matchTree);
}
cTree = matchTree;
}
return(cTree);
}
private void Source_ChildTreeDetached(ObservableSortedTree <DirectoryInfo> sender, ObservableSortedTree <DirectoryInfo> child)
{
Logger.WriteLine($"{nameof(Source_ChildTreeDetached)}: Sender= {sender.Value.FullName} Child= {child.Value.FullName} this= {this.Value.FullName}");
//child.ChildTreeAttached -= Source_ChildTreeAttached;
//child.ChildTreeDetached -= Source_ChildTreeDetached;
var lchild = child as LazyDirectoryTree;
if (lchild != null)
{
lchild.IsSelectedChanged -= SourceChild_IsSelectedChanged;
if (lchild.IsSelected != false)
{
if (this.AreChildrenGenerated)
{
int index;
for (index = 0; index < this.Children.Count; index++)
{
var linkChild = this.Children[index] as LinkedLayTree;
if (linkChild == null)
{
continue;
}
if (ReferenceEquals(lchild, linkChild.Source))
{
break;
}
}
if (index == this.Children.Count)
{
return;
}
this.Children.RemoveAt(index);
}
}
}
}
private void Source_ComparerChanged(ObservableSortedTree <DirectoryInfo> sender, IComparer <ObservableSortedTree <DirectoryInfo> > oldCOmparer) => this.DestRoot.Comparer = Source.Comparer;
