Writing Your Own RTF Converter

• Download source with binaries - 2.37 MB

Introduction

In 1992, Microsoft introduced the Rich Text Format for specifying simple formatted text with embedded graphics. Initially intended to transfer such data between different applications on different operating systems (MS-DOS, Windows, OS/2, and Apple Macintosh), today this format is commonly used in Windows for enhanced editing capabilities (RichTextBox).

However, as soon as you have to work with such data in RTF format, additional wishes start to get strong:

• Simple extraction of text without consideration of any format information
• Extraction and conversion of embedded image information (scaled or unscaled)
• Conversion of the RTF layout and/or data into another format such as XML or HTML
• Transferring RTF data into a custom data model

The component introduced in this article has been designed with the following goals in mind:

• Support for the current RTF Specification 1.9.1
• Open source C# code
• Unlimited usage in console, WinForms, WPF, and ASP.NET applications
• Independence of third party components
• Unicode support
• Possibility to analyze RTF data on various levels
• Separation of parsing and the actual interpretation of the RTF data
• Extensibility of parser and interpreter
• Providing simple predefined conversion modules for text, images, XML, and HTML
• Ready-to-Use RTF converter applications for text, images, XML, and HTML
• Open architecture for simple creation of custom RTF converters

Please keep the following shortcomings in mind:

• The component offers no high-level functionality to create RTF content.
• The present RTF interpreter is restricted to content data and basic formatting options.

  There is no special support for the following RTF layout elements:

  • Tables
  • Lists
  • Automatic numbering
  • All features which require knowledge of how Microsoft Word might mean it ...

In general, this should not pose a big problem for many areas of use. A conforming RTF writer should always write content with readers in mind that they do not know about tags and features which were introduced later in the standards history. As a consequence, a lot of the content in an RTF document is stored several times (at least if the writer cares about other applications). This is taken advantage of by the interpreter here, which just simply focuses on the visual content. Some writers in common use, however, improperly support this alternate representation which will result in differences in the resulting output.

Thanks to its open architecture, the RTF parser is a solid base for development of an RTF converter which focuses on layout.

RTF Parser

The actual parsing of the data is being done by the class RtfParser. Apart from the tag recognition, it also handles (a first level of) character encoding and Unicode support. The RTF parser classifies the RTF data into the following basic elements:

• RTF Group: A group of RTF elements
• RTF Tag: The name and value of an RTF tag
• RTF Text: Arbitrary text content (not necessarily visible!)

The actual parsing process can be monitored by ParserListeners (Observer Pattern), which offers an opportunity to react on specific events and perform corresponding actions.

The integrated parser listener RtfParserListenerFileLogger can be used to write the structure of the RTF elements into a log file (mainly intended for use during development). The produced output can be customized using its RtfParserLoggerSettings. The additional RtfParserListenerLogger parser listener can be used to log the parsing process to any ILogger implementation (see System functions).

The parser listener RtfParserListenerStructureBuilder generates the Structure Model from the RTF elements encountered during parsing. That model represents the basic elements as instances of IRtfGroup, IRtfTag, and IRtfText. Access to the hierarchical structure can be gained through the RTF group available in RtfParserListenerStructureBuilder.StructureRoot. Based on the Visitor Pattern, it is easily possible to examine the structure model via any IRtfElementVisitor implementation:

  // ----------------------------------------------------------------------
  public class MyVisitor : IRtfElementVisitor
  {
    void RtfWriteStructureModel()
    {
      RtfParserListenerFileLogger logger =
         new RtfParserListenerFileLogger( @"c:\temp\RtfParser.log" );
      IRTFGroup structureRoot =
         RtfParserTool.Parse( @"{\rtf1foobar}", logger );
      structureRoot.Visit( this );
    } // RtfWriteStructureModel

    // ----------------------------------------------------------------------
    void IRtfElementVisitor.VisitTag( IRtfTag tag )
    {
      Console.WriteLine( "Tag: " + tag.FullName );
    } // IRtfElementVisitor.VisitTag

    // ----------------------------------------------------------------------
    void IRtfElementVisitor.VisitGroup( IRtfGroup group )
    {
      Console.WriteLine( "Group: " + group.Destination );
      foreach ( IRtfElement child in group.Contents )
      {
        child.Visit( this ); // recursive
      }
    } // IRtfElementVisitor.VisitGroup

    // ----------------------------------------------------------------------
    void IRtfElementVisitor.VisitText( IRtfText text )
    {
      Console.WriteLine( "Text: " + text.Text );
    } // IRtfElementVisitor.VisitText

  } // MyVisitor

