sgoliver.net blog

Estreno hoy una nueva sección de documentación sobre la librería NRtfTree. Esto era algo que tenía un poco olvidado desde hace tiempo y que ya era hora de solucionar.

Para ello, he reorganizado un poco la información que ya existía sobre la librería y la he ampliado con nuevos apartados sobre los distintos modos de funcionamiento, las opciones de carga de documentos RTF, la navegación y búsqueda de nodos, y la creación y eliminación de nuevos elementos en el árbol RTF, todo ello describiendo los recursos proporcionados por NRtfTree y aportando algunos ejemplos prácticos.

Me quedan pendientes de completar los apartados sobre generación de documentos con RtfDocument, y la combinación o fusión de documentos RTF mediante RtfMerge. Os informaré convientemente cuando ya estén disponibles éstos últimos apartados.

Espero que os sea útil.

NRtfTree permite la modificación de árboles RTF mediante la eliminación, modificación y creación de nuevos nodos en cualquier lugar del árbol. Para ello nos proporciona diversos constructores y métodos públicos que nos facilitarán esta tarea.

Creación de nuevos nodos RTF

Para la creación de nuevos nodos tendremos disponibles varios constructores de la clase RtfTreeNode:

//Crea un nuevo nodo vacío
RtfTreeNode node = new RtfTreeNode();

//Crea un nuevo nodo de tipo Keyword sin parámetro
RtfTreeNode node = new RtfTreeNode(RtfNodeType.Keyword);

//Crea un nuevo nodo de tipo Keyword,
//palabra de control "\fs" y parámetro con valor 1
RtfTreeNode node =
       new RtfTreeNode(RtfNodeType.Keyword, "fs", true, 1);

Una vez creado un nodo éste también puede ser editado a través de sus propiedades:

• NodeType (tipo de nodo, enumeración RtfNodeType)
• NodeKey (palabra de control)
• HasParameter (indica si el nodo tiene parámetro asociado)
• Parameter (valor del parámetro, 0 si HasParameter es falso)

Inserción de nodos hijos

Los nodos de tipo grupo (RtfNodeType.Group) pueden contener nodos hijos. Para insertarlos pueden utilizarse los métodos AppendChild(), InsertChild(), o acceder directamente a los métodos de su propiedad ChildNodes.

//Inserta un nuevo nodo al final de la lista de hijos
node.AppendChild(nuevoNodo);

//Inserta un nuevo nodo en la posición 3 de la lista de hijos
node.InsertChild(3, nuevoNodo);

//Inserta un nuevo nodo al final de la lista de hijos
node.ChildNodes.Add(nuevoNodo);

//Inserta un conjunto de nodos al final de la lista de hijos
node.ChildNodes.AddRange(coleccionNodos);

//Inserta un nuevo nodo en la posición 3 de la lista de hijos
node.ChildNodes.Insert(3, nuevoNodo);

Eliminación de nodos

Para eliminar nodos de un árbol RTF existen también diversos métodos dependiendo de si necesitamos hacerlo por su posición en el árbol o por su valor. Además, al igual que en el caso de la inserción de nodos, podremos hacerlo utilizando los métodos propios del nodo, o los de su colección de nodos hijos ChildNodes.

//Elimina el cuarto nodo de la lista de hijos
node.RemoveChild(3);

//Elimina un nodo concreto de la lista de hijos
node.RemoveChild(nodoAEliminar);

//Elimina el cuarto nodo de la lista de hijos
node.ChildNodes.RemoveAt(3);

//Elimina 5 nodos hijos a partir de la posición 3
node.ChildNodes.RemoveRange(3, 5);

Creación directa de árboles RTF

Vistos los métodos de creación, inserción y ensamblaje de nodos RTF. ya deberíamos saber construir un árbol RTF desde cero utilizando de forma ordenada todos estos recursos. Vemos por ejemplo como construir el siguiente documento sencillo:

