// -------------------------------------------------------------------------
// Pour les tests, ce bouton remplit le RegistryTree
// -------------------------------------------------------------------------
private void FillRegistryTree(object sender, RoutedEventArgs e)
{
RegistryItem N1 = new RegistryItem("Node 1", "node");
RegistryItem K1 = new RegistryItem("clef 1", "dword")
{
Value = "0001"
};
RegistryItem K2 = new RegistryItem("clef 2", "dword")
{
Value = "0002"
};
N1.AddSubItem(K1);
N1.AddSubItem(K2);
RegistryTree1.Add(N1);
RegistryItem N2 = new RegistryItem("Node 2", "node");
RegistryItem K3 = new RegistryItem("clef 3", "dword")
{
Value = "0003"
};
N2.AddSubItem(K3);
RegistryTree1.Add(N2);
RegistryItem N3 = new RegistryItem("SubNode 3", "node");
RegistryItem K4 = new RegistryItem("clef 4", "dword")
{
Value = "0004"
};
N3.AddSubItem(K4);
N2.AddSubItem(N3);
RegistryItem K5 = new RegistryItem("clef 5", "dword")
{
Value = "0005"
};
RegistryItem K6 = new RegistryItem("clef 6", "dword")
{
Value = "0006"
};
RegistryItem N4 = new RegistryItem("SubNode 4", "node");
N4.AddSubItem(K5);
N4.AddSubItem(K6);
N2.AddSubItem(N4);
DropZone.Visibility = Visibility.Hidden;
TreeView1.Visibility = Visibility.Visible;
}
// ------------------------------------------------------------------
// Attache le node fourni à son parent. On retrouve le parent grace au dictionnaire.
// ------------------------------------------------------------------
protected void AttachToParentNode(RegistryItem node, string parentpath)
{
if (parentpath == string.Empty)
{
return;
}
// On cherche le Node Parent dans la table
RegistryItem parentNode = this.GetFromNodeTable(parentpath);
// Si on le trouve: on lui attache le node
if (parentNode != null)
{
parentNode.AddSubItem(node);
}
// Si on ne trouve pas le Parent: on en crée un, et on le rattache à son propre parent (grand-parent)
else
{
// On crée un nouveau Node pour le Parent
string parentName = this.GetNodeNameFromPath(parentpath);
parentNode = new RegistryItem(parentName, "node");
// On le met dans le dictionnaire
this.AddToNodeTable(parentNode, parentpath);
// On le rattache à son propre parent (le parent du parent)
string greatParentPath = GetParentPath(parentpath);
this.AttachToParentNode(parentNode, greatParentPath);
}
}
// ------------------------------------------------------------------
// Attache le node fourni à son parent. Fonction rapide, si on connait deja le Parent.
// ------------------------------------------------------------------
protected void AttachToParentNode(RegistryItem node, RegistryItem parentnode)
{
if (parentnode is RegistryItem)
{
parentnode.AddSubItem(node);
}
}
// ------------------------------------------------------------------
// Parse le fichier REG
// Enregistre l'arborescence dans un RegistryTree
// Enregistre la liste des Nodes dans un Dictionnaire
// ------------------------------------------------------------------
public void ParseFile(string fileName)
{
// On commence par vider la collection et le dictionnaire
InitParser();
AverageLabelLength = 0;
ModalLabelLength = 0;
Array.Clear(TableStats, 0, TableStats.Length);
// Vérification
if (!fileName.EndsWith(".reg"))
{
RegistryItem WrongNode = new RegistryItem("Not a REG file", "node");
RegistryTree.Add(WrongNode);
return;
}
// On lit le fichier et on met tout dans une très longue string.
// fileName = "E:\\source\\repos\\RegFineViewer\\_example1.reg";
StreamReader streamFile = new StreamReader(File.Open(fileName, FileMode.OpenOrCreate));
string fichier = streamFile.ReadToEnd();
streamFile.Close();
// On decoupe le fichier en un tableau de lignes
string[] lignes = fichier.Split('\r', '\n');
// Vérification
if (lignes.Length > 50000)
{
RegistryItem WrongNode = new RegistryItem("The file contains too many lines (max 10.000).", "node");
RegistryTree.Add(WrongNode);
return;
}
// On crée un Node Racine
RegistryItem currentNode = new RegistryItem("root", "node");
RegistryTree.Add(currentNode);
bool firstNode = true;
// On parcourt le tableau des lignes du fichier
for (int i = 0; i < lignes.Length; i++)
{
string ligne = lignes[i];
// On ignore la ligne d'entete
if (ligne.StartsWith("Windows Registry Editor"))
{
}
// On ignore les lignes vides
else if (ligne.Equals(""))
{
}
// Lignes de type [path\to\node]
else if (ligne.StartsWith("[") && ligne.EndsWith("]"))
{
string nodePath = ligne.Trim('[', ']');
string parentPath = GetParentPath(nodePath);
// ----------------------------------------------------------------------
// S'il s'agit du premier node
// ----------------------------------------------------------------------
// Le node racine du treeView est le parent du premier node du fichier REG
if (firstNode)
{
if (parentPath != "")
{
// Pour ce node racine, son nom est le chemin complet du parent
currentNode.Name = parentPath;
}
else
{
// sauf si le nom du parent est vide...
currentNode.Name = nodePath;
}
// On met le node Racine dans le dictionnaire
AddToNodeTable(currentNode, currentNode.Name);
// On memorise le Level de ce Node
RacineNodeLevel = nodePath.Split('\\').Length - 1;
firstNode = false;
}
// on cree un nouveau node
currentNode = CreateRegistryNode(nodePath);
// On le rattache à son parent
AttachToParentNode(currentNode, parentPath);
// on comptabilise sa longueur dans les statistiques
TableStats[currentNode.Name.Length] += 1;
}
// Lignes du type: "ErrorLogSizeInKb" = dword:000186A0
// Lignes du type: "Application" = ""
else if (ligne.StartsWith("\""))
{
// Si on n'a pas de node courant, on passe. Ca ne devrait pas arriver.
if (currentNode != null)
{
// On cree une Key
RegistryItem newKey = CreateRegistryKeyFromFileLine(ligne);
// On la rattache au Node courant
currentNode.AddSubItem(newKey);
}
}
// Autres cas
else
{
}
}
}