Note, however, that the same result for such simple functionality could be achieved by writing a custom IRtfParserListener (see below). This can, in some cases, be useful to avoid the overhead of creating the structure model in memory.

The utility class RtfParserTool offers the possibility to receive RTF data from a multitude of sources, such as string, TextReader, and Stream. It also allows, via its IRtfSource interface, to handle all these (and even other) scenarios in a uniform way.

The interface IRtfParserListener with its base utility implementation RtfParserListenerBase offers a way to react in custom ways to specific events during the parsing process:

  // ------------------------------------------------------------------------
  public class MyParserListener : RtfParserListenerBase
  {
    // ----------------------------------------------------------------------
    protected override void DoParseBegin()
    {
      Console.WriteLine( "parse begin" );
    } // DoParseBegin

    // ----------------------------------------------------------------------
    protected override void DoGroupBegin()
    {
      Console.WriteLine( "group begin - level " + Level.ToString() );
    } // DoGroupBegin

    // ----------------------------------------------------------------------
    protected override void DoTagFound( IRtfTag tag )
    {
      Console.WriteLine( "tag " + tag.FullName );
    } // DoTagFound

    // ----------------------------------------------------------------------
    protected override void DoTextFound( IRtfText text )
    {
      Console.WriteLine( "text " + text.Text );
    } // DoTextFound

    // ----------------------------------------------------------------------
    protected override void DoGroupEnd()
    {
      Console.WriteLine( "group end - level " + Level.ToString() );
    } // DoGroupEnd

    // ----------------------------------------------------------------------
    protected override void DoParseSuccess()
    {
      Console.WriteLine( "parse success" );
    } // DoParseSuccess

    // ----------------------------------------------------------------------
    protected override void DoParseFail( RtfException reason )
    {
      Console.WriteLine( "parse failed: " + reason.Message );
    } // DoParseFail

    // ----------------------------------------------------------------------
    protected override void DoParseEnd()
    {
      Console.WriteLine( "parse end" );
    } // DoParseEnd

  } // MyParserListener

Note that the used base class already provides (empty) implementations for all the interface methods, so only the ones which are required for a specific purpose need to be overridden.

RTF Interpreter

Once an RTF document has been parsed into a structure model, it is subject to interpretation through the RTF interpreter. One obvious way to interpret the structure is to build a Document Model which provides high-level access to the meaning of the document's contents. A very simple document model is part of this component, and consists of the following building blocks:

• Document info: title, subject, author, etc.
• User properties
• Color information
• Font information
• Text formats
• Visuals
  • Text with associated formatting information
  • Breaks: line, paragraph, section, page
  • Special characters: tabulator, paragraph begin/end, dash, space, bullet, quote, hyphen
  • Images

The various Visuals represent the recognized visible RTF elements, and can be examined with any IRtfVisualVisitor implementation.

Analogous to the possibilities of the RTF parser, the provided RtfInterpreter supports monitoring the interpretation process with InterpreterListeners for specific purposes.

Analyzing documents might be simplified by using the RtfInterpreterListenerFileLogger interpreter listener, which writes the recognized RTF elements into a log file. Its output can be customized through its RtfInterpreterLoggerSettings. The additional RtfInterpreterListenerLogger interpreter listener can be used to log the interpretation process to any ILogger implementation (see System functions).

Construction of the document model is also achieved through such an interpreter listener (RtfInterpreterListenerDocumentBuilder) which, in the end, delivers an instance of an IRtfDocument.