{\rtf1\ansi{\fonttbl{\f0 Arial;}}\pard Prueba\par}

RtfTree tree = new RtfTree();

RtfTreeNode main = new RtfTreeNode(RtfNodeType.Group);

main.AppendChild(
           new RtfTreeNode(RtfNodeType.Keyword, "rtf", true, 1));
main.AppendChild(
           new RtfTreeNode(RtfNodeType.Keyword, "ansi", false, 0));

RtfTreeNode fontTable = new RtfTreeNode(RtfNodeType.Group);
fontTable.AppendChild(
              new RtfTreeNode(RtfNodeType.Keyword, "fonttbl", false, 0));

RtfTreeNode arial = new RtfTreeNode(RtfNodeType.Group);
arial.AppendChild(
          new RtfTreeNode(RtfNodeType.Keyword, "f", true, 0));
arial.AppendChild(
          new RtfTreeNode(RtfNodeType.Text, "Arial;", false, 0));

fontTable.AppendChild(arial);

main.AppendChild(fontTable);
main.AppendChild(
          new RtfTreeNode(RtfNodeType.Keyword, "pard", false, 0));
main.AppendChild(
           new RtfTreeNode(RtfNodeType.Text, "Prueba", false, 0));
main.AppendChild(
           new RtfTreeNode(RtfNodeType.Keyword, "par", false, 0));

tree.RootNode.AppendChild(main);

Mientras sigo trabajando en la próxima versión de NRtfTree y en la puesta al día de JRtfTree, hoy os hago llegar una aportación de Terence L. Wallace (Arkitech EBC Corporation), que ha traducido la librería NRtfTree al lenguaje Visual Basic .Net (vbNRtfTree).

Aunque esta traducción no era técnicamente necesaria dado que NRtfTree puede ser utilizada directamente desde cualquier lenguaje .Net (siempre bajo el .Net Framework 2.0 o superior), sí que puede ser interesante para aquellos que queráis modificarla o simplemente consultar su funcionamiento y prefiráis o tengáis más soltura con VB.Net que con C#.

Se trata de una traducción completa de la versión 0.3.3503 de NRtfTree. Es una versión no oficial de la librería, por lo que no tendrá soporte por mi parte ni ha sido revisada al 100%, aunque sí puedo decir que pasa todas las pruebas unitarias de la última versión de NRtfTree.

Además, un aporte añadido es que Terence, además de traducir a VB.Net el código de la librería, también ha realizado una traducción al inglés de todos los comentarios y documentación, por lo que puede ser de gran ayuda a todos los usuarios y colaboradores del proyecto no conocedores del castellano.

En definitiva, un recurso más a la mano de todos los interesados en NRtfTree.

Podéis acceder a la página de versiones no oficiales de NRtfTree para descargar los fuentes de esta versión.

vbNRtfTree es una traducción al lenguaje Visual Basic .NET (VB.NET) de la librería NRtfTree, realizada por Terence L. Wallace (Arkitech EBC Corporation).

Aunque esta traducción no era técnicamente necesaria dado que NRtfTree puede ser utilizada directamente desde cualquier lenguaje .Net (siempre bajo el .Net Framework 2.0 o superior), sí que puede ser interesante para aquellos que queráis modificarla o simplemente consultar su funcionamiento y prefiráis o tengáis más soltura con VB.Net que con C#.

Se trata de una traducción completa de la versión 0.3.3503 de NRtfTree. Es una versión no oficial de la librería, por lo que no tendrá soporte por mi parte ni ha sido revisada al 100%, aunque sí puedo decir que pasa todas las pruebas unitarias de la última versión de NRtfTree.

Además, un aporte añadido es que Terence, además de traducir a VB.Net el código de la librería, también ha realizado una traducción al inglés de todos los comentarios y documentación, por lo que puede ser de gran ayuda a todos los usuarios y colaboradores del proyecto no conocedores del castellano.

