static void PrintToFile(Treenode node)
{
using (Stream fs = File.Create(@"C:\users\chris.wood\desktop\new folder\output.txt")) {
using (StreamWriter writer = new StreamWriter(fs)) {
PrintToFile(writer, new List<Treenode>() { node }, 0);
}
}
}
public TreenodeViewModel(Treenode node, TreenodeViewModel parent)
{
this.Treenode = node;
this.Parent = parent;
foreach (Treenode n in Treenode.Children.Cast<Treenode>()) {
children.Add(new TreenodeViewModel(n, this));
}
}
public bool VisitEnter(Composite composite)
{
VisitCount++;
Treenode node = (Treenode)composite;
if (predicate(node) && node != lastResult) {
lastResult = result = node;
}
return true;
}
public Treenode FindNode(Func<Treenode, bool> predicate)
{
this.predicate = predicate;
result = null;
root.Accept(this, stack);
lastResult = result;
return result;
}
private void Reset()
{
VisitCount = 0;
lastResult = null;
result = null;
}
public DepthFirstSearch(Treenode root)
{
this.root = root;
Reset();
}
private void AddNodeChild(Treenode child)
{
_NodeChildren.Add(child);
child.Parent = this;
}
private void AddDataChild(Treenode child)
{
_DataChildren.Add(child);
child.Parent = this;
}
private static Treenode _Read(BinaryReader reader, ref int count)
{
Treenode ret = new Treenode();
count++;
ret.Flags = (Flags)reader.ReadByte();
ret.DataType = (DataType)reader.ReadByte();
if ((ret.Flags & Flags.ExtendedFlags) == Flags.ExtendedFlags) {
ret.FlagsExtended = (FlagsExtended)reader.ReadInt32();
}
int titleLength = reader.ReadInt32();
if (titleLength > 0) {
ret.Title = Encoding.ASCII.GetString(reader.ReadBytes(titleLength)).TrimEnd(Treenode.TrimChars);
}
if (ret.DataType == DataType.Float) {
double value = reader.ReadDouble();
} else if (ret.DataType == DataType.ByteBlock) {
int stringLength = reader.ReadInt32();
ret.Data = reader.ReadBytes(stringLength);
} else if (ret.DataType == DataType.Object) {
// If the node is an object then the next 4 bytes are an Int32 containing the
// number of child data nodes that it has (those accessed through the > symbol
// that is specific to objects). The next node to be read is the first of these
// which may itself have child nodes. This is how the tree is serialised.
// TODO Still don't know the purpose of this node
Treenode node = _Read(reader, ref count);
// The number of object children access with > rather then the normal +
int numChildren = reader.ReadInt32();
while (numChildren > 0) {
Treenode child = _Read(reader, ref count);
numChildren--;
ret.AddDataChild(child);
}
} else if (ret.DataType == DataType.PointerCoupling) {
int coupling = reader.ReadInt32();
} else if (ret.DataType == DataType.None || ret.DataType == DataType.Undefined) {
// Do nothing
} else {
throw new Exception("Data type was not recognised");
}
// If the HasBranch flag is set then this node is followed by an Int32 containing the
// number of child nodes that it has. The next node to be read is the first of these
// which may itself have child nodes. This is how the tree is serialised
if ((ret.Flags & Flags.HasBranch) == Flags.HasBranch) {
// TODO Still don't know the purpose of this node
Treenode node = _Read(reader, ref count);
int numChildren = reader.ReadInt32();
while (numChildren > 0) {
Treenode child = _Read(reader, ref count);
numChildren--;
ret.AddNodeChild(child);
}
}
return ret;
}
private static void _PrintTree(Treenode t, StreamWriter sw)
{
sw.WriteLine(t.FullPath + " " + t.DataAsString);
foreach (Treenode child in t.Children) {
_PrintTree(child, sw);
}
}
public static void PrintTree(Treenode t, Stream s)
{
using (StreamWriter sw = new StreamWriter(s)) {
_PrintTree(t, sw);
}
}
/// <summary>
/// Find a node from a path relative to a specified starting node.
/// </summary>
/// <param name="path">The path relative to the relativeTo node of the node to be returned.</param>
/// <param name="relativeTo">The starting node for the search.</param>
/// <returns>The Treenode if it is found, null otherwise.</returns>
public static Treenode NodeFromPath(string path, Treenode relativeTo)
{
if (path == null) throw new ArgumentException("path");
if (relativeTo == null) throw new ArgumentException("relativeTo");
string[] parts = path.Split(new char[] { '/' });
if (parts.Length < 1 || parts[1] != relativeTo.Title) {
// The root node of the search differs
return null;
}
Treenode node = relativeTo;
// Start on 2 because of the leading forward slash giving an empty string and the starting nodes being the same
for (int p = 2; p < parts.Length && node != null; p++) {
node = node[parts[p]];
}
return node;
}
public void SelectNode(Treenode target)
{
if (RootNode == null) return;
Stack<Treenode> ancestors = new Stack<Treenode>();
Treenode parent = target;
while (parent != null) {
ancestors.Push(parent);
parent = parent.Parent;
}
TreenodeViewModel item = null;
while (ancestors.Count > 0) {
Treenode node = ancestors.Pop();
ObservableCollection<TreenodeViewModel> items;
if (item == null) {
items = new ObservableCollection<TreenodeViewModel>() { RootNode };
} else {
items = item.Children;
}
foreach (TreenodeViewModel n in items) {
if (n.RepresentsNode(node)) {
item = n;
if (item.Parent != null) {
item.Parent.IsExpanded = true;
}
break;
}
}
if (item == null) {
throw new Exception("Cannot find node in tree");
}
}
item.IsSelected = true;
SelectedItem = item;
}
/// <summary>
/// This function evaluates Treenodes during a search in accordance with the criteria specified on this form.
/// </summary>
/// <param name="node">The Treenode that is currently being evaluated.</param>
/// <returns>True if the Treenode matches the criteria specified on this form, false otherwise.</returns>
public bool SearchPredicate(Treenode node)
{
if (!svm.FindAllDataTypes && node.DataType != svm.DataType) return false;
if (!svm.FindAllFlags) {
if ((node.Flags & svm.Flags) != svm.Flags) return false;
if ((node.FlagsExtended & svm.FlagsExtended) != svm.FlagsExtended) return false;
}
return true;
}