The following example shows how to make use of the high-level API of the document model:

  // ----------------------------------------------------------------------
  void RtfWriteDocumentModel( Stream rtfStream )
  {
    RtfInterpreterListenerFileLogger logger =
      new RtfInterpreterListenerFileLogger( @"c:\temp\RtfInterpreter.log" );
    IRtfDocument document = RtfInterpreterTool.BuildDoc( rtfStream, logger );
    RtfWriteDocument( document );
  } // RtfWriteDocumentModel

  // ----------------------------------------------------------------------
  void RtfWriteDocument( IRtfDocument document )
  {
    Console.WriteLine( "RTF Version: " + document.RtfVersion.ToString() );

    // document info
    Console.WriteLine( "Title: " + document.DocumentInfo.Title );
    Console.WriteLine( "Subject: " + document.DocumentInfo.Subject );
    Console.WriteLine( "Author: " + document.DocumentInfo.Author );
    // ...

    // fonts
    foreach ( IRtfFont font in document.FontTable )
    {
      Console.WriteLine( "Font: " + font.Name );
    }

    // colors
    foreach ( IRtfColor color in document.ColorTable )
    {
      Console.WriteLine( "Color: " + color.AsDrawingColor.ToString() );
    }

    // user properties
    foreach ( IRtfDocumentProperty documentProperty in document.UserProperties )
    {
      Console.WriteLine( "User property: " + documentProperty.Name );
    }

    // visuals (preferably handled through an according visitor)
    foreach ( IRtfVisual visual in document.VisualContent )
    {
      switch ( visual.Kind )
      {
        case RtfVisualKind.Text:
          Console.WriteLine( "Text: " + ((IRtfVisualText)visual).Text );
          break;
        case RtfVisualKind.Break:
          Console.WriteLine( "Tag: " +
                  ((IRtfVisualBreak)visual).BreakKind.ToString() );
          break;
        case RtfVisualKind.Special:
          Console.WriteLine( "Text: " +
                 ((IRtfVisualSpecialChar)visual).CharKind.ToString() );
          break;
        case RtfVisualKind.Image:
          IRtfVisualImage image = (IRtfVisualImage)visual;
          Console.WriteLine( "Image: " + image.Format.ToString() +
           " " + image.Width.ToString() + "x" + image.Height.ToString() );
          break;
      }
    }
  } // RtfWriteDocument

As with the parser, the class RtfInterpreterTool offers convenience functionality for easy interpretation of RTF data and creation of a corresponding IRtfDocument. In case no IRtfGroup is yet available, it also provides for passing any source to the RtfParserTool for automatic on-the-fly parsing.

The interface IRtfInterpreterListener, with its base utility implementation RtfInterpreterListenerBase, offers the necessary foundation for a custom interpreter listener:

  // ------------------------------------------------------------------------
  public class MyInterpreterListener : RtfInterpreterListenerBase
  {
    // ----------------------------------------------------------------------
    protected override void DoBeginDocument( IRtfInterpreterContext context )
    {
      // custom action
    } // DoBeginDocument

    // ----------------------------------------------------------------------
    protected override void DoInsertText( IRtfInterpreterContext context, string text )
    {
      // custom action
    } // DoInsertText

    // ----------------------------------------------------------------------
    protected override void DoInsertSpecialChar( IRtfInterpreterContext context,
                                                 RtfVisualSpecialCharKind kind )
    {
      // custom action
    } // DoInsertSpecialChar

    // ----------------------------------------------------------------------
    protected override void DoInsertBreak( IRtfInterpreterContext context,
                                           RtfVisualBreakKind kind )
    {
      // custom action
    } // DoInsertBreak

    // ----------------------------------------------------------------------
    protected override void DoInsertImage( IRtfInterpreterContext context,
      RtfVisualImageFormat format,
      int width, int height, int desiredWidth, int desiredHeight,
      int scaleWidthPercent, int scaleHeightPercent,
      string imageDataHex
    )
    {
      // custom action
    } // DoInsertImage

    // ----------------------------------------------------------------------
    protected override void DoEndDocument( IRtfInterpreterContext context )
    {
      // custom action
    } // DoEndDocument

  } // MyInterpreterListener

The IRtfInterpreterContext passed to all of these methods contains the document information which is available at the very moment (colors, fonts, formats, etc.) as well as information about the state of the interpretation.

RTF Base Converters

As a foundation for the development of more complex converters, there are four base converters available for text, images, XML, and HTML. They are designed to be extended by inheritance.

Text Converter

The RtfTextConverter can be used to extract plain text from an RTF document. Its RtfTextConvertSettings determines how to represent special characters, tabulators, white space, breaks (line, page, etc.), and what to do with them.

  // ----------------------------------------------------------------------
  void ConvertRtf2Text( Stream rtfStream )
  {
    // logger
    RtfInterpreterListenerFileLogger logger =
      new RtfInterpreterListenerFileLogger( @"c:\temp\RtfInterpreter.log" );

    // text converter
    RtfTextConvertSettings textConvertSettings = new RtfTextConvertSettings();
    textConvertSettings.BulletText = "-"; // // replace default bullet text '°'
    RtfTextConverter textConverter = new RtfTextConverter( textConvertSettings );

    // interpreter
    RtfInterpreterTool.Interpret( rtfStream, logger, textConverter );
    Console.WriteLine( textConverter.PlainText );
  } // ConvertRtf2Text

Image Converter