Podéis descargar los fuentes de la librería desde el siguiente enlace:

Nota Importante:

Como he indicado anteriormente, esta versión de la librería no es propia por lo que no ofrezco soporte personalmente ni asumo ningún tipo de responsabilidad sobre la misma.

En esta sección iré publicando distintas versiones de NRtfTree que me hacen llegar algunos colaboradores del proyecto. Se trata de versiones sin soporte directo por mi parte, pero que por su interés técnico o didáctico merece la pena hacer públicas a la comunidad.

Advertir de nuevo que las versiones aquí publicadas no han sido 100% revisadas por el autor de NRtfTree ni recibirán soporte técnico por su parte. Para cualquier duda o incidencia sobre una de estas versiones póngase en contacto con su autor correspondiente.

Tras un enorme parón en la actividad del blog debido a diversas circunstancias que han obligado a ello, retomamos el ritmo con una buena noticia.

La librería NRtfTree ha llegado, según estadísticas de Sourceforge, a las 5.000 descargas. Nunca pensé que un proyecto de propósito tan súmamente específico como NRtfTree podría generar “tanto” interés. Claro está que unos pocos miles de descargas no son nada en comparación con los grandes proyectos de código libre, pero sí resulta un número importante para algo que comenzó como una simple librería auxiliar para un pequeño proyecto personal.

Como curiosidad, separando las descargas por versión de la librería, tenemos los siguientes datos:

Ante esto no puedo más que dar las gracias a todos los que han colaborado aportanto ideas, nuevas funcionalidades, y reportando errores, tareas más que importantes a la hora de evolucionar un proyecto de este tipo.

Espero de aquí en adelante tener el tiempo necesario para seguir mejorando NRtfTree, y sobre todo espero seguir contando con el apoyo de los que colaboráis habitualmente con el proyecto.

Navegar entre nodos de un árbol RTF nos puede ayudar en muchas ocasiones a posicionarnos en un punto concreto del árbol de un documento. Sin embargo, si nuestra intención es localizar un determinado nodo dentro del árbol estos metodos de navegación no nos facilitarán demasiado el trabajo.

Como solución, NRtfTree proporciona una serie de métodos de búsqueda de nodos, que nos permitirán localizar nodos concretos dentro del árbol dado su tipo y/o contenido. Estos métodos de búsuqeda se pueden clasificar según dos criterios distintos.

En primer lugar, podemos agruparlos según el número de nodos que queremos localizar. Así, tendremos dos tipos distintos:

• Localización del primer nodo que cumpla el criterio de búsqueda.
• Localización de todos los nodos que cumplan el criterio de búsqueda.

En segundo lugar, también podemos agruparlos según el nivel al que queremos buscar los nodos. Así, distinguimos también dos tipos de búsquedas:

• Localizar nodos únicamente entre los nodos hijos del nodo actual.
• Localizar nodos a todos los niveles a partir del nodo actual.

La combinación de estos tipos de búsqueda dan lugar a 4 grupos distintos de métodos en NRtfTree:

//Localiza todos los nodos hijos del nodo actual que cumplen el criterio.
RtfNodeCollection SelectChildNodes(...);

//Localiza todos los nodos a cualquier nivel a partir del nodo actual que
//cumplen el criterio.
RtfNodeCollection SelectNodes(...);

//Localiza el primer nodo hijo del nodo actual que cumple el criterio.
RtfTreeNode SelectSingleChildNode(...);

//Localiza el primer nodo a cualquier nivel a partir del nodo actual que
//cumple el criterio.
RtfTreeNode SelectSingleNode(...);

En cuanto a los criterios de búsqueda, NRtfTree nos permitirá especificar los siguientes datos:

• Búsqueda de nodos por tipo (los tipos de nodo se definen en la clase RtfNodeType).
• Búsqueda de nodos por palabra clave.
• Búsqueda de nodos por palabra clave y valor del parámetro.

