} // ToTextButtonClick
// ----------------------------------------------------------------------
private void ToXmlButtonClick(object sender, RoutedEventArgs e)
{
try
{
TextRange conversionText = ConversionText;
using (MemoryStream stream = new MemoryStream())
{
conversionText.Save(stream, DataFormats.Rtf);
stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(stream))
{
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(reader);
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Indent = true;
xmlWriterSettings.IndentChars = (" ");
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb, xmlWriterSettings))
{
RtfXmlConverter xmlConverter = new RtfXmlConverter(rtfDocument, writer);
xmlConverter.Convert();
writer.Flush();
textBox.Text = sb.ToString();
}
}
}
}
catch (Exception exception)
{
MessageBox.Show(this, "Error " + exception.Message, Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
} // ToXmlButtonClick
} // InterpretRtf
// ----------------------------------------------------------------------
private void ConvertXml(IRtfDocument rtfDocument)
{
try
{
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Indent = true;
xmlWriterSettings.IndentChars = (" ");
xmlWriterSettings.Encoding = settings.Encoding;
string fileName = settings.BuildDestinationFileName(null, RtfXmlConverter.DefaultXmlFileExtension);
using (XmlWriter writer = XmlWriter.Create(fileName, xmlWriterSettings))
{
RtfXmlConvertSettings xmlConvertSettings = new RtfXmlConvertSettings();
xmlConvertSettings.Prefix = settings.XmlPrefix;
xmlConvertSettings.Ns = settings.XmlNamespace;
xmlConvertSettings.IsShowHiddenText = settings.ShowHiddenText;
RtfXmlConverter xmlConverter = new RtfXmlConverter(rtfDocument, writer, xmlConvertSettings);
xmlConverter.Convert();
writer.Flush();
}
}
catch (Exception e)
{
Console.WriteLine("error while converting to xml: " + e.Message);
ExitCode = ProgramExitCode.ConvertXml;
}
} // ConvertXml
public void ImageTest()
{
const RtfParserListenerLogger parserLogger = null;
//parserLogger = new RtfParserListenerLogger();
IRtfGroup rtfStructure =
RtfParserTool.Parse(GetTestResource("RtfInterpreterTest_4.rtf"), parserLogger);
Assert.IsNotNull(rtfStructure);
const RtfInterpreterListenerLogger interpreterLogger = null;
//interpreterLogger = new RtfInterpreterListenerLogger();
IRtfDocument rtfDoc = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterLogger);
Assert.IsNotNull(rtfDoc);
IRtfVisualCollection rtfVisuals = rtfDoc.VisualContent;
Assert.AreEqual(RtfVisualKind.Image, rtfVisuals[4].Kind);
IRtfVisualImage img = (IRtfVisualImage)rtfVisuals[4];
Assert.AreEqual(RtfVisualImageFormat.Jpg, img.Format);
Assert.AreEqual(100, img.Width);
Assert.AreEqual(142, img.Height);
Assert.AreEqual(720, img.DesiredWidth);
Assert.AreEqual(1020, img.DesiredHeight);
} // ImageTest
} // RtfDumpElement
// ----------------------------------------------------------------------
static void RtfSympleInterpreter()
{
RtfInterpreterListenerFileLogger logger = new RtfInterpreterListenerFileLogger(@"c:\temp\RtfInterpreter.log");
IRtfDocument document = RtfInterpreterTool.BuildDoc(@"{\rtf1foobar}", logger);
RtfWriteDocument(document);
} // RtfSympleInterpreter
public void ImageFormatDecodingTest()
{
const RtfParserListenerLogger parserLogger = null;
//parserLogger = new RtfParserListenerLogger();
const RtfInterpreterListenerLogger interpreterLogger = null;
//interpreterLogger = new RtfInterpreterListenerLogger();
// ReSharper disable RedundantExplicitArrayCreation
int[] imageResources = new int[] { 4, 5, 6, 7, 8, 19 };
// ReSharper restore RedundantExplicitArrayCreation
for (int i = 0; i < imageResources.Length; i++)
{
string testCaseName = BuildTestResourceName("", imageResources[i], false, "rtf");
IRtfGroup rtfStructure =
RtfParserTool.Parse(GetTestResource(testCaseName), parserLogger);
IRtfDocument rtfDoc = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterLogger);
Assert.IsNotNull(rtfDoc);
bool imageFound = false;
foreach (IRtfVisual visual in rtfDoc.VisualContent)
{
if (visual.Kind == RtfVisualKind.Image)
{
IRtfVisualImage img = (IRtfVisualImage)visual;
Assert.IsNotNull(img.ImageForDrawing);
imageFound = true;
//Console.WriteLine( "image: " + img.ImageForDrawing );
}
}
Assert.IsTrue(imageFound, "no image found in test case " + testCaseName);
}
} // ImageFormatDecodingTest
private static string GetHtmlFromRTF(string rtfSelection)
{
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(rtfSelection);
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument);
return(htmlConverter.Convert());
}
public void TextAlignmentTest()
{
const RtfParserListenerLogger parserLogger = null;
//parserLogger = new RtfParserListenerLogger();
IRtfGroup rtfStructure =
RtfParserTool.Parse(GetTestResource("RtfInterpreterTest_3.rtf"), parserLogger);
Assert.IsNotNull(rtfStructure);
const RtfInterpreterListenerLogger interpreterLogger = null;
//interpreterLogger = new RtfInterpreterListenerLogger();
IRtfDocument rtfDoc = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterLogger);
Assert.IsNotNull(rtfDoc);
IRtfVisualCollection rtfVisuals = rtfDoc.VisualContent;
Assert.AreEqual(8, rtfVisuals.Count);
Assert.AreEqual(RtfVisualKind.Text, rtfVisuals[0].Kind);
Assert.AreEqual("left aligned", ((IRtfVisualText)rtfVisuals[0]).Text);
Assert.AreEqual(RtfTextAlignment.Left, ((IRtfVisualText)rtfVisuals[0]).Format.Alignment);
Assert.AreEqual(RtfVisualKind.Text, rtfVisuals[2].Kind);
Assert.AreEqual("centered", ((IRtfVisualText)rtfVisuals[2]).Text);
Assert.AreEqual(RtfTextAlignment.Center, ((IRtfVisualText)rtfVisuals[2]).Format.Alignment);
Assert.AreEqual(RtfVisualKind.Text, rtfVisuals[4].Kind);
Assert.AreEqual("right aligned", ((IRtfVisualText)rtfVisuals[4]).Text);
Assert.AreEqual(RtfTextAlignment.Right, ((IRtfVisualText)rtfVisuals[4]).Format.Alignment);
Assert.AreEqual(RtfVisualKind.Text, rtfVisuals[6].Kind);
Assert.AreEqual("block aligned", ((IRtfVisualText)rtfVisuals[6]).Text);
Assert.AreEqual(RtfTextAlignment.Justify, ((IRtfVisualText)rtfVisuals[6]).Format.Alignment);
} // TextAlignmentTest
public static string RtfToHtml(this string str, RtfHtmlConvertSettings htmlConvertSettings, bool throwOnError = false, IRtfParserListener listener = null, string destinationDirectory = null, RtfVisualImageAdapter imageAdapter = null, string imageAdapterLogFile = null, RtfImageConvertSettings imageConvertSettings = null)
{
IRtfGroup rtfStructure;
IRtfDocument rtfDocument = null;
try
{
using (var stream = str.ToStream())
{
// parse the rtf structure
var structureBuilder = new RtfParserListenerStructureBuilder();
var parser = new RtfParser(structureBuilder);
DirectoryInfo destination;
if (destinationDirectory != null)
{
destination = new DirectoryInfo(destinationDirectory);
}
parser.IgnoreContentAfterRootGroup = true; // support WordPad documents
if (listener != null)
{
parser.AddParserListener(listener);
}
parser.Parse(new RtfSource(stream));
rtfStructure = structureBuilder.StructureRoot;
ThrowOnUnexpectedExitCode();
rtfDocument = InterpretRtf(rtfStructure, imageAdapter, imageAdapterLogFile, imageConvertSettings, throwOnError);
if (throwOnError)
{
ThrowOnUnexpectedExitCode();
}
// convert to hmtl
string html = ConvertHmtl(rtfDocument, imageAdapter, htmlConvertSettings, throwOnError);
if (throwOnError)
{
ThrowOnUnexpectedExitCode();
}
return(html);
}
}
catch (Exception e)
{
Debug.WriteLine("RtfToHtml parser failed with error: {0}", e.Message);
}
return(null);
}
private static string ConvertRtfToHtml(string rtfText)
{
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(rtfText);
RtfHtmlConvertSettings settings = new RtfHtmlConvertSettings();
settings.ConvertScope = RtfHtmlConvertScope.Content;
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument, settings);
return(htmlConverter.Convert());
} // ConvertRtfToHtml
private IRtfDocument InterpretRtf(IRtfGroup rtfStructure, RtfVisualImageAdapter imageAdapter)
{
IRtfDocument rtfDocument = null;
RtfImageConverter imageConverter = null;
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings(imageAdapter);
imageConvertSettings.ImagesPath = ImagePath;
imageConvertSettings.BackgroundColor = null;
imageConverter = new RtfImageConverter(imageConvertSettings);
rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, null, imageConverter);
return(rtfDocument);
}
} // RtfSympleInterpreter
// ----------------------------------------------------------------------
static 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
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("Text: " + image.Format.ToString() +
" " + image.Width.ToString() + "x" + image.Height.ToString());
break;
}
}
} // RtfWriteElement
private string ConvertHmtl(IRtfDocument rtfDocument, RtfVisualImageAdapter imageAdapter)
{
RtfHtmlConvertSettings htmlConvertSettings = new RtfHtmlConvertSettings(imageAdapter);
htmlConvertSettings.Title = "Doc Title " + DateTime.Now.ToString("dd/MM/yyyy");
htmlConvertSettings.ImagesPath = ImagePath;
htmlConvertSettings.IsShowHiddenText = IsShowHiddenText;
htmlConvertSettings.ConvertVisualHyperlinks = ConvertVisualHyperlinks;
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument, htmlConvertSettings);
return(htmlConverter.Convert());
}
} // ToXmlButtonClick
// ----------------------------------------------------------------------
private void ToHtmlButtonClick(object sender, EventArgs e)
{
try
{
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(ConversionText);
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument);
textBox.Text = htmlConverter.Convert();
}
catch (Exception exception)
{
MessageBox.Show(this, "Error " + exception.Message, Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
} // ToHtmlButtonClick
/// <summary>
/// Do the actual conversion by using a RichTextBox
/// </summary>
private void Convert()
{
if (string.IsNullOrEmpty(_rtf))
{
_convertedRtf = string.Empty;
return;
}
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(_rtf);
RtfHtmlConverter converter = new RtfHtmlConverter(rtfDocument);
_convertedRtf = converter.Convert();
}
} // RtfHtmlConverter
// ----------------------------------------------------------------------
public RtfHtmlConverter(IRtfDocument rtfDocument, RtfHtmlConvertSettings settings)
{
if (rtfDocument == null)
{
throw new ArgumentNullException("rtfDocument");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.rtfDocument = rtfDocument;
this.settings = settings;
} // RtfHtmlConverter
private string GetBibDescr(string s)
{
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(s);
string ret = "";
foreach (IRtfVisual vt in rtfDocument.VisualContent)
{
if (vt.Kind == RtfVisualKind.Text)
{
ret += ((IRtfVisualText)vt).Text;
}
}
return(ret);
}
public string GetHTML(string rtfString)
{
ReportProgress(33);
IRtfGroup rtfStructure = ParseRtf(rtfString);
RtfVisualImageAdapter imageAdapter = new RtfVisualImageAdapter(
ImageFileNamePattern,
ImageFormat.Jpeg);
ReportProgress(33);
IRtfDocument rtfDocument = InterpretRtf(rtfStructure, imageAdapter);
ReportProgress(33);
return(ConvertHmtl(rtfDocument, imageAdapter));
}
// ----------------------------------------------------------------------
static 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
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( "Text: " + image.Format.ToString() +
" " + image.Width.ToString() + "x" + image.Height.ToString() );
break;
}
}
}
} // RtfHtmlConverter
// ----------------------------------------------------------------------
public RtfHtmlConverter(IRtfDocument rtfDocument, RtfHtmlConvertSettings settings)
{
if (rtfDocument == null)
{
throw new ArgumentNullException("rtfDocument");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.rtfDocument = rtfDocument;
this.settings = settings;
specialCharacters = new RtfHtmlSpecialCharCollection(settings.SpecialCharsRepresentation);
} // RtfHtmlConverter
} // RtfHtmlConverter
public RtfHtmlConverter(IRtfDocument rtfDocument, RtfHtmlConvertSettings settings)
{
if (rtfDocument == null)
{
throw new ArgumentNullException(nameof(rtfDocument));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
RtfDocument = rtfDocument;
Settings = settings;
SpecialCharacters = new RtfHtmlSpecialCharCollection(settings.SpecialCharsRepresentation);
} // RtfHtmlConverter
// ----------------------------------------------------------------------
public RtfHtmlConverter( IRtfDocument rtfDocument, RtfHtmlConvertSettings settings )
{
if ( rtfDocument == null )
{
throw new ArgumentNullException( "rtfDocument" );
}
if ( settings == null )
{
throw new ArgumentNullException( "settings" );
}
this.rtfDocument = rtfDocument;
this.settings = settings;
specialCharacters = new RtfHtmlSpecialCharCollection( settings.SpecialCharsRepresentation );
}
} // InterpretRtf
// ----------------------------------------------------------------------
private string ConvertHmtl(IRtfDocument rtfDocument, IRtfVisualImageAdapter imageAdapter)
{
string html;
try
{
RtfHtmlConvertSettings htmlConvertSettings = new RtfHtmlConvertSettings(imageAdapter);
if (settings.CharacterSet != null)
{
htmlConvertSettings.CharacterSet = settings.CharacterSet;
}
htmlConvertSettings.Title = settings.SourceFileNameWithoutExtension;
htmlConvertSettings.ImagesPath = settings.ImagesPath;
htmlConvertSettings.IsShowHiddenText = settings.ShowHiddenText;
htmlConvertSettings.UseNonBreakingSpaces = settings.UseNonBreakingSpaces;
if (settings.ConvertScope != RtfHtmlConvertScope.None)
{
htmlConvertSettings.ConvertScope = settings.ConvertScope;
}
if (!string.IsNullOrEmpty(settings.StyleSheets))
{
string[] styleSheets = settings.StyleSheets.Split(',');
htmlConvertSettings.StyleSheetLinks.AddRange(styleSheets);
}
htmlConvertSettings.ConvertVisualHyperlinks = settings.ConvertVisualHyperlinks;
if (!string.IsNullOrEmpty(settings.VisualHyperlinkPattern))
{
htmlConvertSettings.VisualHyperlinkPattern = settings.VisualHyperlinkPattern;
}
htmlConvertSettings.SpecialCharsRepresentation = settings.SpecialCharsRepresentation;
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument, htmlConvertSettings);
if (!settings.UseInlineStyles)
{
htmlConverter.StyleConverter = new RtfEmptyHtmlStyleConverter();
}
html = htmlConverter.Convert();
}
catch (Exception e)
{
Console.WriteLine("error while converting to html: " + e.Message);
ExitCode = ProgramExitCode.ConvertHtml;
return(null);
}
return(html);
} // ConvertHmtl
} // RtfXmlConverter
// ----------------------------------------------------------------------
public RtfXmlConverter(IRtfDocument rtfDocument, XmlWriter writer, RtfXmlConvertSettings settings)
{
if (rtfDocument == null)
{
throw new ArgumentNullException("rtfDocument");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.rtfDocument = rtfDocument;
this.writer = writer;
this.settings = settings;
} // RtfXmlConverter
private static string ConvertHmtl(IRtfDocument rtfDocument, IRtfVisualImageAdapter imageAdapter, RtfHtmlConvertSettings htmlConvertSettings, bool throwOnError = false)
{
string html = null;
try
{
var htmlConverter = new RtfHtmlConverter(rtfDocument, htmlConvertSettings);
html = htmlConverter.Convert();
}
catch (Exception e)
{
if (throwOnError)
{
ThrowOnUnexpectedExitCode(e);
}
}
return(html);
}
// ----------------------------------------------------------------------
public RtfXmlConverter( IRtfDocument rtfDocument, XmlWriter writer, RtfXmlConvertSettings settings )
{
if ( rtfDocument == null )
{
throw new ArgumentNullException( "rtfDocument" );
}
if ( writer == null )
{
throw new ArgumentNullException( "writer" );
}
if ( settings == null )
{
throw new ArgumentNullException( "settings" );
}
this.rtfDocument = rtfDocument;
this.writer = writer;
this.settings = settings;
}
} // ExitCode
// ----------------------------------------------------------------------
public void Execute()
{
Console.WriteLine(string.Concat(
ApplicationInfo.ShortCaption,
", ",
ApplicationInfo.Copyright));
// program settings
if (ValidateProgramSettings() == false)
{
return;
}
// parse rtf
IRtfGroup rtfStructure = ParseRtf();
if (ExitCode != ProgramExitCode.Successfully)
{
return;
}
// destination directory
EnsureDestinationDirectory();
if (ExitCode != ProgramExitCode.Successfully)
{
return;
}
// interpret rtf
IRtfDocument rtfDocument = InterpretRtf(rtfStructure);
if (ExitCode != ProgramExitCode.Successfully)
{
return;
}
// convert to xml
ConvertXml(rtfDocument);
Console.WriteLine("successfully converted RTF to XML in " + settings.DestinationDirectory);
} // Execute
public string CovnvertRtftoHtml(string rtf)
{
const RtfParserListenerLogger parserLogger = null;
IRtfGroup rtfStructure = RtfParserTool.Parse(rtf, parserLogger);
Assert.IsNotNull(rtfStructure);
const RtfInterpreterListenerLogger interpreterLogger = null;
RtfTextConverter textConverter = new RtfTextConverter();
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, textConverter, interpreterLogger);
RtfHtmlConvertSettings htmlConvertSettings = new RtfHtmlConvertSettings();
htmlConvertSettings.ConvertScope = RtfHtmlConvertScope.Content;
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument);
string plainText = htmlConverter.Convert();
plainText = plainText.Replace("@?]e1", "á").Replace("@?]e9", "é").Replace("@?]f3", "ó").Replace("@?]ed", "í").Replace("@?]c1", "á").Replace("@?]f1", "ñ").Replace("@?]fa", "ú"); //aqui reemplazamos para letras con acentos.
return(plainText);
}
} // ToXmlButtonClick
// ----------------------------------------------------------------------
private void ToHtmlButtonClick(object sender, RoutedEventArgs e)
{
try
{
TextRange conversionText = ConversionText;
using (MemoryStream stream = new MemoryStream())
{
conversionText.Save(stream, DataFormats.Rtf);
stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(stream))
{
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(reader);
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument);
textBox.Text = htmlConverter.Convert();
}
}
}
catch (Exception exception)
{
MessageBox.Show(this, "Error " + exception.Message, Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
} // ToHtmlButtonClick
public void TextAlignmentTestFixed()
{
const RtfParserListenerLogger parserLogger = null;
//parserLogger = new RtfParserListenerLogger();
IRtfGroup rtfStructure =
RtfParserTool.Parse(GetTestResource("RtfInterpreterTest_23.rtf"), parserLogger);
Assert.IsNotNull(rtfStructure);
const RtfInterpreterListenerLogger interpreterLogger = null;
//interpreterLogger = new RtfInterpreterListenerLogger();
IRtfDocument rtfDoc = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterLogger);
Assert.IsNotNull(rtfDoc);
IRtfVisualCollection rtfVisuals = rtfDoc.VisualContent;
Assert.AreEqual(2, rtfVisuals.Count);
Assert.AreEqual(RtfVisualKind.Text, rtfVisuals[0].Kind);
Assert.AreEqual("Simple text", ((IRtfVisualText)rtfVisuals[0]).Text);
Assert.AreEqual(RtfTextAlignment.Right, ((IRtfVisualText)rtfVisuals[0]).Format.Alignment);
} // TextAlignmentTestFixed
} // ToTextButtonClick
// ----------------------------------------------------------------------
private void ToXmlButtonClick(object sender, EventArgs e)
{
try
{
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(ConversionText);
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Indent = true;
xmlWriterSettings.IndentChars = (" ");
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb, xmlWriterSettings))
{
RtfXmlConverter xmlConverter = new RtfXmlConverter(rtfDocument, writer);
xmlConverter.Convert();
writer.Flush();
textBox.Text = sb.ToString();
}
}
catch (Exception exception)
{
MessageBox.Show(this, "Error " + exception.Message, Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
} // ToXmlButtonClick
} // ConvertRtf2Txt
// ----------------------------------------------------------------------
public string ConvertRtf2Html(string fileName)
{
// parser
IRtfGroup rtfStructure = ParseRtf(fileName);
if (rtfStructure == null)
{
return(string.Empty);
}
// interpreter logger
RtfInterpreterListenerFileLogger interpreterLogger = null;
if (!string.IsNullOrEmpty(InterpreterLogFileName))
{
interpreterLogger = new RtfInterpreterListenerFileLogger(InterpreterLogFileName);
}
// image converter
RtfVisualImageAdapter imageAdapter = new RtfVisualImageAdapter(ImageFormat.Jpeg);
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings(imageAdapter);
imageConvertSettings.ScaleImage = true; // scale images
RtfImageConverter imageConverter = new RtfImageConverter(imageConvertSettings);
// rtf interpreter
RtfInterpreterSettings interpreterSettings = new RtfInterpreterSettings();
IRtfDocument rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterSettings, interpreterLogger, imageConverter);
// html converter
RtfHtmlConvertSettings htmlConvertSettings = new RtfHtmlConvertSettings();
htmlConvertSettings.ConvertScope = RtfHtmlConvertScope.Content;
RtfHtmlConverter htmlConverter = new RtfHtmlConverter(rtfDocument);
return(htmlConverter.Convert());
} // ConvertRtf2Html
// ----------------------------------------------------------------------
public RtfHtmlConverter( IRtfDocument rtfDocument )
: this(rtfDocument, new RtfHtmlConvertSettings())
{
}
// ----------------------------------------------------------------------
private string ConvertHmtl( IRtfDocument rtfDocument, IRtfVisualImageAdapter imageAdapter )
{
string html;
try
{
RtfHtmlConvertSettings htmlConvertSettings = new RtfHtmlConvertSettings( imageAdapter );
if ( settings.CharacterSet != null )
{
htmlConvertSettings.CharacterSet = settings.CharacterSet;
}
htmlConvertSettings.Title = settings.SourceFileNameWithoutExtension;
htmlConvertSettings.ImagesPath = settings.ImagesPath;
htmlConvertSettings.IsShowHiddenText = settings.ShowHiddenText;
htmlConvertSettings.UseNonBreakingSpaces = settings.UseNonBreakingSpaces;
if ( settings.ConvertScope != RtfHtmlConvertScope.None )
{
htmlConvertSettings.ConvertScope = settings.ConvertScope;
}
if ( !string.IsNullOrEmpty( settings.StyleSheets ) )
{
string[] styleSheets = settings.StyleSheets.Split( ',' );
htmlConvertSettings.StyleSheetLinks.AddRange( styleSheets );
}
htmlConvertSettings.ConvertVisualHyperlinks = settings.ConvertVisualHyperlinks;
if ( !string.IsNullOrEmpty( settings.VisualHyperlinkPattern ) )
{
htmlConvertSettings.VisualHyperlinkPattern = settings.VisualHyperlinkPattern;
}
htmlConvertSettings.SpecialCharsRepresentation = settings.SpecialCharsRepresentation;
RtfHtmlConverter htmlConverter = new RtfHtmlConverter( rtfDocument, htmlConvertSettings );
html = htmlConverter.Convert();
}
catch ( Exception e )
{
Console.WriteLine( "error while converting to html: " + e.Message );
ExitCode = ProgramExitCode.ConvertHtml;
return null;
}
return html;
}
// ----------------------------------------------------------------------
public RtfXmlConverter( IRtfDocument rtfDocument, XmlWriter writer )
: this(rtfDocument, writer, new RtfXmlConvertSettings())
{
}
public void DocumentBuilderTest()
{
const RtfParserListenerLogger parserLogger = null;
//parserLogger = new RtfParserListenerLogger();
IRtfGroup rtfStructure =
RtfParserTool.Parse(GetTestResource("RtfInterpreterTest_1.rtf"), parserLogger);
Assert.IsNotNull(rtfStructure);
const RtfInterpreterListenerLogger interpreterLogger = null;
//interpreterLogger = new RtfInterpreterListenerLogger();
RtfInterpreterListenerDocumentBuilder docBuilder =
new RtfInterpreterListenerDocumentBuilder();
RtfInterpreterTool.Interpret(rtfStructure, docBuilder, interpreterLogger);
IRtfDocument doc = docBuilder.Document;
Assert.IsNotNull(doc);
Assert.AreEqual("TX_RTF32 14.0.520.501", doc.Generator);
Assert.AreEqual(3, doc.FontTable.Count);
Assert.AreEqual(RtfFontKind.Swiss, doc.FontTable[0].Kind);
Assert.AreEqual(RtfFontPitch.Variable, doc.FontTable[0].Pitch);
Assert.AreEqual(0, doc.FontTable[0].CharSet);
Assert.AreEqual(1252, doc.FontTable[0].CodePage);
Assert.AreEqual("Arial", doc.FontTable[0].Name);
Assert.AreEqual(RtfFontKind.Swiss, doc.FontTable[1].Kind);
Assert.AreEqual(RtfFontPitch.Variable, doc.FontTable[1].Pitch);
Assert.AreEqual(0, doc.FontTable[01].CharSet);
Assert.AreEqual(1252, doc.FontTable[1].CodePage);
Assert.AreEqual("Verdana", doc.FontTable[1].Name);
Assert.AreEqual(RtfFontKind.Roman, doc.FontTable[2].Kind);
Assert.AreEqual(RtfFontPitch.Variable, doc.FontTable[2].Pitch);
Assert.AreEqual(2, doc.FontTable[2].CharSet);
Assert.AreEqual(42, doc.FontTable[2].CodePage);
Assert.AreEqual("Symbol", doc.FontTable[2].Name);
Assert.AreSame(doc.DefaultFont, doc.FontTable[1]);
Assert.AreEqual(4, doc.ColorTable.Count);
Assert.AreEqual(RtfColor.Black, doc.ColorTable[0]);
Assert.AreEqual(RtfColor.Black, doc.ColorTable[1]);
Assert.AreEqual(RtfColor.White, doc.ColorTable[2]);
Assert.AreEqual(new RtfColor(10, 20, 30), doc.ColorTable[3]);
Assert.AreEqual(2, doc.VisualContent.Count);
Assert.AreEqual(RtfVisualKind.Text, doc.VisualContent[0].Kind);
Assert.AreEqual("Hellou RTF Wörld", ((IRtfVisualText)doc.VisualContent[0]).Text);
Assert.AreEqual("Verdana", ((IRtfVisualText)doc.VisualContent[0]).Format.Font.Name);
Assert.AreEqual(36, ((IRtfVisualText)doc.VisualContent[0]).Format.FontSize);
Assert.AreEqual(RtfVisualKind.Break, doc.VisualContent[1].Kind);
Assert.AreEqual(RtfVisualBreakKind.Paragraph, ((IRtfVisualBreak)doc.VisualContent[1]).BreakKind);
Assert.AreEqual(5, doc.UserProperties.Count);
Assert.AreEqual("created", doc.UserProperties[0].Name);
Assert.AreEqual(RtfPropertyKind.Date, doc.UserProperties[0].PropertyKind);
Assert.AreEqual("2008-05-23", doc.UserProperties[0].StaticValue);
Assert.IsNull(doc.UserProperties[0].LinkValue);
Assert.AreEqual("a link", doc.UserProperties[4].LinkValue);
IRtfDocumentInfo info = doc.DocumentInfo;
Assert.AreEqual(2, info.Version);
Assert.AreEqual(3, info.Revision);
Assert.AreEqual(1, info.NumberOfPages);
Assert.AreEqual(3, info.NumberOfWords);
Assert.AreEqual(16, info.NumberOfCharacters);
Assert.AreEqual(314, info.Id);
Assert.AreEqual(17, info.EditingTimeInMinutes);
Assert.AreEqual("Not really important", info.Title);
Assert.AreEqual("RTF parsing", info.Subject);
Assert.AreEqual("John Doe", info.Author);
Assert.AreEqual("John Doe's boss", info.Manager);
Assert.AreEqual("Itenso GmbH", info.Company);
Assert.AreEqual("Foo Bar", info.Operator);
Assert.AreEqual("Development", info.Category);
Assert.AreEqual("RTF, Parser, Interpreter", info.Keywords);
Assert.AreEqual("a testing document", info.Comment);
Assert.AreEqual("with more commentary", info.DocumentComment);
Assert.AreEqual("http://wwww.nowhere.com/foo/bar", info.HyperLinkbase);
Assert.AreEqual(Time("2008.05.23-17:55:12"), info.CreationTime);
Assert.AreEqual(Time("2008.05.23-18:01:00"), info.RevisionTime);
Assert.AreEqual(Time("2008.05.23-17:59:00"), info.PrintTime);
Assert.AreEqual(Time("2008.05.23-18:00:00"), info.BackupTime);
} // DocumentBuilderTest
// ----------------------------------------------------------------------
private void ConvertXml( IRtfDocument rtfDocument )
{
try
{
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Indent = true;
xmlWriterSettings.IndentChars = ( " " );
xmlWriterSettings.Encoding = settings.Encoding;
string fileName = settings.BuildDestinationFileName( null, RtfXmlConverter.DefaultXmlFileExtension );
using ( XmlWriter writer = XmlWriter.Create( fileName, xmlWriterSettings ) )
{
RtfXmlConvertSettings xmlConvertSettings = new RtfXmlConvertSettings();
xmlConvertSettings.Prefix = settings.XmlPrefix;
xmlConvertSettings.Ns = settings.XmlNamespace;
xmlConvertSettings.IsShowHiddenText = settings.ShowHiddenText;
RtfXmlConverter xmlConverter = new RtfXmlConverter( rtfDocument, writer, xmlConvertSettings );
xmlConverter.Convert();
writer.Flush();
}
}
catch ( Exception e )
{
Console.WriteLine( "error while converting to xml: " + e.Message );
ExitCode = ProgramExitCode.ConvertXml;
}
}
// ----------------------------------------------------------------------
public RtfXmlConverter(IRtfDocument rtfDocument, XmlWriter writer) :
this(rtfDocument, writer, new RtfXmlConvertSettings())
{
} // RtfXmlConverter