The RtfImageConverter offers a way to extract images from an RTF document. The size of the images can remain unscaled or as they appear in the RTF document. Optionally, the format of the image can be converted to another ImageFormat. File name, type, and size can be controlled by an IRtfVisualImageAdapter. The RtfImageConvertSettings determines the storage location as well as any scaling.

  // ----------------------------------------------------------------------
  void ConvertRtf2Image( Stream rtfStream )
  {
    // logger
    RtfInterpreterListenerFileLogger logger =
       new RtfInterpreterListenerFileLogger( @"c:\temp\RtfInterpreter.log" );

    // image converter
    // convert all images to JPG
    RtfVisualImageAdapter imageAdapter = new RtfVisualImageAdapter( ImageFormat.Jpeg );
    RtfImageConvertSettings imageConvertSettings =
            new RtfImageConvertSettings( imageAdapter );
    imageConvertSettings.ImagesPath = @"c:\temp\images\";
    imageConvertSettings.ScaleImage = true; // scale images
    RtfImageConverter imageConverter = new RtfImageConverter( imageConvertSettings );

    // interpreter
    RtfInterpreterTool.Interpret( rtfStream, logger, imageConverter );
    // all images are saved to the path 'c:\temp\images\'
  } // ConvertRtf2Image

XML Converter

The RtfXmlConverter converts the recognized RTF visuals into an XML document. Its RtfXmlConvertSettings allows to specify the used XML namespace and the corresponding prefix.

  // ----------------------------------------------------------------------
  void ConvertRtf2Xml( Stream rtfStream )
  {
    // logger
    RtfInterpreterListenerFileLogger logger =
      new RtfInterpreterListenerFileLogger( @"c:\temp\RtfInterpreter.log" );

    // interpreter
    IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc( rtfStream, logger );

    // XML convert
    XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
    xmlWriterSettings.Indent = true;
    xmlWriterSettings.IndentChars = ( "  " );
    string fileName = @"c:\temp\Rtf.xml";
    using ( XmlWriter writer = XmlWriter.Create( fileName, xmlWriterSettings ) )
    {
      RtfXmlConverter xmlConverter = new RtfXmlConverter( rtfDocument, writer );
      xmlConverter.Convert();
      writer.Flush();
    }
  } // ConvertRtf2Xml

HTML Converter

The RtfHtmlConverter converts the recognized RTF visuals into an HTML document. File names, type, and size of any encountered images can be controlled through an IRtfVisualImageAdapter, while the RtfHtmlConvertSettings determines storage location, stylesheets, and other HTML document information.

  // ----------------------------------------------------------------------
  void ConvertRtf2Html( Stream rtfStream )
  {
    // logger
    RtfInterpreterListenerFileLogger logger =
      new RtfInterpreterListenerFileLogger( @"c:\temp\RtfInterpreter.log" );

    // image converter
    // convert all images to JPG
    RtfVisualImageAdapter imageAdapter =
       new RtfVisualImageAdapter( ImageFormat.Jpeg );
    RtfImageConvertSettings imageConvertSettings =
                   new RtfImageConvertSettings( imageAdapter );
    imageConvertSettings.ScaleImage = true; // scale images
    RtfImageConverter imageConverter =
            new RtfImageConverter( imageConvertSettings );

    // interpreter
    IRtfDocument rtfDocument = RtfInterpreterTool.Interpret( rtfStream,
                                              logger, imageConverter );

    // html converter
    RtfHtmlConvertSettings htmlConvertSettings =
           new RtfHtmlConvertSettings( imageAdapter );
    htmlConvertSettings.StyleSheetLinks.Add( "default.css" );
    RtfHtmlConverter htmlConverter = new RtfHtmlConverter( rtfDocument,
                                                 htmlConvertSettings );
    Console.WriteLine( htmlConverter.Convert() );
  } // ConvertRtf2Html

HTML Styles can be integrated in two ways:

• Inline through RtfHtmlCssStyle in RtfHtmlConvertSettings.Styles
• Link through RtfHtmlConvertSettings.StyleSheetLinks

The RtfHtmlConvertScope allows to restrict the target range:

• RtfHtmlConvertScope.All: complete HTML document (=Default)
• ...
• RtfHtmlConvertScope.Content: only paragraphs

RTF Converter Applications

The console applications Rtf2Raw, Rtf2Xml, and Rtf2Html demonstrate the range of functionality of the corresponding base converters, and offer a starting point for the development of our own RTF converter.

Rtf2Raw