De esta forma, para cada uno de los cuatro tipos de búsqueda presentados, se podrá indicar cualquiera de estos tres criterios, de forma que tendremos un total de 12 métodos distintos de búsqueda de nodos dentro de un árbol RTF. Así, por ejemplo, podríamos realizar las siguientes búsquedas:

//Localizar todos los nodos a cualquier nivel a partir del nodo
//actual que cumplen el siguiente criterio de búsqueda:
//* Palabra de control = "\b"

RtfNodeCollection encontrados = nodo.SelectNodes("b");

//Localizar todos los nodos hijos del nodo actual que cumplen el
//siguiente criterio de búsqueda:
//* Palabra de control = "\cf"
//* Parámetro = "3"

RtfNodeCollection encontrados = nodo.SelectChildNodes("cf", 3);

//Localizar el primer nodo hijo del nodo actual que cumplen el
//siguiente criterio de búsqueda:
//* Tipo de nodo = Texto

RtfTreeNode encontrado = nodo.SelectSingleChildNode(RtfNodeType.TEXT);

Además de los métodos ya presentados, debemos indicar que los nodos de tipo grupo presentan una casuística especial. En muchas ocasiones, la primera palabra de control incluida en un grupo RTF indica el propósito de dicho grupo. Por ejemplo, el grupo RTF que define la tabla de colores del documento comienza siempre por la palabla de control “\colortlb”. Por tanto, es interesante disponer de métodos específicos para buscar nodos de tipo grupo indicando como criterio cuál es la primera palabra de control que debe contener. Para ello, NRtfTree proporciona los siguientes métodos, análogos a los ya comentados:

//Localiza todos los grupos hijos del nodo actual que cumplen el criterio.
RtfNodeCollection SelectChildGroups(string firstKeyword);

//Localiza todos los grupos a cualquier nivel a partir del nodo actual que
//cumplen el criterio.
RtfNodeCollection SelectGroups(string firstKeyword);

//Localiza el primer grupo hijo del nodo actual que cumple el criterio.
RtfTreeNode SelectSingleChildGroup(string firstKeyword);

//Localiza el primer grupo a cualquier nivel a partir del nodo actual que
//cumple el criterio.
RtfTreeNode SelectSingleGroup(string firstKeyword);

Uniendo la funcionalidad de las propiedades de navegación comentadas en el apartado anterior a las muchas posibilidades de los métodos de búsqueda presentados, posicionarnos en un punto concreto de un árbol RTF debería ser tan sencillo como escribir un par de líneas de código.

El primer paso a la hora de trabajar con documentos RTF mediante NRtfTree es la carga del documento. El proceso de carga será el encargado de leer el código RTF del documento, parsearlo, y construir el árbol RTF equivalente. Como ya comentamos en el apartado de introducción al modelo DOM de NRtfTree, un árbol RTF quedará representado por un objeto de la clase RtfTree, y cada uno de sus nodos será una instancia de RtfTreeNode.

NRtfTree permite cargar documentos desde un fichero en disco o directamente desde una cadena de caracteres. Ambas opciones resultan tan sencillas como llamar al método correspondiente de carga indicando como parámetro la ruta del fichero o la cadena correspondiente.

Así, para cargar un documento RTF desde un fichero de disco procederemos de la siguiente forma:

//Se crea el objeto RtfTree que albergará el árbol RTF
RtfTree tree = new RtfTree();

//Se carga el documento desde un fichero indicando su ruta
int res = tree.LoadRtfFile("midocumento.rtf");

Como vemos, en primer lugar crearemos el objeto RtfTree que va a almacenar el árbol RTF, y en segundo lugar llamamos al método LoadRtfFile() para cargar el documento. El constructor de RtfTree no recibe ningún parámetro, ya que su función es simplemente la de crear un árbol vacío (se crea tan solo el nodo ROOT). Por su parte, el método de carga recibe como parámetro la ruta del fichero a cargar y devuelve un entero con el resultado de la carga, donde un valor 0 indicará que la carga se ha realizado correctamente y un valor -1 indicará que se ha producido algún error.

