public void SearchNodes()
{
RtfNodeCollection list1 = new RtfNodeCollection();
RtfTreeNode node = new RtfTreeNode(RtfNodeType.Keyword, "c", true, 3);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "a", true, 1));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "b", true, 2));
list1.Add(node);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "b", true, 4));
list1.Add(node);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "e", true, 6));
Assert.That(list1.IndexOf(node), Is.EqualTo(2));
Assert.That(list1.IndexOf(new RtfTreeNode()), Is.EqualTo(-1));
Assert.That(list1.IndexOf(node, 0), Is.EqualTo(2));
Assert.That(list1.IndexOf(node, 2), Is.EqualTo(2));
Assert.That(list1.IndexOf(node, 3), Is.EqualTo(4));
Assert.That(list1.IndexOf(node, 5), Is.EqualTo(-1));
Assert.That(list1.IndexOf("b", 0), Is.EqualTo(1));
Assert.That(list1.IndexOf("b", 1), Is.EqualTo(1));
Assert.That(list1.IndexOf("b", 2), Is.EqualTo(3));
Assert.That(list1.IndexOf("x", 0), Is.EqualTo(-1));
Assert.That(list1.IndexOf("b"), Is.EqualTo(1));
Assert.That(list1.IndexOf("x"), Is.EqualTo(-1));
}
public void SelectChildNodesByType()
{
RtfTree tree = new RtfTree();
int res = tree.LoadRtfFile("..\\..\\testdocs\\testdoc1.rtf");
RtfNodeCollection lista1 = tree.MainGroup.SelectChildNodes(RtfNodeType.Keyword); //48 nodes
RtfNodeCollection lista2 = tree.MainGroup.SelectChildNodes(RtfNodeType.Control); //3 nodes
RtfNodeCollection lista3 = tree.MainGroup.SelectChildNodes(RtfNodeType.Group); //3 nodes
Assert.That(lista1.Count, Is.EqualTo(49));
Assert.That(lista2.Count, Is.EqualTo(3));
Assert.That(lista3.Count, Is.EqualTo(3));
Assert.That(lista1[5], Is.SameAs(tree.MainGroup[8])); //viewkind
Assert.That(lista1[22].NodeKey, Is.EqualTo("lang")); //lang3082
Assert.That(lista2[0], Is.SameAs(tree.MainGroup[45])); //'233
Assert.That(lista2[1], Is.SameAs(tree.MainGroup[47])); //'241
Assert.That(lista2[1].Parameter, Is.EqualTo(241)); //'241
Assert.That(lista3[0], Is.SameAs(tree.MainGroup[5]));
Assert.That(lista3[0].FirstChild.NodeKey, Is.EqualTo("fonttbl"));
Assert.That(lista3[1], Is.SameAs(tree.MainGroup[6]));
Assert.That(lista3[1].FirstChild.NodeKey, Is.EqualTo("colortbl"));
Assert.That(lista3[2], Is.SameAs(tree.MainGroup[7]));
Assert.That(lista3[2].ChildNodes[0].NodeKey, Is.EqualTo("*"));
Assert.That(lista3[2].ChildNodes[1].NodeKey, Is.EqualTo("generator"));
}
public void SelectNodesByKeyword()
{
RtfTree tree = new RtfTree();
int res = tree.LoadRtfFile("..\\..\\testdocs\\testdoc1.rtf");
RtfNodeCollection lista1 = tree.MainGroup.SelectNodes("fs"); //5 nodes
RtfNodeCollection lista2 = tree.MainGroup.SelectNodes("f"); //6 nodes
Assert.That(lista1.Count, Is.EqualTo(5));
Assert.That(lista2.Count, Is.EqualTo(6));
Assert.That(lista1[0], Is.SameAs(tree.MainGroup[17]));
Assert.That(lista1[1], Is.SameAs(tree.MainGroup[22]));
Assert.That(lista1[2], Is.SameAs(tree.MainGroup[25]));
Assert.That(lista1[3], Is.SameAs(tree.MainGroup[43]));
Assert.That(lista1[4], Is.SameAs(tree.MainGroup[77]));
Assert.That(lista2[0], Is.SameAs(tree.MainGroup[5].ChildNodes[1].FirstChild));
Assert.That(lista2[1], Is.SameAs(tree.MainGroup[5].ChildNodes[2].FirstChild));
Assert.That(lista2[2], Is.SameAs(tree.MainGroup[5].ChildNodes[3].FirstChild));
Assert.That(lista2[3], Is.SameAs(tree.MainGroup[16]));
Assert.That(lista2[4], Is.SameAs(tree.MainGroup[56]));
Assert.That(lista2[5], Is.SameAs(tree.MainGroup[76]));
}
public void RemoveNodesFromCollection()
{
RtfNodeCollection list1 = new RtfNodeCollection();
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "a", true, 1));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "b", true, 2));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "c", true, 3));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "d", true, 4));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "e", true, 5));
Assert.That(list1.Count, Is.EqualTo(5));
Assert.That(list1[1].NodeKey, Is.EqualTo("b"));
list1.RemoveAt(1);
Assert.That(list1.Count, Is.EqualTo(4));
Assert.That(list1[0].NodeKey, Is.EqualTo("a"));
Assert.That(list1[1].NodeKey, Is.EqualTo("c"));
Assert.That(list1[2].NodeKey, Is.EqualTo("d"));
Assert.That(list1[3].NodeKey, Is.EqualTo("e"));
list1.RemoveRange(1, 2);
Assert.That(list1.Count, Is.EqualTo(2));
Assert.That(list1[0].NodeKey, Is.EqualTo("a"));
Assert.That(list1[1].NodeKey, Is.EqualTo("e"));
}
private static void ExtractHyperlinks()
{
RtfTree tree = new RtfTree();
tree.LoadRtfFile("..\\..\\testdocs\\test-doc.rtf");
RtfNodeCollection fields = tree.MainGroup.SelectGroups("field");
foreach (RtfTreeNode node in fields)
{
//Extract URL
RtfTreeNode fldInst = node.ChildNodes[1];
string fldInstText = ExtractGroupText(fldInst);
string url = fldInstText.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries)[1];
//Extract Link Text
RtfTreeNode fldRslt = node.SelectSingleChildGroup("fldrslt");
string linkText = ExtractGroupText(fldRslt);
Console.WriteLine("[" + linkText + ", " + url + "]");
}
}
public void SelectNodesByType()
{
RtfTree tree = new RtfTree();
int res = tree.LoadRtfFile("..\\..\\testdocs\\testdoc1.rtf");
RtfNodeCollection lista1 = tree.MainGroup.SelectNodes(RtfNodeType.Keyword); //68 nodes
RtfNodeCollection lista2 = tree.MainGroup.SelectNodes(RtfNodeType.Control); //4 nodes
RtfNodeCollection lista3 = tree.MainGroup.SelectNodes(RtfNodeType.Group); //6 nodes
Assert.That(lista1.Count, Is.EqualTo(69));
Assert.That(lista2.Count, Is.EqualTo(4));
Assert.That(lista3.Count, Is.EqualTo(6));
Assert.That(lista1[5], Is.SameAs(tree.MainGroup[5].FirstChild)); //fonttbl
Assert.That(lista1[22], Is.SameAs(tree.MainGroup[6].ChildNodes[7])); //green0
Assert.That(lista1[22].NodeKey, Is.EqualTo("green")); //green0
Assert.That(lista2[0], Is.SameAs(tree.MainGroup[7].FirstChild)); //* generator
Assert.That(lista2[1], Is.SameAs(tree.MainGroup[45])); //'233
Assert.That(lista2[2], Is.SameAs(tree.MainGroup[47])); //'241
Assert.That(lista2[2].Parameter, Is.EqualTo(241)); //'241
Assert.That(lista3[0], Is.SameAs(tree.MainGroup[5]));
Assert.That(lista3[0].FirstChild.NodeKey, Is.EqualTo("fonttbl"));
Assert.That(lista3[3], Is.SameAs(tree.MainGroup[5].ChildNodes[3]));
Assert.That(lista3[3].FirstChild.NodeKey, Is.EqualTo("f"));
Assert.That(lista3[3].FirstChild.Parameter, Is.EqualTo(2));
Assert.That(lista3[5], Is.SameAs(tree.MainGroup[7]));
Assert.That(lista3[5].ChildNodes[0].NodeKey, Is.EqualTo("*"));
Assert.That(lista3[5].ChildNodes[1].NodeKey, Is.EqualTo("generator"));
}
private static void ExtractImages()
{
RtfTree tree = new RtfTree();
tree.LoadRtfFile("..\\..\\testdocs\\test-doc.rtf");
RtfNodeCollection imageNodes = tree.RootNode.SelectNodes("pict");
Console.WriteLine("Extracting images...");
int i = 1;
foreach (RtfTreeNode node in imageNodes)
{
ImageNode imageNode = new ImageNode(node.ParentNode);
if (imageNode.ImageFormat == ImageFormat.Png)
{
imageNode.SaveImage("..\\..\\testdocs\\image" + i + ".png");
Console.WriteLine("File '" + "image" + i + ".png" + "' created.");
i++;
}
}
Console.WriteLine("");
}
public static void ExtractDocumentOutline()
{
RtfTree tree = new RtfTree();
tree.LoadRtfFile("..\\..\\testdocs\\test-doc.rtf");
RtfStyleSheetTable sst = tree.GetStyleSheetTable();
int heading1 = sst.IndexOf("heading 1");
int heading2 = sst.IndexOf("heading 2");
int heading3 = sst.IndexOf("heading 3");
tree.MainGroup.RemoveChild(tree.MainGroup.SelectChildGroups("stylesheet")[0]);
RtfNodeCollection headingKeywords = tree.MainGroup.SelectNodes("s");
for (int i = 0; i < headingKeywords.Count; i++)
{
RtfTreeNode hk = headingKeywords[i];
StringBuilder text = new StringBuilder("");
if (hk.Parameter == heading1 ||
hk.Parameter == heading2 ||
hk.Parameter == heading3)
{
RtfTreeNode sibling = hk.NextSibling;
while (sibling != null && !sibling.NodeKey.Equals("pard"))
{
if (sibling.NodeType == RtfNodeType.Text)
{
text.Append(sibling.NodeKey);
}
else if (sibling.NodeType == RtfNodeType.Group)
{
text.Append(ExtractGroupText(sibling));
}
sibling = sibling.NextSibling;
}
if (hk.Parameter == heading1)
{
Console.WriteLine("H1: {0}", text);
}
else if (hk.Parameter == heading2)
{
Console.WriteLine(" H2: {0}", text);
}
else if (hk.Parameter == heading3)
{
Console.WriteLine(" H3: {0}", text);
}
}
}
}
/// <summary>
/// Constructor de la clase RtfTreeNode. Crea un nodo sin inicializar.
/// </summary>
public RtfTreeNode()
{
children = new RtfNodeCollection();
this.type = RtfNodeType.None;
this.key = "";
/* Inicializados por defecto */
//this.param = 0;
//this.hasParam = false;
//this.parent = null;
//this.root = null;
}
/// <summary>
/// Constructor de la clase RtfTreeNode. Crea un nodo especificando su tipo, palabra clave y parámetro.
/// </summary>
/// <param name="type">Tipo del nodo.</param>
/// <param name="key">Palabra clave o símbolo de Control.</param>
/// <param name="hasParameter">Indica si la palabra clave o el símbolo de Control va acompañado de un parámetro.</param>
/// <param name="parameter">Parámetro del la palabra clave o símbolo de Control.</param>
public RtfTreeNode(RtfNodeType type, string key, bool hasParameter, int parameter)
{
children = new RtfNodeCollection();
this.type = type;
this.key = key;
this.hasParam = hasParameter;
this.param = parameter;
/* Inicializados por defecto */
//this.parent = null;
//this.root = null;
}
/// <summary>
/// Constructor privado de la clase RtfTreeNode. Crea un nodo a partir de un token del analizador léxico.
/// </summary>
/// <param name="token">Token RTF devuelto por el analizador léxico.</param>
internal RtfTreeNode(RtfToken token)
{
children = new RtfNodeCollection();
this.type = (RtfNodeType)token.Type;
this.key = token.Key;
this.hasParam = token.HasParameter;
this.param = token.Parameter;
/* Inicializados por defecto */
//this.parent = null;
//this.root = null;
}
/// <summary>
/// Constructor de la clase RtfTreeNode. Crea un nodo sin inicializar.
/// </summary>
public RtfTreeNode()
{
children = new RtfNodeCollection();
this.type = RtfNodeType.None;
this.key = "";
/* Inicializados por defecto */
//this.param = 0;
//this.hasParam = false;
//this.parent = null;
//this.root = null;
}
public void SelectChildGroups()
{
RtfTree tree = new RtfTree();
int res = tree.LoadRtfFile("..\\..\\testdocs\\testdoc1.rtf");
RtfNodeCollection lista1 = tree.MainGroup.SelectChildGroups("colortbl"); //1 node
RtfNodeCollection lista2 = tree.MainGroup.SelectChildGroups("f"); //0 nodes
Assert.That(lista1.Count, Is.EqualTo(1));
Assert.That(lista2.Count, Is.EqualTo(0));
Assert.That(lista1[0], Is.SameAs(tree.MainGroup[6]));
}
/// <summary>
/// Devuelve todos los nodos de la lista de nodos hijos del nodo actual cuyo tipo es el indicado como parámetro.
/// </summary>
/// <param name="nodeType">Tipo del nodo buscado.</param>
/// <returns>Colección de nodos de la lista de nodos hijos del nodo actual cuyo tipo es el indicado como parámetro.</returns>
public RtfNodeCollection SelectChildNodes(RtfNodeType nodeType)
{
RtfNodeCollection nodes = new RtfNodeCollection();
foreach (RtfTreeNode node in children)
{
if (node.type == nodeType)
{
nodes.Add(node);
}
}
return(nodes);
}
/// <summary>
/// Devuelve todos los nodos de la lista de nodos hijos del nodo actual cuya palabra clave y parámetro son los indicados como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <param name="param">Parámetro buscado.</param>
/// <returns>Colección de nodos de la lista de nodos hijos del nodo actual cuya palabra clave y parámetro son los indicados como parámetro.</returns>
public RtfNodeCollection SelectChildNodes(string keyword, int param)
{
RtfNodeCollection nodes = new RtfNodeCollection();
foreach (RtfTreeNode node in children)
{
if (node.key == keyword && node.param == param)
{
nodes.Add(node);
}
}
return(nodes);
}
/// <summary>
/// Método auxiliar para generar la representación Textual del documento RTF.
/// </summary>
/// <param name="curNode">Nodo actual del árbol.</param>
/// <param name="level">Nivel actual en árbol.</param>
/// <param name="showNodeTypes">Indica si se mostrará el tipo de cada nodo del árbol.</param>
/// <returns>Representación Textual del nodo 'curNode' con nivel 'level'</returns>
private string toStringInm(RtfTreeNode curNode, int level, bool showNodeTypes)
{
StringBuilder res = new StringBuilder();
RtfNodeCollection children = curNode.ChildNodes;
for (int i = 0; i < level; i++)
{
res.Append(" ");
}
if (curNode.NodeType == RtfNodeType.Root)
{
res.Append("ROOT\r\n");
}
else if (curNode.NodeType == RtfNodeType.Group)
{
res.Append("GROUP\r\n");
}
else
{
if (showNodeTypes)
{
res.Append(curNode.NodeType);
res.Append(": ");
}
res.Append(curNode.NodeKey);
if (curNode.HasParameter)
{
res.Append(" ");
res.Append(Convert.ToString(curNode.Parameter));
}
res.Append("\r\n");
}
if (children != null)
{
foreach (RtfTreeNode node in children)
{
res.Append(toStringInm(node, level + 1, showNodeTypes));
}
}
return(res.ToString());
}
public void FindText()
{
RtfTree tree = new RtfTree();
int res = tree.LoadRtfFile("..\\..\\testdocs\\testdoc1.rtf");
RtfNodeCollection list1 = tree.MainGroup.FindText("Italic");
Assert.That(list1.Count, Is.EqualTo(2));
Assert.That(list1[0], Is.SameAs(tree.MainGroup[18]));
Assert.That(list1[0].NodeKey, Is.EqualTo("Bold Italic Underline Size 14"));
Assert.That(list1[1], Is.SameAs(tree.MainGroup[73]));
Assert.That(list1[1].NodeKey, Is.EqualTo("Italic2"));
}
/// <summary>
/// Devuelve todos los nodos, a partir del nodo actual, cuya palabra clave es la indicada como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <returns>Colección de nodos, a partir del nodo actual, cuya palabra clave es la indicada como parámetro.</returns>
public RtfNodeCollection SelectNodes(string keyword)
{
RtfNodeCollection nodes = new RtfNodeCollection();
foreach (RtfTreeNode node in children)
{
if (node.key == keyword)
{
nodes.Add(node);
}
nodes.AddRange(node.SelectNodes(keyword));
}
return(nodes);
}
public void PopulateCollection()
{
RtfNodeCollection list1 = new RtfNodeCollection();
RtfNodeCollection list2 = new RtfNodeCollection();
RtfTreeNode node = new RtfTreeNode(RtfNodeType.Keyword, "b", true, 2);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "a", true, 1));
list1.Add(node);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "c", true, 3));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "d", true, 4));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "e", true, 5));
list2.Add(node);
list2.Add(new RtfTreeNode(RtfNodeType.Keyword, "g", true, 7));
Assert.That(list1.Count, Is.EqualTo(5));
Assert.That(list2.Count, Is.EqualTo(2));
Assert.That(list1[1], Is.SameAs(node));
Assert.That(list2[0], Is.SameAs(node));
list1.AddRange(list2);
Assert.That(list1.Count, Is.EqualTo(7));
Assert.That(list1[5], Is.SameAs(list2[0]));
Assert.That(list1[6], Is.SameAs(list2[1]));
Assert.That(list1[6].NodeKey, Is.EqualTo("g"));
Assert.That(list2[0], Is.SameAs(node));
RtfTreeNode node1 = new RtfTreeNode(RtfNodeType.Keyword, "h", false, 8);
list1.Insert(5, node1);
Assert.That(list1.Count, Is.EqualTo(8));
Assert.That(list1[5], Is.SameAs(node1));
RtfTreeNode node2 = new RtfTreeNode(RtfNodeType.Keyword, "i", false, 9);
list1[1] = node2;
Assert.That(list1.Count, Is.EqualTo(8));
Assert.That(list1[1], Is.SameAs(node2));
}
public void PopulateCollection()
{
RtfNodeCollection list1 = new RtfNodeCollection();
RtfNodeCollection list2 = new RtfNodeCollection();
RtfTreeNode node = new RtfTreeNode(RtfNodeType.Keyword, "b", true, 2);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "a", true, 1));
list1.Add(node);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "c", true, 3));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "d", true, 4));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "e", true, 5));
list2.Add(node);
list2.Add(new RtfTreeNode(RtfNodeType.Keyword, "g", true, 7));
Assert.That(list1.Count, Is.EqualTo(5));
Assert.That(list2.Count, Is.EqualTo(2));
Assert.That(list1[1], Is.SameAs(node));
Assert.That(list2[0], Is.SameAs(node));
list1.AddRange(list2);
Assert.That(list1.Count, Is.EqualTo(7));
Assert.That(list1[5], Is.SameAs(list2[0]));
Assert.That(list1[6], Is.SameAs(list2[1]));
Assert.That(list1[6].NodeKey, Is.EqualTo("g"));
Assert.That(list2[0], Is.SameAs(node));
RtfTreeNode node1 = new RtfTreeNode(RtfNodeType.Keyword, "h", false, 8);
list1.Insert(5, node1);
Assert.That(list1.Count, Is.EqualTo(8));
Assert.That(list1[5], Is.SameAs(node1));
RtfTreeNode node2 = new RtfTreeNode(RtfNodeType.Keyword, "i", false, 9);
list1[1] = node2;
Assert.That(list1.Count, Is.EqualTo(8));
Assert.That(list1[1], Is.SameAs(node2));
}
public void SelectChildNodesByKeywordAndParam()
{
RtfTree tree = new RtfTree();
int res = tree.LoadRtfFile("..\\..\\testdocs\\testdoc1.rtf");
RtfNodeCollection lista1 = tree.MainGroup.SelectChildNodes("fs", 24); //2 nodes
RtfNodeCollection lista2 = tree.MainGroup.SelectChildNodes("f", 1); //1 nodes
Assert.That(lista1.Count, Is.EqualTo(2));
Assert.That(lista2.Count, Is.EqualTo(1));
Assert.That(lista1[0], Is.SameAs(tree.MainGroup[22]));
Assert.That(lista1[1], Is.SameAs(tree.MainGroup[43]));
Assert.That(lista2[0], Is.SameAs(tree.MainGroup[56]));
}
/// <summary>
/// Constructor de la clase ImageNode.
/// </summary>
/// <param name="node">Nodo RTF del que se obtendrán los datos de la imagen.</param>
public ImageNode(RtfTreeNode node)
{
if (node != null)
{
//Asignamos todos los campos del nodo
NodeKey = node.NodeKey;
HasParameter = node.HasParameter;
Parameter = node.Parameter;
ParentNode = node.ParentNode;
RootNode = node.RootNode;
NodeType = node.NodeType;
ChildNodes = new RtfNodeCollection();
ChildNodes.AddRange(node.ChildNodes);
//Obtenemos los datos de la imagen como un array de bytes
getImageData();
}
}
/// <summary>
/// Constructor de la clase ImageNode.
/// </summary>
/// <param name="node">Nodo RTF del que se obtendrán los datos de la imagen.</param>
public ImageNode(RtfTreeNode node)
{
if(node != null)
{
//Asignamos todos los campos del nodo
NodeKey = node.NodeKey;
HasParameter = node.HasParameter;
Parameter = node.Parameter;
ParentNode = node.ParentNode;
RootNode = node.RootNode;
NodeType = node.NodeType;
ChildNodes = new RtfNodeCollection();
ChildNodes.AddRange(node.ChildNodes);
//Obtenemos los datos de la imagen como un array de bytes
getImageData();
}
}
/// <summary>
/// Devuelve la tabla de hojas de estilo del documento RTF.
/// </summary>
/// <returns>Tabla de hojas de estilo del documento RTF.</returns>
public RtfStyleSheetTable GetStyleSheetTable()
{
RtfStyleSheetTable sstable = new RtfStyleSheetTable();
RtfTreeNode sst = MainGroup.SelectSingleGroup("stylesheet");
RtfNodeCollection styles = sst.ChildNodes;
for (int i = 1; i < styles.Count; i++)
{
RtfTreeNode style = styles[i];
RtfStyleSheet rtfss = ParseStyleSheet(style);
sstable.AddStyleSheet(rtfss.Index, rtfss);
}
return(sstable);
}
/// <summary>
/// Obtiene el código del color pasado como parámetro, insertándolo en la tabla de colores si es necesario.
/// </summary>
/// <param name="colorDestTbl">Tabla de colores resultante.</param>
/// <param name="iColorName">Color buscado.</param>
/// <returns></returns>
private int getColorID(RtfColorTable colorDestTbl, Color iColorName)
{
int iExistingColorID;
if ((iExistingColorID = colorDestTbl.IndexOf(iColorName)) == -1)
{
iExistingColorID = colorDestTbl.Count;
colorDestTbl.AddColor(iColorName);
RtfNodeCollection nodeListToInsert = baseRtfDoc.RootNode.SelectNodes("colortbl");
nodeListToInsert[0].ParentNode.AppendChild(new RtfTreeNode(RtfNodeType.Keyword, "red", true, iColorName.R));
nodeListToInsert[0].ParentNode.AppendChild(new RtfTreeNode(RtfNodeType.Keyword, "green", true, iColorName.G));
nodeListToInsert[0].ParentNode.AppendChild(new RtfTreeNode(RtfNodeType.Keyword, "blue", true, iColorName.B));
nodeListToInsert[0].ParentNode.AppendChild(new RtfTreeNode(RtfNodeType.Text, ";", false, 0));
}
return(iExistingColorID);
}
private static void ExtractObjects()
{
RtfTree tree = new RtfTree();
tree.LoadRtfFile("..\\..\\testdocs\\test-doc.rtf");
//Busca el primer nodo de tipo objeto.
RtfNodeCollection objects = tree.RootNode.SelectGroups("object");
Console.WriteLine("Extracting objects...");
int i = 1;
foreach (RtfTreeNode node in objects)
{
//Se crea un nodo RTF especializado en imágenes
ObjectNode objectNode = new ObjectNode(node);
Console.WriteLine("Found new object:");
Console.WriteLine("Object type: " + objectNode.ObjectType);
Console.WriteLine("Object class: " + objectNode.ObjectClass);
byte[] data = objectNode.GetByteData();
FileStream binaryFile = new FileStream("..\\..\\testdocs\\object" + i + ".xls", FileMode.Create, FileAccess.ReadWrite);
BinaryWriter bw = new BinaryWriter(binaryFile);
for (int j = 38; j < data.Length; j++)
{
bw.Write(data[j]);
}
bw.Flush();
bw.Close();
Console.WriteLine("File 'object" + i + ".xls' created.");
i++;
}
Console.WriteLine("");
}
/// <summary>
/// Obtiene el código de la fuente pasada como parámetro, insertándola en la tabla de fuentes si es necesario.
/// </summary>
/// <param name="fontDestTbl">Tabla de fuentes resultante.</param>
/// <param name="sFontName">Fuente buscada.</param>
/// <returns></returns>
private int getFontID(ref RtfFontTable fontDestTbl, string sFontName)
{
int iExistingFontID = -1;
if ((iExistingFontID = fontDestTbl.IndexOf(sFontName)) == -1)
{
fontDestTbl.AddFont(sFontName);
iExistingFontID = fontDestTbl.IndexOf(sFontName);
RtfNodeCollection nodeListToInsert = baseRtfDoc.RootNode.SelectNodes("fonttbl");
RtfTreeNode ftFont = new RtfTreeNode(RtfNodeType.Group);
ftFont.AppendChild(new RtfTreeNode(RtfNodeType.Keyword, "f", true, iExistingFontID));
ftFont.AppendChild(new RtfTreeNode(RtfNodeType.Keyword, "fnil", false, 0));
ftFont.AppendChild(new RtfTreeNode(RtfNodeType.Text, sFontName + ";", false, 0));
nodeListToInsert[0].ParentNode.AppendChild(ftFont);
}
return(iExistingFontID);
}
public void SelectSpecialGroups()
{
RtfTree tree = new RtfTree();
int res = tree.LoadRtfFile("..\\..\\testdocs\\testdoc1.rtf");
RtfNodeCollection list1 = tree.MainGroup.SelectChildGroups("generator");
RtfNodeCollection list2 = tree.MainGroup.SelectChildGroups("generator", false);
RtfNodeCollection list3 = tree.MainGroup.SelectChildGroups("generator", true);
RtfNodeCollection list4 = tree.MainGroup.SelectGroups("generator");
RtfNodeCollection list5 = tree.MainGroup.SelectGroups("generator", false);
RtfNodeCollection list6 = tree.MainGroup.SelectGroups("generator", true);
RtfTreeNode node1 = tree.MainGroup.SelectSingleChildGroup("generator");
RtfTreeNode node2 = tree.MainGroup.SelectSingleChildGroup("generator", false);
RtfTreeNode node3 = tree.MainGroup.SelectSingleChildGroup("generator", true);
RtfTreeNode node4 = tree.MainGroup.SelectSingleGroup("generator");
RtfTreeNode node5 = tree.MainGroup.SelectSingleGroup("generator", false);
RtfTreeNode node6 = tree.MainGroup.SelectSingleGroup("generator", true);
Assert.That(list1.Count, Is.EqualTo(0));
Assert.That(list2.Count, Is.EqualTo(0));
Assert.That(list3.Count, Is.EqualTo(1));
Assert.That(list4.Count, Is.EqualTo(0));
Assert.That(list5.Count, Is.EqualTo(0));
Assert.That(list6.Count, Is.EqualTo(1));
Assert.That(node1, Is.Null);
Assert.That(node2, Is.Null);
Assert.That(node3, Is.Not.Null);
Assert.That(node4, Is.Null);
Assert.That(node5, Is.Null);
Assert.That(node6, Is.Not.Null);
}
private RtfTree _ConvertMMath(RtfTree tree)
{
RtfNodeCollection nodes = tree.RootNode.SelectNodes("mmath");
//RtfNodeCollection nodes = tree.RootNode.ChildNodes;
foreach (RtfTreeNode n in nodes)
{
Console.WriteLine(n.ParentNode.Rtf);
RtfTreeNode auxNode = null;
if ((auxNode = n.ParentNode.SelectSingleNode("nonshppict")) != null)
{
ImageNode imageNode = new ImageNode(auxNode.ParentNode.SelectSingleNode("pict").ParentNode);
ConvertEquation ce = new ConvertEquation();
EquationInput ei = new EquationInputFileEPS(imageNode.GetByteData());
EquationOutput eo = new EquationOutputFileGIF(GetOutputFile("gif"));
ce.Convert(ei, eo);
//string strEquation = ce.ConvertToText(ei);
//EquationObj equationObj = Wmf2Equation(imageNode);
//tree.RootNode.FirstChild.ReplaceChildDeep(n.ParentNode, getReplaceNode());
//rtf_replace.Add(equationObj);
}
else
{
MessageBox.Show("'\result' node contains no images!");
}
tree.RootNode.FirstChild.RemoveChildDeep(n.ParentNode);
}
return(tree);
}
private RtfTree _ConvertObject(RtfTree tree)
{
RtfNodeCollection nodes = tree.RootNode.SelectNodes("object");
//RtfNodeCollection nodes = tree.RootNode.ChildNodes;
foreach (RtfTreeNode n in nodes)
{
ObjectNode objectNode = new ObjectNode(n.ParentNode);
if (objectNode.ObjectType == "objemb" && objectNode.ObjectClass == "Equation.DSMT4")
{
RtfTreeNode resultNode = objectNode.ResultNode;
RtfTreeNode auxNode = null;
if ((auxNode = resultNode.SelectSingleNode("pict")) != null)
{
ImageNode imageNode = new ImageNode(auxNode.ParentNode);
EquationObj equationObj = Wmf2Equation(imageNode);
tree.RootNode.FirstChild.ReplaceChildDeep(n.ParentNode, getReplaceNode());
rtf_replace.Add(equationObj);
}
else
{
MessageBox.Show("'\result' node contains no images!");
}
}
tree.RootNode.FirstChild.RemoveChildDeep(n.ParentNode);
}
return(tree);
}
private void button5_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog1 = new OpenFileDialog();
//Se establecen las propiedades del cuadro de diálogo "Abrir"
openFileDialog1.InitialDirectory = "c:\\";
openFileDialog1.Filter = "Archivos RTF (*.rtf)|*.rtf|Todos los archivos (*.*)|*.*";
openFileDialog1.FilterIndex = 1;
openFileDialog1.RestoreDirectory = true;
//Se muestra el cuadro de diálogo Abrir y se espera a que se seleccione un fichero RTF.
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
//Se crea un árbol RTF
RtfTree arbol = new RtfTree();
//Se carga el documento seleccionado (Este método parsea el documento y crea la estructura de árbol interna)
arbol.LoadRtfFile(openFileDialog1.FileName);
//Busca todos los nodos de tipo "\pict" (Imagen)
RtfNodeCollection imageNodes = arbol.RootNode.SelectNodes("pict");
//Se recorren los nodos encontrados
int i = 1;
foreach (RtfTreeNode node in imageNodes)
{
//Se crea un nodo RTF especializado en imágenes
ImageNode imageNode = new ImageNode(node.ParentNode);
//Se guarda el contenido de la imagen a un fichero con el formato original con el que se almacenó en el documento.
imageNode.SaveImage("image" + i + "." + getExtension(imageNode.ImageFormat));
i++;
}
}
}
private RtfTree _ConvertPict(RtfTree tree)
{
RtfNodeCollection shppict_nodes = tree.RootNode.SelectNodes("shppict");
foreach (RtfTreeNode n in shppict_nodes)
{
tree.RootNode.FirstChild.RemoveChildDeep(n.ParentNode);
}
RtfNodeCollection pict_nodes = tree.RootNode.SelectNodes("pict");
foreach (RtfTreeNode n in pict_nodes)
{
ImageNode imageNode = new ImageNode(n.ParentNode);
pictObj pictObj = new pictObj();
ImageConverter ic = new ImageConverter();
Image img = (Image)ic.ConvertFrom(imageNode.GetByteData());
ImageFormat format = getImageFormat(img);
//string imgBase64Code = Convert.ToBase64String(imageNode.GetByteData());
string imgBase64Code = ImageToBase64(img, format);
pictObj.format = format;
pictObj.content = imgBase64Code;
pictObj.attr("width", imageNode.Width);
pictObj.attr("height", imageNode.Height);
tree.RootNode.FirstChild.ReplaceChildDeep(n.ParentNode.ParentNode, getReplaceNode());
rtf_replace.Add(pictObj);
tree.RootNode.FirstChild.RemoveChildDeep(n.ParentNode.ParentNode);
}
return(tree);
}
/// <summary>
/// Constructor de la clase RtfTreeNode. Crea un nodo especificando su tipo, palabra clave y parámetro.
/// </summary>
/// <param name="type">Tipo del nodo.</param>
/// <param name="key">Palabra clave o símbolo de Control.</param>
/// <param name="hasParameter">Indica si la palabra clave o el símbolo de Control va acompañado de un parámetro.</param>
/// <param name="parameter">Parámetro del la palabra clave o símbolo de Control.</param>
public RtfTreeNode(RtfNodeType type, string key, bool hasParameter, int parameter)
{
this.type = type;
this.key = key;
this.hasParam = hasParameter;
this.param = parameter;
if (type == RtfNodeType.Group || type == RtfNodeType.Root)
children = new RtfNodeCollection();
if (type == RtfNodeType.Root)
this.root = this;
/* Inicializados por defecto */
//this.parent = null;
//this.root = null;
//this.tree = null;
//children = null;
}
/// <summary>
/// Añade al final de la colección una nueva lista de nodos.
/// </summary>
/// <param name="collection">Nueva lista de nodos a añadir a la colección actual.</param>
public void AddRange(RtfNodeCollection collection)
{
InnerList.AddRange(collection);
}
/// <summary>
/// Busca todos los nodos de tipo Texto que contengan el texto buscado.
/// </summary>
/// <param name="text">Texto buscado en el documento.</param>
/// <returns>Lista de nodos, a partir del actual, que contienen el texto buscado.</returns>
public RtfNodeCollection FindText(string text)
{
RtfNodeCollection list = new RtfNodeCollection();
//Si el nodo actual tiene hijos
if (children != null)
{
foreach (RtfTreeNode node in children)
{
if (node.NodeType == RtfNodeType.Text && node.NodeKey.IndexOf(text) != -1)
list.Add(node);
else if(node.NodeType == RtfNodeType.Group)
list.AddRange(node.FindText(text));
}
}
return list;
}
public void RemoveNodesFromCollection()
{
RtfNodeCollection list1 = new RtfNodeCollection();
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "a", true, 1));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "b", true, 2));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "c", true, 3));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "d", true, 4));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "e", true, 5));
Assert.That(list1.Count, Is.EqualTo(5));
Assert.That(list1[1].NodeKey, Is.EqualTo("b"));
list1.RemoveAt(1);
Assert.That(list1.Count, Is.EqualTo(4));
Assert.That(list1[0].NodeKey, Is.EqualTo("a"));
Assert.That(list1[1].NodeKey, Is.EqualTo("c"));
Assert.That(list1[2].NodeKey, Is.EqualTo("d"));
Assert.That(list1[3].NodeKey, Is.EqualTo("e"));
list1.RemoveRange(1, 2);
Assert.That(list1.Count, Is.EqualTo(2));
Assert.That(list1[0].NodeKey, Is.EqualTo("a"));
Assert.That(list1[1].NodeKey, Is.EqualTo("e"));
}
/// <summary>
/// COnstructor de la clase RtfStyleSheet.
/// </summary>
public RtfStyleSheet()
{
keyCode = null;
formatting = new RtfNodeCollection();
}
/// <summary>
/// Función encargada de procesar los nodos hijo de un nodo padre RTF un nodo del documento RTF
/// y generar las etiquetas HTML necesarias
/// </summary>
private void ProcessChildNodes(RtfNodeCollection nodos, int inicio)
{
for (int i = inicio; i < nodos.Count; i++)
{
RtfTreeNode nodo = nodos[i];
switch (nodo.NodeType)
{
case RtfNodeType.Control:
if (nodo.NodeKey == "'") //Símbolos especiales, como tildes y "ñ"
{
WriteText(Encoding.Default.GetString(new[] { (byte)nodo.Parameter }));
}
break;
case RtfNodeType.Keyword:
switch (nodo.NodeKey)
{
case "pard": //Reinicio de formato
_currentFormat.Reset();
break;
case "f": //Tipo de fuente
if (nodo.Parameter < _fontTable.Count)
_currentFormat.FontName = _fontTable[nodo.Parameter];
break;
case "cf": //Color de fuente
if (nodo.Parameter < _colorTable.Count)
_currentFormat.ForeColor = _colorTable[nodo.Parameter];
break;
case "highlight": //Color de fondo
if (nodo.Parameter < _colorTable.Count)
_currentFormat.BackColor = _colorTable[nodo.Parameter];
break;
case "fs": //Tamaño de fuente
_currentFormat.FontSize = nodo.Parameter;
break;
case "b": //Negrita
_currentFormat.Bold = !nodo.HasParameter || nodo.Parameter == 1;
break;
case "i": //Cursiva
_currentFormat.Italic = !nodo.HasParameter || nodo.Parameter == 1;
break;
case "ul": //Subrayado ON
_currentFormat.Underline = true;
break;
case "ulnone": //Subrayado OFF
_currentFormat.Underline = false;
break;
case "super": //Superscript
_currentFormat.Superscript = true;
_currentFormat.Subscript = false;
break;
case "sub": //Subindice
_currentFormat.Subscript = true;
_currentFormat.Superscript = false;
break;
case "nosupersub":
_currentFormat.Superscript = _currentFormat.Subscript = false;
break;
case "qc": //Alineacion centrada
_currentFormat.Alignment = HorizontalAlignment.Center;
break;
case "qr": //Alineacion derecha
_currentFormat.Alignment = HorizontalAlignment.Right;
break;
case "li": //tabulacion
_currentFormat.Margin = nodo.Parameter;
break;
case "line":
case "par": //Nueva línea
_builder.Append("<br />");
break;
}
break;
case RtfNodeType.Group:
//Procesar nodos hijo, si los tiene
if (nodo.HasChildNodes())
{
if (nodo["pict"] != null) //El grupo es una imagen
{
ImageNode imageNode = new ImageNode(nodo);
WriteImage(imageNode);
}
else
{
ProcessChildNodes(nodo.ChildNodes, 0);
}
}
break;
case RtfNodeType.Text:
WriteText(nodo.NodeKey);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
/// <summary>
/// Añade un nodo al final de la lista de hijos.
/// </summary>
/// <param name="newNode">Nuevo nodo a añadir.</param>
public void AppendChild(RtfTreeNode newNode)
{
if(newNode != null)
{
//Si aún no tenía hijos se inicializa la colección
if (children == null)
children = new RtfNodeCollection();
//Se asigna como nodo padre el nodo actual
newNode.parent = this;
//Se actualizan las propiedades Root y Tree del nuevo nodo y sus posibles hijos
updateNodeRoot(newNode);
//Se añade el nuevo nodo al final de la lista de nodos hijo
children.Add(newNode);
}
}
/// <summary>
/// Devuelve todos los nodos, a partir del nodo actual, cuya palabra clave y parámetro son los indicados como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <param name="param">Parámetro buscado.</param>
/// <returns>Colección de nodos, a partir del nodo actual, cuya palabra clave y parámetro son los indicados como parámetro.</returns>
public RtfNodeCollection SelectNodes(string keyword, int param)
{
RtfNodeCollection nodes = new RtfNodeCollection();
foreach (RtfTreeNode node in children)
{
if (node.key == keyword && node.param == param)
{
nodes.Add(node);
}
nodes.AddRange(node.SelectNodes(keyword, param));
}
return nodes;
}
/// <summary>
/// Devuelve todos los nodos de la lista de nodos hijos del nodo actual cuya palabra clave es la indicada como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <returns>Colección de nodos de la lista de nodos hijos del nodo actual cuya palabra clave es la indicada como parámetro.</returns>
public RtfNodeCollection SelectChildNodes(string keyword)
{
RtfNodeCollection nodes = new RtfNodeCollection();
foreach (RtfTreeNode node in children)
{
if (node.key == keyword)
{
nodes.Add(node);
}
}
return nodes;
}
/// <summary>
/// Devuelve todos los nodos de la lista de nodos hijos del nodo actual cuyo tipo es el indicado como parámetro.
/// </summary>
/// <param name="nodeType">Tipo del nodo buscado.</param>
/// <returns>Colección de nodos de la lista de nodos hijos del nodo actual cuyo tipo es el indicado como parámetro.</returns>
public RtfNodeCollection SelectChildNodesByType(RtfNodeType nodeType)
{
RtfNodeCollection nodes = new RtfNodeCollection();
foreach (RtfTreeNode node in children)
{
if (node.type == nodeType)
{
nodes.Add(node);
}
}
return nodes;
}
/// <summary>
/// Devuelve todos los nodos de la lista de nodos hijos del nodo actual cuya palabra clave y parámetro son los indicados como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <param name="param">Parámetro buscado.</param>
/// <returns>Colección de nodos de la lista de nodos hijos del nodo actual cuya palabra clave y parámetro son los indicados como parámetro.</returns>
public RtfNodeCollection SelectChildNodes(string keyword, int param)
{
RtfNodeCollection nodes = new RtfNodeCollection();
if (children != null)
{
foreach (RtfTreeNode node in children)
{
if (node.key == keyword && node.param == param)
{
nodes.Add(node);
}
}
}
return nodes;
}
/// <summary>
/// Devuelve todos los nodos, a partir del nodo actual, cuyo tipo es el indicado como parámetro.
/// </summary>
/// <param name="nodeType">Tipo del nodo buscado.</param>
/// <returns>Colección de nodos, a partir del nodo actual, cuyo tipo es la indicado como parámetro.</returns>
public RtfNodeCollection SelectNodes(RtfNodeType nodeType)
{
RtfNodeCollection nodes = new RtfNodeCollection();
if (children != null)
{
foreach (RtfTreeNode node in children)
{
if (node.type == nodeType)
{
nodes.Add(node);
}
nodes.AddRange(node.SelectNodes(nodeType));
}
}
return nodes;
}
/// <summary>
/// Método auxiliar para obtener el Texto RTF del nodo actual a partir de su representación en árbol.
/// </summary>
/// <param name="curNode">Nodo actual del árbol.</param>
/// <param name="prevNode">Nodo anterior tratado.</param>
/// <param name="enc">Codificación del documento.</param>
/// <returns>Texto en formato RTF del nodo.</returns>
private string getRtfInm(RtfTreeNode curNode, RtfTreeNode prevNode, Encoding enc)
{
StringBuilder res = new StringBuilder("");
if (curNode.NodeType == RtfNodeType.Root)
{
res.Append("");
}
else if (curNode.NodeType == RtfNodeType.Group)
{
res.Append("{");
}
else
{
if (curNode.NodeType != RtfNodeType.Text)
{
res.Append("\\");
}
else //curNode.NodeType == RtfNodeType.Text
{
if (prevNode == null || prevNode.NodeType == RtfNodeType.Control)
{
res.Append("");
}
else //antNode.NodeType == RtfNodeType.KEYWORD
{
res.Append(" ");
}
}
AppendEncoded(res, curNode.NodeKey, enc);
if (curNode.HasParameter)
{
if (curNode.NodeType == RtfNodeType.Keyword)
{
res.Append(Convert.ToString(curNode.Parameter));
}
else if (curNode.NodeType == RtfNodeType.Control)
{
//Si es un caracter especial como las vocales acentuadas
if (curNode.NodeKey == "\'")
{
res.Append(GetHexa(curNode.Parameter));
}
}
}
}
//Se obtienen los nodos hijos
RtfNodeCollection children = curNode.ChildNodes;
for (int i = 0; i < children.Count; i++)
{
RtfTreeNode node = children[i];
if (i > 0)
{
res.Append(getRtfInm(node, children[i - 1], enc));
}
else
{
res.Append(getRtfInm(node, null, enc));
}
}
if (curNode.NodeType == RtfNodeType.Group)
{
res.Append("}");
}
return(res.ToString());
}
/// <summary>
/// Inserta un nuevo nodo en una posición determinada de la lista de hijos.
/// </summary>
/// <param name="index">Posición en la que se insertará el nodo.</param>
/// <param name="newNode">Nuevo nodo a insertar.</param>
public void InsertChild(int index, RtfTreeNode newNode)
{
if (newNode != null)
{
//Si aún no tenía hijos se inicializa la colección
if (children == null)
children = new RtfNodeCollection();
if (index >= 0 && index <= children.Count)
{
//Se asigna como nodo padre el nodo actual
newNode.parent = this;
//Se actualizan las propiedades Root y Tree del nuevo nodo y sus posibles hijos
updateNodeRoot(newNode);
//Se añade el nuevo nodo al final de la lista de nodos hijo
children.Insert(index, newNode);
}
}
}
/// <summary>
/// Devuelve todos los nodos, a partir del nodo actual, cuya palabra clave es la indicada como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <returns>Colección de nodos, a partir del nodo actual, cuya palabra clave es la indicada como parámetro.</returns>
public RtfNodeCollection SelectNodes(string keyword)
{
RtfNodeCollection nodes = new RtfNodeCollection();
if (children != null)
{
foreach (RtfTreeNode node in children)
{
if (node.key == keyword)
{
nodes.Add(node);
}
nodes.AddRange(node.SelectNodes(keyword));
}
}
return nodes;
}
/// <summary>
/// Constructor privado de la clase RtfTreeNode. Crea un nodo a partir de un token del analizador léxico.
/// </summary>
/// <param name="token">Token RTF devuelto por el analizador léxico.</param>
internal RtfTreeNode(RtfToken token)
{
children = new RtfNodeCollection();
this.type = (RtfNodeType)token.Type;
this.key = token.Key;
this.hasParam = token.HasParameter;
this.param = token.Parameter;
/* Inicializados por defecto */
//this.parent = null;
//this.root = null;
}
/// <summary>
/// Devuelve todos los nodos grupos de la lista de nodos hijos del nodo actual cuya primera palabra clave es la indicada como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <returns>Colección de nodos grupo de la lista de nodos hijos del nodo actual cuya primera palabra clave es la indicada como parámetro.</returns>
public RtfNodeCollection SelectChildGroups(string keyword)
{
RtfNodeCollection nodes = new RtfNodeCollection();
if (children != null)
{
foreach (RtfTreeNode node in children)
{
if (node.NodeType == RtfNodeType.Group &&
node.HasChildNodes() &&
node.FirstChild.NodeKey == keyword)
{
nodes.Add(node);
}
}
}
return nodes;
}
public void SearchNodes()
{
RtfNodeCollection list1 = new RtfNodeCollection();
RtfTreeNode node = new RtfTreeNode(RtfNodeType.Keyword, "c", true, 3);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "a", true, 1));
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "b", true, 2));
list1.Add(node);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "b", true, 4));
list1.Add(node);
list1.Add(new RtfTreeNode(RtfNodeType.Keyword, "e", true, 6));
Assert.That(list1.IndexOf(node), Is.EqualTo(2));
Assert.That(list1.IndexOf(new RtfTreeNode()), Is.EqualTo(-1));
Assert.That(list1.IndexOf(node, 0), Is.EqualTo(2));
Assert.That(list1.IndexOf(node, 2), Is.EqualTo(2));
Assert.That(list1.IndexOf(node, 3), Is.EqualTo(4));
Assert.That(list1.IndexOf(node, 5), Is.EqualTo(-1));
Assert.That(list1.IndexOf("b", 0), Is.EqualTo(1));
Assert.That(list1.IndexOf("b", 1), Is.EqualTo(1));
Assert.That(list1.IndexOf("b", 2), Is.EqualTo(3));
Assert.That(list1.IndexOf("x", 0), Is.EqualTo(-1));
Assert.That(list1.IndexOf("b"), Is.EqualTo(1));
Assert.That(list1.IndexOf("x"), Is.EqualTo(-1));
}
/// <summary>
/// Constructor de la clase RtfTreeNode. Crea un nodo especificando su tipo, palabra clave y parámetro.
/// </summary>
/// <param name="type">Tipo del nodo.</param>
/// <param name="key">Palabra clave o símbolo de Control.</param>
/// <param name="hasParameter">Indica si la palabra clave o el símbolo de Control va acompañado de un parámetro.</param>
/// <param name="parameter">Parámetro del la palabra clave o símbolo de Control.</param>
public RtfTreeNode(RtfNodeType type, string key, bool hasParameter, int parameter)
{
children = new RtfNodeCollection();
this.type = type;
this.key = key;
this.hasParam = hasParameter;
this.param = parameter;
/* Inicializados por defecto */
//this.parent = null;
//this.root = null;
}
/// <summary>
/// Devuelve todos los nodos grupos de la lista de nodos hijos del nodo actual cuya primera palabra clave es la indicada como parámetro.
/// </summary>
/// <param name="keyword">Palabra clave buscada.</param>
/// <param name="ignoreSpecial">Si está activo se ignorarán los nodos de control '\*' previos a algunas palabras clave.</param>
/// <returns>Colección de nodos grupo de la lista de nodos hijos del nodo actual cuya primera palabra clave es la indicada como parámetro.</returns>
public RtfNodeCollection SelectChildGroups(string keyword, bool ignoreSpecial)
{
RtfNodeCollection nodes = new RtfNodeCollection();
if (children != null)
{
foreach (RtfTreeNode node in children)
{
if (node.NodeType == RtfNodeType.Group && node.HasChildNodes() &&
(
(node.FirstChild.NodeKey == keyword) ||
(ignoreSpecial && node.ChildNodes[0].NodeKey == "*" && node.ChildNodes[1].NodeKey == keyword))
)
{
nodes.Add(node);
}
}
}
return nodes;
}
/// <summary>
/// Constructor de la clase RtfTreeNode. Crea un nodo de un tipo concreto.
/// </summary>
/// <param name="nodeType">Tipo del nodo que se va a crear.</param>
public RtfTreeNode(RtfNodeType nodeType)
{
this.type = nodeType;
this.key = "";
if (nodeType == RtfNodeType.Group || nodeType == RtfNodeType.Root)
children = new RtfNodeCollection();
if (nodeType == RtfNodeType.Root)
this.root = this;
/* Inicializados por defecto */
//this.param = 0;
//this.hasParam = false;
//this.parent = null;
//this.root = null;
//this.tree = null;
//children = null;
}
