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.

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].

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.

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.

NRtfTree es una librería .NET escrita íntegramente en C# y dirigida a facilitar el tratamiento estructurado de documentos con formato RTF. NRtfTree se distribuye bajo licencia LGPL.

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

En el apartado anterior vimos cómo 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.

Además, otro aspecto importante a considerar es que RTF es el formato utilizado internamente por el control RichTextBox proporcionado por Microsoft en la plataforma .NET. Este control permite incluir con suma facilidad en nuestras aplicaciones controles de edición de texto enriquecido. Sin embargo, no se proporcionan demasiadas facilidades a la hora de manipular el contenido RTF del control.

Las dos situaciones habituales cuando utilizamos el control RichTextBox serán:

• Trasladar toda la información contenida en el mismo, formato incluido, a otro formato distinto.
• Analizar la información para tomar decisiones como parte de la lógica de nuestra aplicación.

En ninguna de estas dos situaciones nos podrá ayudar demasiado la funcionalidad original del control y por tanto necesitamos de otros medios para afrontarlas.

En este punto es donde puede entenderse la utilidad de la librería que presentamos. NRtfTree permite analizar de forma automática un documento RTF y convertirlo a una estructura de datos interna manejable e intuitiva a través de la cual poder analizar y/o modificar el documento de una forma sencilla y eficaz sin tener que conocer a fondo los detalles del formato tratado.

La solución aportada por NRtfTree es muy similar a los modelos DOM y SAX utilizados con otros formatos como XML. Ambos modelos serán comentados detalladamente en el siguiente apartado de la documentació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 descargar la documentación oficial desde el siguiente enlace: [Especificación RTF versión 1.8]

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.

Documentación Librería NRtfTree

1. Introducción al formato RTF
2. Introducción a NRtfTree
3. Modos de funcionamiento
4. Modelo DOM [RtfTree/RtfTreeNode]
   1. Carga de documentos
   2. Navegación entre nodos
   3. Búsqueda de nodos
   4. Creación y eliminación de nodos
5. Modelo SAX [RtfReader/SARParser]
6. Generación de documentos RTF [RtfDocument]
7. Combinación de documentos RTF [RtfMerger]
8. Otras fuentes de información sobre NRtfTree:
   1. Ejemplos NRtfTree
   2. Tutorial NRtfTree I: Modelo DOM – Conversor RTF a HTML
   3. Tutorial NRtfTree II: Modelo SAX – Conversor RTF a XML
   4. Documentación API NRtfTree (formatos CHM y HTML)

Algunos recursos con información valiosa sobre ASP.NET MVC:

• La propia web oficial de ASP.NET MVC, con gran cantidad de información, tutoriales, videos, ejemplos…
• La documentación oficial de ASP.NET MVC en MSDN.
• Una lista de 10 cuestiones básicas sobre ASP.NET MVC que pueden ayudar a aclarar algunas dudas iniciales [Edito: Actulización de la lista de preguntas para la versión ASP.NET MVC 1.0].
• Una serie de artículos de Scott Guthrie en cuatro entregas [1, 2, 3, 4].
• Recordar también que el propio Scott Guthrie publicó en su blog hace unos días un fantástico tutorial de 185 páginas sobre ASP.NET MVC que forma parte del libro Professional ASP.NET MVC y cuyo enlace de descarga podéis encontrar en la entrada que dedicamos a dicha noticia.
• Otro buen recurso de información sobre ASP.NET MVC es el ASP.NET MVC Training Kit publicado por Microsoft, que contiene entre otros Hand On Labs, demos y presentaciones sobre el framework.
• Como utilizar ejemplos es casi siempre la mejor forma de aprender, os paso también una lista de aplicaciones de ejemplo [open source] construídas con ASP.NET MVC.
• Y por último un par de artículos sobre consejos o buenas prácticas a la hora de utilizar ASP.NET MVC que pueden ayudarnos a hacer menos laboriosas algunas tareas.

Suficiente por el momento para comenzar a utilizar este fantástico framework.