De forma análoga, la carga de un documento desde una cadena de caracteres se realizaría de la siguiente forma:

//Cadena de caracteres con código RTF
string strdoc =
@"{\rtf1\ansi\ansicpg1252\deff0\deflang1034\deflangfe1034\deftab708" +
@"{\fonttbl{\f0\froman\fprq2\fcharset0 Times New Roman;}}" +
@"\viewkind4\uc1\pard\nowidctlpar\lang3082\f0\fs24 example\par}";

//Se crea el objeto RtfTree que albergará el árbol RTF
RtfTree tree = new RtfTree();

//Se carga el documento desde la cadena de caracteres
int res = tree.LoadRtfText(strdoc);

La única diferencia con el ejemplo anterior es la utilización del método LoadRtfText(), que recibe en este caso una cadena de caracteres con el contenido del documento RTF.

La única opción adicional que ofrece NRtfTree a la hora de cargar un documento es la fusión de caracteres especiales con nodos de texto adyacentes. Expliquemos esto un poco. En RTF, algunos caracteres especiales no se incluyen directamente en el codigo, sino que se representan mediante el símbolo de control \’ seguido por su código numérico correspondiente [en hexadecimal] según la codificación utilizada en el documento. Así, como ejemplo que afecta especialmente al idioma castellano, las vocales acentuadas y la letra ñ no aparecen tal cual en el código RTF, sino que aparecen codificadas de la forma descrita. Por ejemplo la vocal acentuada ‘é’ aparecerá como \’e9 .

Si no se indica ninguna opción especial a NRtfTree, cuando la librería genere por ejemplo el árbol RTF correspondiente al texto “apéndice”, cuyo código RTF es “ap\’e9ndice”, se generarán 3 nodos: un nodo de tipo texto con el contenido “ap”, un nodo de tipo control con el parámetro e9 (realmente en el nodo se almacena en decimal, en este caso 233), y otro nodo de texto con el contenido “ndice”.

Aunque para reflejar de forma fiel el contenido RTF real del documento son estos tres nodos los que deben generarse, en ocasiones esto puede no ser lo más práctico. Para ello, NRtfTree ofrece la posibilidad de fusionar, durante la carga del documento, los símbolos de control correspondientes a caracteres especiales con los nodos de texto adyacentes, si existen. Así, siguiendo con el ejemplo, para el texto “apéndice” se generaría un sólo nodo de tipo texto con el contenido completo de la palabra.

Esto se consigue activando la propiedad MergeSpecialCharacters de RtfTree antes de llamar al método de carga correspondiente. Veamos un ejemplo:

//Se crea el objeto RtfTree que albergará el árbol RTF
RtfTree tree = new RtfTree();

//Se activa la opción de combinar caracteres especiales
tree.MergeSpecialCharacters = true;

//Se carga el documento desde un fichero indicando su ruta
int res = tree.LoadRtfFile("midocumento.rtf");

En el siguiente apartado veremos cómo una vez cargado el documento y generado su árbol RTF equivalente podemos navegar facilmente por su contenido a través de sus nodos.

Esta entrada forma parte de una serie de artículos dedicados a NRtfTree, la librería .NET para tratamiento de documentos RTF, entre los cuales podrás encontrar una descripción detallada de la librería, documentación técnica, ejemplos y tutoriales de uso que pueden ser de tu interés. No olvides consultar la página principal de NRtfTree para más información.

El objetivo de este modelo, a diferencia del modelo DOM ya comentado, es proporcionar la posibilidad de realizar un tratamiento secuencial del documento RTF a medida que éste se va analizando.

El procedimiento general seguido para la utilización de esta técnica será el siguiente:

