sgoliver.net blog

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.

Como comentamos al final del apartado anterior, las estrategias utilizadas por NRtfTree para el análisis estruturado de documentos RTF son las mismas que las utilizadas para otro tipo de documentos y formatos muy extendidos como el XML. En el contexto del formato XML existen dos aproximaciones principales al problema del análisis de su contenido: DOM (Document Object Model) y SAX (Simple API for XML).

El primero de los métodos, DOM, consiste básicamente en la carga de un documento completo en una estructura de datos en forma de árbol que puede recorrerse y manipularse fácilmente mediante una serie de métodos para la navegación y modificación del árbol. En el caso del formato RTF esto tendrá como consecuencia la modificación del aspecto y el contenido del documento.

La segunda de las soluciones, SAX, consiste en la lectura y análisis secuencial del documento, durante el cual se van lanzando una serie de eventos tratables por el desarrollador y que se corresponden con la lectura de cada uno de los elementos contenidos en el documento. Así, por ejemplo, cada vez que el analizador lee del documento una etiqueta de apertura de un elemento se lanza un evento que se podrá capturar para realizar la acciones oportunas.

El primero de los métodos es quizá el más flexible de ambos debido a que una vez cargado el documento completo éste puede recorrerse tantas veces como se desee y en el sentido que se necesite. En cambio, con SAX el documento es leido una sóla vez y las acciones realizadas deben ejecutarse a medida que se realiza el análisis, sin tener la posibilidad de “volver atrás”.

Pues bien, NRtfTree transfiere estas dos mismas soluciones al campo del formato RTF, lo que consiga gracias a la funcionalidad de varias clases principales:

• RtfTree y RtfTreeNode, que proporcionan los métodos necesarios para cargar y manipular un documento RTF en forma de estructura de árbol.
• RtfReader y SARParser, que dan la posibilidad de realizar un tratamiento al estilo SAX de un documento RTF.

En los siguientes apartados de esta documentación hablaremos con más detalle de cada uno de los modelos de funcionamiento de NRtfTree, comenzando en primer lugar por el modelo DOM para RTF.

Índice de secciones

1. Introducción
2. Descargas

Enlaces relacionados

• Web del proyecto (en inglés)
• NRtfTree en Sourceforge (en inglés)
• Foro de soporte
• Foro de peticiones
• Tracker de errores
• Repositorio Subversion
• NRtfTree en Code Project
• Especificación RTF 1.6

Introducción a JRtfTree

