public void ChangeColor(EsfNode node)
{
foreach (DataGridViewCell cell in row.Cells)
{
cell.Style.ForeColor = node.Modified ? Color.Red : Color.Black;
}
}
private void validateCell(object sender, DataGridViewCellValidatingEventArgs args)
{
EsfNode esfNode = nodeValueGridView.Rows[args.RowIndex].Tag as EsfNode;
if (esfNode != null)
{
string text = args.FormattedValue.ToString();
try
{
if (args.ColumnIndex == 0 && text != esfNode.ToString())
{
esfNode.FromString(text);
}
}
catch
{
Console.WriteLine("Invalid value {0}", text);
args.Cancel = true;
}
}
else
{
nodeValueGridView.Rows[args.RowIndex].ErrorText = "Cannot edit this value";
}
}
private void VerifyEncodeDecode(EsfNode node, bool withoutCodec = true)
{
if (withoutCodec)
{
// encode only the single node
ICodecNode codecNode = node as ICodecNode;
if (codecNode != null)
{
byte[] bytes;
using (var stream = new MemoryStream()) {
using (var writer = new BinaryWriter(stream)) {
codecNode.Encode(writer);
}
bytes = stream.ToArray();
}
EsfNode decoded = node.CreateCopy();
((ICodecNode)decoded).Decode(new BinaryReader(new MemoryStream(bytes, 1, bytes.Length - 1)), node.TypeCode);
assertEqual(node, decoded);
}
}
// now the test with the full file codec
List <EsfNode> singleNode = new List <EsfNode>();
singleNode.Add(node);
VerifyEncodeDecode(singleNode);
}
static void forceDecode(EsfNode node)
{
if (node is ParentNode)
{
(node as ParentNode).AllNodes.ForEach(n => forceDecode(n));
}
}
private void CopyNode(EsfNode node)
{
ParentNode toCopy = node as ParentNode;
ParentNode copy = toCopy.CreateCopy() as ParentNode;
if (copy != null)
{
ParentNode parent = toCopy.Parent as ParentNode;
if (parent != null)
{
List <EsfNode> nodes = new List <EsfNode>(parent.Value);
SetAllModified(copy);
int insertAt = parent.Children.IndexOf(toCopy) + 1;
nodes.Insert(insertAt, copy);
#if DEBUG
Console.Out.WriteLine("new list now {0}", string.Join(",", nodes));
#endif
// copy.Modified = true;
// copy.AllNodes.ForEach(n => n.Modified = true);
parent.Value = nodes;
#if DEBUG
}
else
{
Console.WriteLine("no parent to add to");
#endif
}
#if DEBUG
}
else
{
Console.WriteLine("couldn't create copy");
#endif
}
}
public void NotifySelection(EsfNode node)
{
if (NodeSelected != null)
{
NodeSelected(node);
}
}
private ToolStripMenuItem CreateMenuItem(String label, EsfNode node, NodeAction action)
{
ToolStripMenuItem item = new ToolStripMenuItem(label);
item.Click += new EventHandler(delegate(object s, EventArgs args) { action(node); });
return(item);
}
public override bool Iterate(EsfNode fromNode)
{
ParentNode parentNode = fromNode.Parent as ParentNode;
bool flag = parentNode != null;
if (flag)
{
bool flag2 = false;
{
foreach (EsfNode allNode in parentNode.AllNodes)
{
if (flag2)
{
if (!Visit(allNode))
{
return(false);
}
}
else
{
flag2 = (allNode == fromNode);
}
}
return(flag);
}
}
return(flag);
}
private ToolStripMenuItem CreateMenuItem(string label, EsfNode node, NodeAction action)
{
ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem(label);
toolStripMenuItem.Click += delegate { action(node); };
return(toolStripMenuItem);
}
public void WriteEntry(EsfNode node, long position)
{
//ParentNode
if (node is RecordNode)
{
}
//writer.WriteLine("Entry {0} / {1:x} read at {2:x}", node, node.TypeCode, position);
}
byte[] encodeNode(EsfNode node)
{
MemoryStream stream = new MemoryStream();
using (BinaryWriter writer = new BinaryWriter(stream)) {
codec.Encode(writer, node);
return(stream.ToArray());
}
}
static void OutputNodeEnd(EsfNode node, long position)
{
if (logWriter != null)
{
logWriter.WriteLine("{0} / {1:x}", node, node.TypeCode);
addressLogWriter.WriteLine("{2:x}: {0} / {1:x}", node, node.TypeCode, position);
logWriter.Flush();
addressLogWriter.Flush();
}
}
private bool Invalidate(EsfNode node)
{
MemoryMappedRecordNode memoryMappedRecordNode = node as MemoryMappedRecordNode;
bool flag = memoryMappedRecordNode == null;
if (memoryMappedRecordNode != null)
{
memoryMappedRecordNode.Invalid = true;
}
return(!flag);
}
private void DeleteNode(EsfNode node)
{
RecordArrayNode recordArrayNode = node.Parent as RecordArrayNode;
if (recordArrayNode != null)
{
List <EsfNode> list = new List <EsfNode>(recordArrayNode.Value);
list.Remove(node);
recordArrayNode.Value = list;
}
}
public override bool Iterate(EsfNode node)
{
bool num = Visit(node);
if (num)
{
(node as ParentNode)?.AllNodes.ForEach(delegate(EsfNode n) { Iterate(n); });
}
return(num);
}
private void DeleteNode(EsfNode node)
{
RecordArrayNode parent = node.Parent as RecordArrayNode;
if (parent != null)
{
List <EsfNode> nodes = new List <EsfNode>(parent.Value);
nodes.Remove(node);
parent.Value = nodes;
}
}
public override bool Iterate(EsfNode node)
{
bool num = node != null && Visit(node);
if (num)
{
Iterate(node.Parent as ParentNode);
}
return(num);
}
public static string CreatePath(EsfNode node, string separator = "/")
{
NodePathCreator nodePathCreator = new NodePathCreator
{
PathSeparator = separator
};
ParentIterator parentIterator = new ParentIterator();
parentIterator.Visit = nodePathCreator.Visit;
parentIterator.Iterate(node);
return(nodePathCreator.Path);
}
private EsfValueNode <T> TestNode <T>(EsfValueNode <T> node, EsfType expectedTypeCode = EsfType.INVALID)
{
byte[] data = encodeNode(node);
EsfNode decoded = decodeNode(data);
EsfValueNode <T> node2 = decoded as EsfValueNode <T>;
assertEqual(node, node2);
if (expectedTypeCode != EsfType.INVALID)
{
assertEqual(node2.TypeCode, expectedTypeCode);
}
encodeNode(node2);
return(node2);
}
public bool Visit(EsfNode node)
{
INamedNode namedNode = node as INamedNode;
if (namedNode is CompressedNode)
{
path = path.Substring(path.IndexOf(PathSeparator) + 1);
}
if (!(namedNode is MemoryMappedRecordNode) || string.IsNullOrEmpty(path))
{
path = $"{namedNode.GetName()}{PathSeparator}{path}";
}
return(true);
}
void Update(EsfNode ignored, long position)
{
if (ignored is ParentNode)
{
try {
if ((int)position <= progress.Maximum)
{
progress.Value = (int)position;
}
Application.DoEvents();
} catch {
progress.Value = 0;
currentCodec.NodeReadFinished -= Update;
}
}
}
private void CopyNode(EsfNode node)
{
ParentNode parentNode = node as ParentNode;
ParentNode parentNode2 = parentNode.CreateCopy() as ParentNode;
if (parentNode2 != null)
{
ParentNode parentNode3 = parentNode.Parent as ParentNode;
if (parentNode3 != null)
{
List <EsfNode> list = new List <EsfNode>(parentNode3.Value);
int index = parentNode3.Children.IndexOf(parentNode) + 1;
list.Insert(index, parentNode2);
parentNode3.Value = list;
parentNode2.Modified = true;
parentNode2.AllNodes.ForEach(delegate(EsfNode n) { n.Modified = false; });
}
}
}
public void Toc(EsfNode node, long readerPosition)
{
long endTime = DateTime.Now.Ticks;
long total;
int count;
if (codeToTime.TryGetValue((byte)node.TypeCode, out total))
{
count = codeToCount[(byte)node.TypeCode] + 1;
}
else
{
total = 0;
count = 1;
}
total += endTime - startTime;
codeToTime[(byte)node.TypeCode] = total;
codeToCount[(byte)node.TypeCode] = count;
}
private void MoveNode(EsfNode node)
{
RecordArrayNode recordArrayNode = node.Parent as RecordArrayNode;
if (recordArrayNode == null)
{
return;
}
InputBox inputBox = new InputBox();
inputBox.Input = "Move to index";
InputBox inputBox2 = inputBox;
if (inputBox2.ShowDialog() != DialogResult.OK)
{
return;
}
int result = -1;
List <EsfNode> list = new List <EsfNode>(recordArrayNode.Value);
if (int.TryParse(inputBox2.Input, out result))
{
if (result >= 0 && result < list.Count)
{
list.Remove(node);
list.Insert(result, node);
recordArrayNode.Value = list;
}
else
{
MessageBox.Show($"Entry only valid between 0 and {list.Count - 1}", "Invalid input",
MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
else
{
MessageBox.Show($"Enter index (between 0 and {list.Count - 1})", "Invalid input", MessageBoxButtons.OK,
MessageBoxIcon.Hand);
}
}
private void MoveNode(EsfNode node)
{
RecordArrayNode parent = node.Parent as RecordArrayNode;
if (parent != null)
{
InputBox input = new InputBox {
Input = "Move to index"
};
if (input.ShowDialog() == DialogResult.OK)
{
int moveToIndex = -1;
List <EsfNode> nodes = new List <EsfNode>(parent.Value);
if (int.TryParse(input.Input, out moveToIndex))
{
if (moveToIndex >= 0 && moveToIndex < nodes.Count)
{
nodes.Remove(node);
nodes.Insert(moveToIndex, node);
#if DEBUG
Console.Out.WriteLine("new list now {0}", string.Join(",", nodes));
#endif
parent.Value = nodes;
}
else
{
MessageBox.Show(string.Format("Entry only valid between 0 and {0}", nodes.Count - 1),
"Invalid input", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(string.Format("Enter index (between 0 and {0})", nodes.Count - 1),
"Invalid input", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
public void NodeChange(EsfNode n)
{
ForeColor = n.Modified ? Color.Red : Color.Black;
if (!n.Modified)
{
return;
}
ParentNode node = (Tag as ParentNode);
bool sameChildren = node.Children.Count == this.Nodes.Count;
for (int i = 0; sameChildren && i < node.Children.Count; i++)
{
sameChildren &= node.Children[i].Name.Equals(Nodes[i].Text);
}
if (node != null)
{
if (!sameChildren)
{
Nodes.Clear();
Fill();
if (IsExpanded)
{
foreach (TreeNode child in Nodes)
{
(child as EsfTreeNode).Fill();
}
}
}
else
{
for (int i = 0; i < node.Children.Count; i++)
{
Nodes[i].Text = node.Children[i].Name;
}
}
}
}
public void NodeChange(EsfNode n)
{
base.ForeColor = (n.Modified ? Color.Red : Color.Black);
ParentNode parentNode = base.Tag as ParentNode;
bool flag = parentNode.Children.Count == base.Nodes.Count;
int num = 0;
while (flag && num < parentNode.Children.Count)
{
flag &= parentNode.Children[num].Name.Equals(base.Nodes[num].Text);
num++;
}
if (parentNode == null)
{
return;
}
if (!flag)
{
base.Nodes.Clear();
Fill();
if (base.IsExpanded)
{
foreach (TreeNode node in base.Nodes)
{
(node as EsfTreeNode).Fill();
}
}
}
else
{
for (int i = 0; i < parentNode.Children.Count; i++)
{
base.Nodes[i].Text = parentNode.Children[i].Name;
}
}
}
private bool InvalidateAll(EsfNode node)
{
Invalidate(node);
return(true);
}
private void NodeSelected(EsfNode node)
{
_bookmarksToolStripMenuItem.Enabled = (node != null);
_addBookmarkToolStripMenuItem.Enabled = (node != null);
}
public void WriteEntry(EsfNode node, long position)
{
bool flag = node is RecordNode;
}