1. Implementar una clase derivada de SARParser donde habrá que redefinir, entre otros, los métodos correspondientes a cada uno de los eventos lanzados durante la lectura del documento RTF. Los eventos lanzados serán los siguientes:

• Comienzo del documento.
• Palabra de control leida.
• Símbolo de control leido.
• Texto leido.
• Inicio de grupo leido.
• Fin de grupo leido.
• Fin del documento.

2. Crear una instancia de las clases RtfReader y de la clase anterior. El objeto RtfReader se encargará de cargar el documento y comenzar su lectura. En el constructor de éste se pasará como parámetro el objeto derivado de SARParser, de forma que le estamos indicando a RtfReader qué acciones tomar cada vez que se lance un evento determinado.

3. Comenzar la lectura del documento llamando al método Parse() del objeto RtfReader.

Esta entrada forma parte de una serie de artículos dedicados a NRtfTree, la librería .NET para tratamiento de documentos RTF, entre los cuales podrás encontrar una descripción detallada de la librería, documentación técnica, ejemplos y tutoriales de uso que pueden ser de tu interés. No olvides consultar la página principal de NRtfTree para más información.

En el apartado anterior vimos como las clases RtfTree y RtfTreeNode nos van a dar la posibilidad de tratar los distintos elementos de un documento RTF como si formaran parte de una estructura en forma de árbol. Esto facilita en gran medida el análisis y modificación de un documento por parte de nuestras aplicaciones, siempre de forma muy general y sin imponer en ningún momento tratamientos o conversiones específicas del contenido.

Una vez cargado un documento en el árbol [consultar el siguiente apartado del manual para más información sobre la carga de documentos], cada nodo de éste (de la clase RtfTreeNode) representará un elemento del código RTF, que se diferenciará por su tipo de nodo, su clave, y el valor de su parámetro en caso de existir.

En cuanto al tipo de nodo, almacenado en la propiedad NodeType, NRtfTree considera 5 posibles tipos, declarados en la clase RtfNodeType, de acuerdo a los distintos elementos que componen un documento RTF [consultar el apartado de introducción al formato RTF para más detalles]:

El único tipo de nodo que no habíamos visto hasta ahora es el llamado nodo raíz o ROOT. Éste es un nodo auxiliar (es decir, no forma parte del documento real) creado por NRtfTree del cual va a partir el resto del árbol RTF del documento. Un árbol RTF vacío será aquel que cuente únicamente con el nodo ROOT.

El segundo elemento destacable de un nodo RTF es su clave, almacenada en la propiedad NodeKey de la clase RtfTreeNode. El contenido de ésta dependerá del tipo de nodo en cuestión, pudiendo tener los siguientes significados:

Por último, cada nodo también contendrá el valor de su parámetro, si existe. Este valor se almacenará en la propiedad Parameter de RtfTreeNode. Si el elemento RTF no va acompañado de ningún parámetro, el valor de esta propiedad será 0. Esto nos lleva al problema de distinguir cuándo un nodo no tiene parámetro, o sí lo tiene pero con valor 0. Para ello, cada nodo cuenta también con una propiedad booleana llamada HasParameter, que indica si el nodo tiene o no parámetro asociado.

Por mostrar un pequeño ejemplo de código, si consideramos un nodo equivalente a la palabra de control ‘\deflang3082‘, el siguiente código mostraría la siguiente salida:

Console.WriteLine("Tipo: " + nodo.NodeType);
Console.WriteLine("Clave: " + nodo.NodeKey);
Console.WriteLine("Tiene parámetro: " + nodo.HasParameter);
Console.WriteLine("Valor parámetro: " + nodo.Parameter);

/******************************
Salida del programa:

Tipo: KEYWORD
Clave: deflang
Tiene parámetro: True
Valor parámetro: 3082
*******************************/

Con todos estos elementos en cuenta, ya podemos ver un ejemplo del árbol RTF creado por NRtfTree para un documento sencillo. A continuación se muestra un documento con formato, su código interno RTF, y una representación textual del árbol RTF creado por NRtfTree (en formato “<Tipo>: <Clave> <Parámetro>”):