The command line application Rtf2Raw converts an RTF document into plain text and images:

   Rtf2Raw source-file [destination] [/IT:format] [/CE:encoding]
                       [/IS+] [/ST-] [/SI-] [/LD:path] [/LP] [/LI] [/D] [/O] [/?]

      source-file       source rtf file
      destination       destination directory (default=source-file directory)
      /IT:format        images type format: bmp, emf, exif, gif, icon, jpg,
                               png, tiff or wmf (default=original)
      /CE:encoding      character encoding: ASCII, UTF7, UTF8, Unicode,
                               BigEndianUnicode, UTF32, OperatingSystem (default=UTF8)
      /IS+              image scale (default=off)
      /ST-              don't save text to the destination (default=on)
      /SI-              don't save images to the destination (default=on)
      /LD:path          log file directory (default=destination directory)
      /LP               write rtf parser log (default=off)
      /LI               write rtf interpreter log (default=off)
      /D                write text to screen (default=off)
      /O                open text in associated application (default=off)
      /?                this help

   Samples:
     Rtf2Raw MyText.rtf
     Rtf2Raw MyText.rtf c:\temp
     Rtf2Raw MyText.rtf c:\temp /CSS:MyCompany.css
     Rtf2Raw MyText.rtf c:\temp /CSS:MyCompany.css,ThisProject.css
     Rtf2Raw MyText.rtf c:\temp /CSS:MyCompany.css,ThisProject.css /IT:png
     Rtf2Raw MyText.rtf c:\temp /CSS:MyCompany.css,ThisProject.css /IT:png
                                /LD:log /LP /LI

Rtf2Xml

The command line application Rtf2Xml converts an RTF document into an XML document:

   Rtf2Xml source-file [destination] [/CE:encoding] [/P:prefix]
                       [/NS:namespace] [/LD:path] [/LP] [/LI] [/?]

      source-file       source rtf file
      destination       destination directory (default=source-file directory)
      /CE:encoding      character encoding: ASCII, UTF7, UTF8, Unicode,
                               BigEndianUnicode, UTF32, OperatingSystem (default=UTF8)
      /P:prefix         xml prefix (default=none)
      /NS:namespace     xml namespace (default=none)
      /LD:path          log file directory (default=destination directory)
      /LP               write rtf parser log (default=off)
      /LI               write rtf interpreter log (default=off)
      /?                this help

   Samples:
     Rtf2Xml MyText.rtf
     Rtf2Xml MyText.rtf c:\temp
     Rtf2Xml MyText.rtf c:\temp /NS:MyNs
     Rtf2Xml MyText.rtf c:\temp /LD:log /LP /LI

Rtf2Html

The command line application Rtf2Html converts an RTF document into an HTML document:

   Rtf2Html source-file [destination] [/CSS:names] [/ID:path] [/IT:format] [/CE:encoding]
                        [/CS:charset] [/SH-] [/SI-] [/LD:path] [/LP] [/LI] [/D] [/O] [/?]

      source-file       source rtf file
      destination       destination directory (default=source-file directory)
      /CSS:name1,name2  style sheet names (default=none)
      /ID:path          images directory (default=destination directory)
      /IT:format        images type format: jpg, gif or png (default=jpg)
      /CE:encoding      character encoding: ASCII, UTF7, UTF8, Unicode,
                               BigEndianUnicode, UTF32, OperatingSystem (default=UTF8)
      /CS:charset       document character set used for the HTML header meta-tag
                               'content' (default=UTF-8)
      /SH-              don't save HTML to the destination (default=on)
      /SI-              don't save images to the destination (default=on)
      /LD:path          log file directory (default=destination directory)
      /LP               write rtf parser log file (default=off)
      /LI               write rtf interpreter log file (default=off)
      /D                display HTML text on screen (default=off)
      /O                open HTML in associated application (default=off)
      /?                this help

   Samples:
     Rtf2Html MyText.rtf
     Rtf2Html MyText.rtf c:\temp
     Rtf2Html MyText.rtf c:\temp /CSS:MyCompany.css
     Rtf2Html MyText.rtf c:\temp /CSS:MyCompany.css,ThisProject.css
     Rtf2Html MyText.rtf c:\temp /CSS:MyCompany.css,ThisProject.css
                                 /ID:images /IT:png
     Rtf2Html MyText.rtf c:\temp /CSS:MyCompany.css,ThisProject.css
                                 /ID:images /IT:png /LD:log /LP /LI

Projects

The following projects are provided in the RTF converter component:

Sys	System functions. See below for a short description.
Parser	Parsing of RTF data.
ParserTests	Unit tests for Parser.
Interpreter	Interpretation of parsed RTF data. Functionality for conversion of RTF to plain text and images.
InterpreterTests	Unit tests for Interpreter.
ConverterXml	Functionality for conversion of RTF to XML.
ConverterHtml	Functionality for conversion of RTF to HTML.
Rtf2Raw	Command line application to convert from RTF to text- and image data.
Rtf2Xml	Command line application to convert from RTF to XML.
Rtf2Html	Command line application to convert from RTF to HTML.
RtfWinForms	Windows Forms sample application which demonstrates a simple conversion from RTF to Text/XML/HTML.
RtfWindows	WPF sample application which demonstrates a simple conversion from RTF to Text/XML/HTML.

System Functions

The project Sys contains some base functionality for use in all the other applications/projects:

HashTool	Functions to simplify implementing overrides of the object.GetHashCode() method.
StringTool	Functions for String formatting.
CollectionTool	Functions to simplify handling of Collections.
ApplicationArguments	Functions to interpret command line arguments. Offers support for the argument types ToggleArgument, ValueArgument, and NamedValueArgument.
Logging	Functionality to abstract the embedding of a Logger facility. Supports the logger types LoggerNone, LoggerTrace, and LoggerLog4net.
Test	Functionality to build a unit-based test application.

Acknowledgement

Special thanks to Leon Poyyayil for the design and his support and contribution in the development of this component.

History

• 22^nd October, 2008
  • RtfParser: Fixed to properly handle skipping of Unicode alternative representation in case these are written in hex-encoded form.
  • RtfHtmlConverter: New property DocumentImages which provides information about the converted images using IRtfConvertedImageInfo.
  • Added ChangeHistory.txt
• 15^th October, 2008
  • Added support for tags
  • \sub: Changes font size to 2/3 of the current font size and moves 'down' by half the current font size.
  • \super: Changes font size to 2/3 of the current font size and moves 'up' by half the current font size.
  • \nosupersub: Resets the 'up'/'down' baseline alignment to zero.
    ATTENTION: this leaves the font size unchanged as it is not known by the current implementation, what the 'previous' font size was.
    Hence, depending on the rtf-writer, this might lead to content that is displayed with a smaller font size than intended.
  • \v*: Toggles the new IsHidden property of the IRtfTextFormat.
    \v and \v1 turn it on while \v0 turns it off (according to the behavior or 'boolean tags').
  • \viewkind: Triggers the transition from interpreter state InHeader to InDocument (but only if the font table is already defined).
    This supports documents without color table and prevents formatting or content at the beginning from being ignored.
  • Extended/fixed support for tags
  • \dn and \up: will use the specified default value of '6' if none is given in the RTF (instead of resetting to zero).
  • RtfTextConverterSettings/RtfXmlConverterSettings/
RtfHtmlConverterSettings: have a new flag IsShowHiddenText which defaults to false.
  • RtfTextConverter/RtfXmlConverter/RtfHtmlConverter: will only append found text to the plain text buffer if it is not marked hidden in its text format or if the new setting IsShowHiddenText is explicitly set to true.
  • Rtf2Raw/Rtf2Xml/Rtf2Html: New commandline argument /HT to convert hidden text
  • RtfWinForms/RtfWindows: Conversion is considering the text selection
  • Added projects and solutions for Visual Studio 2005
  • Download now contains the binaries
• 13^th October, 2008
  • RtfImageConverter: New property ConvertedImages which provides information about the converted images using IRtfConvertedImageInfo
• 3^rd October, 2008
  • RtfHtmlConverter: Fixed encoding of image file names
• 26^th September, 2008
  • Added support for \pict tags wrapped in a \*\shppict group
  • RtfGroup: Extended debugging visualization
• 23^rd September, 2008
  • RtfParser: Fixed local group fonts
• 18^th September, 2008
  • RtfSpec: New tag constants for the theme fonts and stylesheet
  • RtfParser: Added support for dealing with theme fonts during decoding (ugly but necessary when such fonts are used for hex encoded content)
  • RtfFontBuilder: Added support for theme fonts
  • RtfFontBuilder: Added support for font names with an alternative representation
  • RtfFontTableBuilder: Added support for theme fonts
  • RtfInterpeter: Added special support for stylesheets by ignoring their contents (to prevent the style names from appearing in the document content)
  • Added the test document (in two variants) as unit test input