JRtfTree es una traducción al lenguaje Java de mi proyecto NRtfTree (C#). JRtfTree se distribuye bajo licencia GPL.

Se trata de una librería dirigida a facilitar el tratamiento estructurado de documentos con formato RTF.

El formato RTF (Rich Text Format) permite la creación de texto enriquecido en el que pueden insertarse una gran cantidad de elementos extra como imágenes, tablas, listas, hipervínculos y otras muchas características propias de cualquier procesador de texto actual.

La API ofrecida por JRtfTree permite de forma sencilla el análisis, lectura y modificación de documentos RTF, pudiendo utilizar para ello dos modelos distintos de ejecución análogos a los modelos SAX y DOM aplicados al formato XML.

Bajo el primero de los modelos, estilo DOM, JRtfTree permite analizar de forma automática un documento RTF tras convertirlo a una estructura de datos interna en forma de árbol, manejable e intuitiva, a través de la cual poder analizar y modificar el documento de una forma sencilla y eficaz sin tener que conocer a fondo los detalles del formato RTF.

Con el segundo de los modos de ejecución, estilo SAX, el documento RTF podrá analizarse de forma secuencial bajo un modelo basado en eventos, donde sólo habrá que implementar las actuaciones necesarias para tratar cada uno de los elementos leidos del documento RTF que sean relevantes para nuestra aplicación.

Mientras completo la sección de JRtfTree con más información específica para Java, puede conseguir más información sobre el proyecto visitando la página de NRtfTree, versión original de la librería en C#, que contiene información adicional y ejemplos que pueden ser aplicados muy fácilmente a la versión Java.

La versión disponible actualmente de JRtfTree (v0.1.1b) se encuentra aún en fase beta y abarca toda la funcionalidad de las clases base de la versión 0.2 de NRtfTree. Las clases de nodos especiales (imagen, objeto y grupo de información) se publicarán más adelante una vez estabilizada la versión actual.

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 este segundo tutorial nos vamos a centrar en el tratamiento de documentos RTF utilizando la segunda variante de la librería NRtfTree, es decir, realizando un tratamiento basado en eventos al estilo SAX.

Para ilustrar esto pretendemos construir un pequeño conversor de RTF a algo parecido a un XML donde se marquen mediante etiquetas los fragmentos de texto con alguno de los tres formatos más básicos que conocemos: negrita, cursiva y subrayado. Obviamente este conversor no es nada útil pero pienso que su sencillez puede aclarar algunas dudas sobre la forma de proceder con este segundo módulo de la librería.

Como ejemplo práctico de lo que deberá hacer el conversor tenemos lo siguiente, dado el texto:

NRtfTree es una librería escrita íntegramente en C# para el tratamiento estructurado de documentos RTF.

debería convertirse en lo siguiente:

<documento>NRtfTree es una librería <u>escrita íntegramente en C#</u> para el <i>tratamiento estructurado</i> de <b>documentos RTF</b>.</documento>

Tratamiento SAX: Clases RtfReader y SARParser

El esquema de trabajo con estas dos clases será el siguiente:

1. Se creará un clase heredada de SARParser donde se redefinirán todos los eventos de ésta última.
2. Se creará un objeto RtfReader asociado a la clase anterior.
3. Se cargará el documento RTF mediante el método LoadRtfFile() proporcionado por el objeto RtfReader.
4. Se iniciará la lectura del documento mediante el método Parse() proporcionado por el objeto RtfReader.

Este último paso tendrá como efecto inmediato que se comience a llamar automáticamete a los métodos redefinidos del objeto heredado de SARParser a medida que se va leyendo el documento RTF. De esta forma, cada vez que se lea una palabra clave se llamará automáticamente al método RtfKeyword(), cada vez que se lea un fragmento de texto se llamará automáticamente al método RtfText() y de forma análoga para el resto de eventos.

El listado completo de eventos es el siguiente:

Entendida esta forma de funcionamiento, queda claro que todas las acciones necesarias para nuestro conversor deberán implementarse dentro de la clase que heredemos de SARParser y distribuidas convenientemente entre los distintos eventos disponibles. Por tanto, pasemos directamente a los detalles de implementación de esta clase.

En primer lugar, nos fijaremos en las etiquetas <documento></documento> que debemos colocar al principio y final de nuestro fichero resultante. Estás etiquetas deben aparecer tan sólo una vez y en los extremos del documento por lo que el sitio ideal para escribirlas será dentro de los eventos StartDocument() y EndDocument(). Veamos cómo:

public class MiParser : SARParser
{
    public override void StartRtfDocument()
    {
        doc += "<documento>\r\n";
    }

    public override void EndRtfDocument()
    {
        doc += "\r\n</documento>";
    }

    [...]
}

Los estilos de formato nos vendrán indicados en el documento RTF mediante palabras clave, por lo que para detectar los cambios de formato que vamos a tener en cuenta para nuestro conversor y poder escribir las etiquetas correspondientes al documento de salida tendremos que redefinir el evento RtfKeyword() y realizar dentro de éste las acciones necesarias. Para llevar el control del formato actual definiremos tres variables booleanas que indiquen si se han iniciado los estilos negrita, cursiva o subrayado.

Por otro lado, hay que recordar que normalmente en un documento RTF existen muchos fragmentos de texto que realmente no aparecen en la representación final del RTF (por ejemplo en las palabras clave consideradas “destination”, para más detalles se puede consultar la especificación RTF). Estos fragmentos de texto no los queremos tener en cuenta en ningún sentido, por lo que deberemos llevar el control de cuándo comienza el texto real del documento, tras la primera palabra clave “\pard”. Para esto definiremos otra variable booleana desactivada por defecto, que sólo activaremos al encontrar el comienzo real del texto.

En caso de detectarse alguna de las palabras clave consideradas (\b, \i, \ul), se activará o desactivará su variable asociada según el valor del parámetro asociado y se escribirá al documento de salida la etiqueta correspondiente.

private bool enTexto        = false;
private bool negrita        = false;

private bool cursiva        = false;
private bool subrayado        = false;

[...]

public override void RtfKeyword(string key, bool hasParam, int param)
{
    if(key.Equals("pard"))
        enTexto = true;

    if(enTexto)
    {
        switch(key)
        {
            case "b":
                if(!hasParam || (hasParam && param == 1))
                {
                    doc += "<b>";
                    negrita = true;
                }
                else
                {
                    doc += "</b>";
                    negrita = false;
                }
                break;
            case "i":
                if(!hasParam || (hasParam && param == 1))
                {
                    doc += "<i>";
                    cursiva = true;
                }
                else
                {
                    doc += "</i>";
                    cursiva = false;
                }
                break;
            case "ul":
                doc += "<u>";
                subrayado = true;
                break;
            case "ulnone":
                doc += "</u>";
                subrayado = false;
                break;
        }
    }
}

En cuanto a los inicios y finales de grupo tan sólo tendremos que tener en cuenta éstos últimos. Esto es debido a que en RTF no hay por qué “cerrar” las etiquetas abiertas anteriormente como en HTML, es decir, que una etiuqeta \b no tiene por qué ir seguida de una \b0 para terminar de escribir en negrita, sino que la primera puede ir encerrada dentro de un grupo RTF y el formato definido dentro de un grupo sólo se aplica dentro de éste, independientemente del formato definido fuera de él. Por tanto, cada vez que detectmenos un final de grupo deberemos cerrar todas las etiquetas de nuestro documento de salida que estuvieran abiertas con anterioridad. Veamos el código:

public override void EndRtfGroup()
{
    if(enTexto)
    {
        if(negrita)
            doc += "</b>";

        if(cursiva)
            doc += "</i>";

        if(subrayado)
            doc += "</u>";

        negrita = false;
        cursiva = false;
        subrayado = false;
    }
}

Por último, sólo nos quedan los símbolos de control y los fragmentos de texto. Para nuestro conversor trataremos ambos igual dado que los únicos símbolos de control que vamos a tener en cuenta son los destinados a codificar caracteres especiales (en nuestro caso las vocales acentuadas y las ‘ñ’). Para ambos, lo único que haremos será escribir el fragmento de texto o el caracter especial al documento de salida, con la única diferencia de que para los caracteres especiales tendremos que hacer la conversión previa entre el valor del parámetro asociado al símbolo de control y el caracter en castellano:

public override void RtfControl(string key, bool hasParam, int param)
{
    if(key == "'") //Caracter especial
    {
        doc += translateAnsiCode(param);
    }
}

public override void RtfText(string text)
{
    if(enTexto)
    {
        doc += text;
    }
}

La implementación del método translateAnsiCode() es sumamente sencilla y puede consultarse en el código fuente proporcionado con la librería y su aplicación de demostración.

Vista la implementación de nuestra clase heredada de SARParser, ya sólo nos queda ver cómo cargar el documento RTF y lanzar la lectura del mismo para que se ejecuten las acciones definidas en los eventos de SARParser.

public string traducir()
{
    string res = "";

    //Construimos nuestro parser
    MiParser parser = new MiParser(res);

    //Construimos el RTFReader que tratará el documento a través del SARParser creado anteriormente.
    reader = new RtfReader(parser);

    //Cargamos el fichero RTF
    reader.LoadRtfFile(rutaRTF);

    //Comenzamos el análisis del documento
    reader.Parse();

    return parser.doc;
}

El método anterior se limita a seguir los cuatro pasos indicados al principio de este texto: crear un objeto de nuestra clase heredada, crear un objeto RtfReader asociándole el objeto anterior (se le pasa como parámetro al constructor), cargar el documento RTF mediante el método LoadRtfFile() y por último iniciar la lectura del documento mediante el método Parse().

El código fuente mostrado en este tutorial se proporciona como parte de la aplicación de ejemplo distribuida con la librería NRtfTree, la cual puede obtenerse desde la página de descargas.

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.

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 formato RTF (Rich Text Format) nace como un método de codificación de texto con formato e imágenes fácil de transferir entre distintos dispositivos, sistemas y aplicaciones. Con la especificación de este formato se pretende que un documento creado en un sistema determinado pueda consultarse y manipularse en cualquier otro contexto diferente sin las barreras impuestas por otros formatos propietarios.

Esta capacidad surge del hecho de que internamente un documento RTF se almacena como texto plano, en el que se incluye tanto la información del documento en sí como una serie de metadatos que informan del formato del documento y del resto de propiedades adicionales aportadas por RTF.

Un documento RTF se compone de cuatro elementos básicos: texto sin formato, palabras de control (también llamadas palabras clave), símbolos de control y grupos.

Una palabra de control es un comando RTF que se utilizará para dar información acerca del formato del documento o cualquier otro tipo de información adicional sobre el texto. Las palabras de control tienen la siguiente forma:

\PalabraControl<Delimitador>

donde PalabraControl puede ser cualquier combinación de letras en minúscula y <Delimitador> puede ser uno de los siguientes:

1. Un espacio en blanco. En este caso éste se considerará parte de la palabra de control, es decir, no formará parte del texto del documento.
2. Un dígito o un guión (“-”). Esto significará que existe un parámetro numérico que acompaña a la palabra de control. Este parámetro terminará al encontrarse un espacio o cualquier caracter no alfanumérico.
3. Cualquier caracter no alfanumérco. En este caso este caracter no se considerará parte de la palabra de control.

Un símbolo de control se utilizará, entre otras cosas, para representar determinados caracteres especiales y tendrá la siguiente forma:

\SimboloControl<Parametro>

donde SimboloControl puede ser cualquier caracter no alfanumérico y <Parametro> (opcional) será cualquier valor alfanumérico. Además, es importante remarcar que los símbolos de control no van separados por ningún tipo de delimitador. Un ejemplo de símbolo de control puede ser \~ que representa un espacio indivisible.

Un grupo consiste en un conjunto de texto, palabras y símbolos de control encerrados entre llaves (‘{‘ y ‘}’) de forma que todo el texto del documento contenido en un grupo comparte las mismas propiedades. Además, existen grupos especiales que forman parte de la cabecera de un documento RTF y contienen información sobre las fuentes, colores y estilos, entre otros, contenidos en el documento.

Veamos un ejemplo de documento RTF donde aparecen todos los elementos comentados:

{\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}

El código RTF mostrado corresponde al texto con formato siguiente:

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

La estructura general de un documento fuente RTF es la siguiente:

‘{‘ <Cabecera> <Contenido del documento> ‘}’

Por su parte, la cabecera del documento tendrá la siguiente estructura:

<Cabecera> –> \rtf <charset> \deff ? <fonttbl> <filetbl>? <colortbl>? <stylesheet>? <listtables>? <revtbl>?

con los siguientes significados:

<charset> : Tabla de caracteres utilizada en la codificación del documento.

\deff : Fuente por defecto.

<fonttbl>: Tabla de fuentes. Aquí se incluirán todas las fuentes utilizadas en el documento.

<filetbl>: Tabla de ficheros. Utilizada sólo cuando el documento incluye subdocumentos.

<colortbl>: Tabla de colores. Aquí se incluirán todos los colores de fuente utilizados en el documento.

<stylesheet>: Tabla de estilos. Aquí se incluirán los estilos utilizados en el documento.

<listtables>: Tablas de listas. Donde se incluye información sobre las listas, numeradas o no, contenidas en el documento.

<revtbl>: Tabla de revisiones. Que contendrá información sobre las modificaciones realizadas en el documento.

De todos estos elementos, tan sólo el conjunto de caracteres y la tabla de fuentes son obligatorios, y normalmente, tan sólo éstos junto con la tabla de colores serán los que aparezcan en la mayoría de documentos.

En el primer ejemplo podemos ver estas dos tablas habituales. Por un lado la tabla de fuentes donde se definen dos fuentes distintas Arial y Courier New:

{\fonttbl{\f0\fswiss\fcharset0 Arial;}{\f1\fmodern\fprq1\fcharset0 Courier New;}}

Y por otro lado tembién tenemos la tabla de colores, donde definimos tres colores, uno predeterminado que depende de la aplicación que trate el documento (indicado por el primer punto y coma) y otros dos definidos por sus valores RGB:

{\colortbl ;\red255\green0\blue0;\red0\green0\blue128;}

Por último, justo a continuación de la cabecera del documento, comienza el contenido del documento en sí, que irá acompañado de las palabras y símbolos de control que den información sobre su formato. Así por ejemplo, el fragmento siguiente:

\b\f0\fs20 NRTFTree v0.1

indica que el texto “NRTFTree v0.1” se escribirá en negrita (\b), con la fuente número 0 de la tabla de fuentes (\f0) y con tamaño de fuente 20 (\fs20).

Para una información más detallada sobre la especificación del formato RTF se puede consultar el documento oficial en el enlace que se indica al final de este artículo.

Librería NRtfTree

La librería de clases NRtfTree proporciona una serie de mecanismos generales para la lectura y manipulación de documentos RTF.

Como se ha podido comprobar en el apartado anterior, la estructura de un documento RTF resulta en principio un tanto encríptica y a priori nada fácil de manipular de forma automática. Aunque en el fondo esto no es así, si que es cierto que el desarrollo de analizadores a medida para este tipo de documentos es una tarea relativamente complicada o al menos laboriosa, y es en este aspecto donde NRtfTree puede resultar de gran ayuda.

Las estrategias utilizadas por NRtfTree para el análisis estruturado de documentos RTF son las mismas que las utilizadas para otro tipo de documentos y formatos muy extendidos como el XML. En el contexto del formato XML existen dos aproximaciones principales al problema del análisis de su contenido: DOM (Document Object Model) y SAX (Simple API for XML).

El primero de los métodos, DOM, consiste básicamente en la carga de un documento XML completo en una estructura de datos en forma de árbol que puede manipularse fácilmente mediante una serie de métodos para el recorrido y modificación del árbol.

La segunda de las soluciones, SAX, consiste en la lectura y análisis secuencial del documento XML, durante el cual se van lanzando una serie de eventos tratables por el desarrollador y que se corresponden con la lectura de cada uno de los elementos contenidos en el documento. Así, por ejemplo, cada vez que el analizador lee del documento una etiqueta de apertura de un elemento se lanza un evento que se podrá capturar para realizar la acciones oportunas.

El primero de los métodos es quizá el más flexible de ambos debido a que una vez cargado el documento completo éste puede recorrerse tantas veces como se desee y en el sentido que se necesite. En cambio, con SAX el documento es leido una sóla vez y las acciones realizadas deben ejecutarse a medida que se analiza el documento y sin tener la posibilidad de “volver atrás”.

Pues bien, NRtfTree transfiere estas dos mismas soluciones al campo del formato RTF, y de esta forma tendremos dos clases principales:

• RtfTree y RtfTreeNode, que proporcionan los métodos necesarios para cargar y manipular un documento RTF en forma de estructura de árbol.
• RtfReader y SARParser, que dan la posibilidad de realizar un tratamiento al estilo SAX de un documento RTF.

RtfTree y RtfTreeNode

Como hemos comentado, RtfTree nos va dar la posibilidad de tratar los distintos elementos de un documento RTF como si formaran parte de una estructura en forma de árbol. Esto facilitará 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, cada nodo de éste representará un elemento del documento, que se diferenciarán por el tipo de nodo. De esta forma existirán 5 tipos de nodo:

ROOT      Nodo raíz del árbol.
KEYWORD   Palabra de control.
CONTROL   Símbolo de control.
TEXT      Texto del documento.
GROUP     Grupo RTF

Cada nodo del árbol irá acompañado además de su parámetro correspondiente en caso de exisitir, por lo que quedarán perfectamente separados todos los elementos del documento y su información asociada.

Como ejemplo, veamos el árbol creado al cargar el documento de la figura 1:

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.

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. Para una información más detallada de los métodos y propiedades disponibles se puede consultar la documentación proporcionada en formato CHM junto al código fuente de la misma.

RtfReader y SARParser

El objetivo de estas dos clases 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.

Enlaces relacionados

Especificación formato RTF versión 1.6 [http://latex2rtf.sourceforge.net/rtfspec.html]

NRtfTree Library is an open source .NET library written entirely in C# that may be used to manage RTF documents in your own applications. NRtfTree Library is licensed under the GNU LGPL license.

Note: If you are looking for a Java port of NRtfTree, you can have a look at JRtfTree Project.

Table of Contents

1. Introduction
2. NRtfTree by Example
3. Downloads
4. Changelog

Related Links

• NRtfTree Official Site
• NRtfTree in Sourceforge
• NRtfTree in Code Project
• Support Requests
• Feature Requests
• Bugs Tracker
• Subversion Repository [SVN]
• RTF Specification1.6 [online]
• RTF Specification 1.8 [download]

Introduction

RTF (Rich Text Format) is a method of encoding formatted text and graphics for easy transfer between applications. An RTF document can contain text, images, tables, lists, hyperlinks and many other text and graphic elements. In addition, RTF is the format used internally by the RichTextBox control included as part of .NET Framework. Nevertheless, RichTextBox functionality is not enough to satisfy all aspects of RTF file management, and NRtfTree will help you in this scenario.

NRtfTree will help you to:

• Open and parse RTF files.
• Analyze the content of RTF files.
• Add, modify and remove document elements (i.e. text, control words, control symbols).
• Create new RTF documents.

NRtfTree has two modes of operation:

1. DOM-like mode: RTF documents are loaded in a tree structure and are provided several methods to traverse it, access tag contents and modify or create new nodes. This implementation requires the entire content of a document to be parsed and stored in memory.
2. SAX-like mode: RTF file parser is implemented as an event-driven model in which the programmer provides callback methods that are invoked by the parser as part of its traversal of the RTF document.

Publico el segundo tutorial sobre la librería NRtfTree, esta vez centrado en el tratamiento de documentos RTF al estilo SAX, es decir, basado en eventos.

Como siempre, se puede acceder a este tutorial por medio de este enlace directo o accediendo a la página del proyecto.