Texto enriquecido del documento

NRTFTree v0.1 es una librería escrita en C# para el tratamiento estructurado de documentos RTF.

Código RTF interno del documento

{\rtf1\ansi\ansicpg1252\deff0\deflang3082
{\fonttbl{\f0\fswiss\fcharset0 Arial;}{\f1\fmodern\fprq1\fcharset0 Courier New;}}
{\colortbl ;\red255\green0\blue0;\red0\green0\blue128;}
\viewkind4\uc1\pard\b\f0\fs20 NRTFTree v0.1\b0 es una librer\’eda \cf1\b\fs24 escrita en C# \cf0\b0\fs20 para el \cf2\i\fs24 tratamiento estructurado\fs20 \cf0\i0 de\f1\fs40 documentos RTF\f0\fs20 .\par}

Árbol RTF generado por NRtfTree

ROOT
  GROUP
    KEYWORD: rtf 1
    KEYWORD: ansi
    KEYWORD: ansicpg 1252
    KEYWORD: deff 0
    KEYWORD: deflang 3082
    GROUP
      KEYWORD: fonttbl
      GROUP
        KEYWORD: f 0
        KEYWORD: fswiss
        KEYWORD: fcharset 0
        TEXT: Arial;
      GROUP
        KEYWORD: f 1
        KEYWORD: fmodern
        KEYWORD: fprq 1
        KEYWORD: fcharset 0
        TEXT: Courier New;
    GROUP
      KEYWORD: colortbl
      TEXT: ;
      KEYWORD: red 255
      KEYWORD: green 0
      KEYWORD: blue 0
      TEXT: ;
      KEYWORD: red 0
      KEYWORD: green 0
      KEYWORD: blue 128
      TEXT: ;
    KEYWORD: viewkind 4
    KEYWORD: uc 1
    KEYWORD: pard
    KEYWORD: b
    KEYWORD: f 0
    KEYWORD: fs 20
    TEXT: NRTFTree v0.1
    KEYWORD: b 0
    TEXT: es una librer
    CONTROL: ' 237
    TEXT: a
    KEYWORD: cf 1
    KEYWORD: b
    KEYWORD: fs 24
    TEXT: escrita en C#
    KEYWORD: cf 0
    KEYWORD: b 0
    KEYWORD: fs 20
    TEXT: para el
    KEYWORD: cf 2
    KEYWORD: i
    KEYWORD: fs 24
    TEXT: tratamiento estructurado
    KEYWORD: fs 20
    TEXT:�
    KEYWORD: cf 0
    KEYWORD: i 0
    TEXT: de
    KEYWORD: f 1
    KEYWORD: fs 40
    TEXT: documentos RTF
    KEYWORD: f 0
    KEYWORD: fs 20
    TEXT: .
    KEYWORD: par

En la figura anterior se muestra cada elemento del documento RTF con su nivel dentro del árbol, su tipo de nodo, la palabra clave o símbolo de control correspondiente y su parámetro asociado en caso de existir. Como puede comprobarse, la estructura de árbol del documento proviene de la dependencia creada entre los nodos de tipo Grupo y sus nodos hijos asociados. NRtfTree tan sólo crea esta dependencia para los grupos RTF (y para el nodo ROOT), los demás tipos de nodo no tendrán descendientes en el árbol.

Una vez cargado el documento, las clases RtfTree y RtfTreeNode proporcionan una serie de métodos sencillos con los que se puede recorrer el árbol y modificar su contenido añadiendo, modificando o eliminando nodos. En el siguiente apartado veremos los mecanismos disponibles para navegar entre los nodos de un árbol RTF [Para una información más detallada de todos los métodos y propiedades disponibles también se puede consultar la documentación de la API de la librería proporcionada en formato CHM o HTML junto al código fuente de la misma].