• 31^st July, 2008
  • New Windows Forms sample application which demonstrates a simple conversion from RTF to Text/XML/HTML
  • New WPF sample application which demonstrates a simple conversion from RTF to Text/XML/HTML
  • IRtfInterpreterContext: Replaced int DefaultFontIndex by string DefaultFontId to support WPF RichTextBox font indexing
• 14^th July, 2008
  • RtfHtmlConveter: New class IRtfHtmlStyleConverter which provides external style conversion
  • RtfHtmlConveter: Changed default image type from GIF to JPEG
  • RtfHtmlConveter: Fixed align of images
• 11^th July, 2008
  • Support for character set decoding per font
  • Support for decoding multi-byte hex-encoded characters (this handles East Asian fonts commonly encoded in this way instead of using Unicode)
  • Special treatment for the Windows legacy pseudo codepage 42 (mapped to the ANSI codepage)
  • All command line applications: new command line parameter /CE for specifying the output encoding (such as UTF-8 or UTF-16 a.k.a. Unicode)
  • Rtf2Html: Fixed HTML-encoded string
  • Command line application Rtf2Html: New command line parameter /CS for the HTML character set
  • RtfParserTest and RtfInterpreterTest: New unit-tests for multi-byte character set decoding
  • Minor bug fixes
• 3^rd July, 2008
  • Command line applications: Fixed exception in case when log parser is not used
• 1^st July, 2008
  • Initial public release

You must Sign In to use this message board.

FAQ  Noise Tolerance Very HighHighMediumLowVery Low  Search Messages    Layout Expand All MessagesThread ViewNo Javascript (slow)No Javascript Preview    Per page 102550

Msgs 1 to 25 of 152 (Total in Forum: 152) (Refresh) FirstPrevNext

Outstanding example of what CodeProject can be - great work! John C 8:42 15 Nov '08   Jani, you give far better support than the makers of a USD$500.00 commercial component we just bought to do the same thing. I wish I had found this article sooner, I'm having problems with the commercial component, I've found three serious bugs and the support is absolutely horrible, I'm fed up with them and am going to try your component instead. At least this way I'll have the source code and can take ownership of any problems that might come up down the road, with the commercial control I'm left feeling helpless and at their mercy. This is really an outstanding article here on CodeProject, the level of sophistication shown in the article presentation, in the code and your dedication to ensuring it's working properly are to be commended highly. Good work! "It's so simple to be wise. Just think of something stupid to say and then don't say it." -Sam Levenson Sign In·View Thread·PermaLink 5.00/5 (1 vote) Re: Outstanding example of what CodeProject can be - great work! Jani Giannoudis 1:59 16 Nov '08   Hi John, Thank you for your valuing feedback. I've also made the experience that the commercial available RTF convertion components doesn't meet certains requirements. During the implementation of the RTF Converter some peculiarities of this format were soon recognizable. I've profited many years by CP and I gladly share this component at the community. Cheers, Jani Sign In·View Thread·PermaLink Re: Outstanding example of what CodeProject can be - great work! John C 8:06 16 Nov '08   Hi Jani you are welcome. If I wasn't so busy right now on a new release I would have sat down and used your code as a template to write an HTML to RTF converter as well to complete the cycle. Unfortunately I can't use your code in my apps as I need to convert the other way as well so I'm stuck with the commercial component for now. (I'm writing a WIKI feature for our application and it has an asp.net as well as a winform interface so I'm using RTF at the winform side and HTML at the asp.net side and storing it in HTML format internally which is why I need to convert both ways. I don't want to use an html editor at the winform end because all the good solutions rely on a dependancy on IE which I want to avoid.) If I get the time down the road I'd love to write an html -> rtf converter article and then another article with a complete solution for editing html / rtf at both the winform end and the asp.net end. Great work though, not only a good article but a great learning tool for anyone wanting to see a solid professional way to implement code of this kind! "It's so simple to be wise. Just think of something stupid to say and then don't say it." -Sam Levenson Sign In·View Thread·PermaLink Rtf2Html: Ignores Font changes of RichTextBox Member 5530427 0:11 6 Nov '08   I using following sample to convert Rtf2HTML: RichTextBox richTextBox = new RichTextBox(); richTextBox.Text = "Test"; richTextBox.SelectAll(); richTextBox.SelectionFont = new Font(richTextBox.SelectionFont, richTextBox.SelectionFont.Style ^ FontStyle.Bold); IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(richTextBox.Rtf); RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument); String html = htmlConverter.Convert(); Is seems that the converted html does not contain my changes of the font. Is that a bug of RtfConverter or do I use the converter in a wrong way? cu slivercp Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Jani Giannoudis 6:03 6 Nov '08   Hi slivercp With your sample code I receive the following HTML output: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//DE" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8" /> <meta name="generator" content="Rtf2Html Converter" /> </head> <body> <p><b><span style="background-color:#FFFFFF;font-family:Microsoft Sans Serif;font-size:8pt;">Test</span></b></p> </body> </html> As you can see, the output contains the <b> HTML tag. Did you receive a different HTML output? cheers, Jani Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Member 5530427 2:22 7 Nov '08   Strange, my output looks like the following: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//DE" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8" /> <meta name="generator" content="Rtf2Html Converter" /> </head> <body> <p><span style="background-color:#FFFFFF;font-family:Microsoft Sans Serif;font-size:12pt;">Test</span></p> </body> </html> Could it be, that my Visual Studio 2005 is causing the problem? (as your are using VS2008) Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Jani Giannoudis 2:26 7 Nov '08   Hi slivercp - Are you using the actual version? - Which is your CLR version? - Which version has the RichTextBox? Jani Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Member 5530427 2:31 7 Nov '08   - Are you using the actual version? Yep. - Which is your CLR version? .NET 2.0 (VS2005) - Which version has the RichTextBox? That one shipped with VS2005. How can I figure out the exact version number of this control? Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Member 5530427 2:34 7 Nov '08   Here the Rtf output of the RichTextBox: {\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Microsoft Sans Serif;}} \viewkind4\uc1\pard\b\f0\fs17 Test\b0\par } Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Jani Giannoudis 3:01 7 Nov '08   Hi silverscp > That one shipped with VS2005. How can I figure out the exact version number of this control? Its part of the System.Windows.Forms.dll. >> Which is your CLR version? > .NET 2.0 (VS2005) I have tested your document using .NET 2.0 and VS2005 - output is correct The output of your RichTextBox is ok, it contains the bold tag 'pard\b'. You can save the output to a file and start the Rtf2Html tool using the parameters /LP /LI. Contains any log file the bold marker? Cheers, Jani Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox slivercp 4:40 10 Nov '08   Same problem with Rtf2Html tool. rtf.parse.log: ParseBegin GroupBegin Tag: \rtf1 Tag: \ansi Tag: \ansicpg1252 Tag: \deff0 Tag: \deflang1033 GroupBegin Tag: \fonttbl GroupBegin Tag: \f0 Tag: \fnil Tag: \fcharset0 Text: Microsoft Sans Serif; GroupEnd GroupEnd Tag: \viewkind4 Tag: \pard Tag: \b Tag: \f0 Tag: \fs17 Text: Test Tag: \b0 Tag: \par GroupEnd ParseSuccess ParseEnd rtf.interpreter.log BeginDocument InsertText: 'Test' with format [Font Microsoft Sans Serif, 24+0, plain, Left, Color{0,0,0} on Color{255,255,255}] InsertBreak: Paragraph EndDocument Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Jani Giannoudis 11:43 10 Nov '08   Hi slivercp Please try this: RichTextBox richTextBox = new RichTextBox(); richTextBox.Text = "Test"; richTextBox.SelectAll(); Font font = richTextBox.SelectionFont; richTextBox.SelectionFont = new Font( font.FontFamily, font.Size, FontStyle.Bold ); IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(richTextBox.Rtf); RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument); String html = htmlConverter.Convert(); cheers, Jani Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox slivercp 21:59 10 Nov '08   Same problem. Html Output <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//DE" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8" /> <meta name="generator" content="Rtf2Html Converter" /> </head> <body> <p><span style="background-color:#FFFFFF;font-family:Microsoft Sans Serif;font-size:12pt;">Test</span></p> </body> </html> Rtf string: {\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Microsoft Sans Serif;}} \viewkind4\uc1\pard\b\f0\fs17 Test\b0\par } Sign In·View Thread·PermaLink Re: Rtf2Html: Ignores Font changes of RichTextBox Jani Giannoudis 0:39 11 Nov '08   Hi slivercp, Let's do some remote debugging . Please set a breakpoint at RtfInterpreter.cs line #171. - does it break at this location? - what is the value of tag-Name, tag.HasValue and tag.ValueAsNumber - what is the value Context.WritableCurrentTextFormat.bold - what is the value Context.WritableCurrentTextFormat.bold after the statement Context.WritableCurrentTextFormat = Context.WritableCurrentTextFormat.DeriveWithBold( bold ); Cheers, Jani Sign In·View Thread·PermaLink