} // ValidateProgramSettings
// ----------------------------------------------------------------------
private IRtfGroup ParseRtf()
{
IRtfGroup rtfStructure;
try
{
// rtf parser
// open readonly - in case of dominant locks...
using (FileStream stream = File.Open(settings.SourceFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
// parse the rtf structure
RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
RtfParser parser = new RtfParser(structureBuilder);
parser.IgnoreContentAfterRootGroup = true; // support WordPad documents
parser.Parse(new RtfSource(stream));
rtfStructure = structureBuilder.StructureRoot;
}
}
catch (Exception e)
{
Console.WriteLine("error while parsing rtf: " + e.Message);
ExitCode = ProgramExitCode.ParseRtf;
return(null);
}
return(rtfStructure);
} // ParseRtf
} // 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
} // ConvertHmtl
// ----------------------------------------------------------------------
private string SaveHmtl(string text)
{
if (!this.settings.SaveHtml)
{
return(null);
}
string fileName = this.settings.BuildDestinationFileName(null, RtfHtmlConverter.DefaultHtmlFileExtension);
try
{
using (TextWriter writer = new StreamWriter(fileName, false, this.settings.Encoding))
{
writer.Write(text);
}
}
catch (Exception /*e*/)
{
//Console.WriteLine( "error while saving html: " + e.Message );
ExitCode = ProgramExitCode.SaveHtml;
return(null);
}
return(fileName);
} // SaveHmtl
} // ConvertHmtl
// ----------------------------------------------------------------------
private string SaveHmtl(string text)
{
if (!settings.SaveHtml)
{
return(null);
}
string fileName = settings.BuildDestinationFileName(null, RtfHtmlConverter.DefaultHtmlFileExtension);
try
{
using (TextWriter writer = new StreamWriter(fileName, false, settings.Encoding))
{
writer.Write(text);
}
}
catch (Exception e)
{
MessageBox(IntPtr.Zero, "Error while saving HTML:\n" + e.Message, "Itenso.Rtf2Html", 0x010000);
ExitCode = ProgramExitCode.SaveHtml;
return(null);
}
return(fileName);
} // SaveHmtl
} // EnsureDestinationDirectory
// ----------------------------------------------------------------------
private IRtfDocument InterpretRtf(IRtfGroup rtfStructure)
{
IRtfDocument rtfDocument;
RtfInterpreterListenerFileLogger interpreterLogger = null;
try
{
// logger
if (settings.LogInterpreter)
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfInterpreterListenerFileLogger.DefaultLogFileExtension);
interpreterLogger = new RtfInterpreterListenerFileLogger(logFileName);
}
// rtf parser
// interpret the rtf structure using the extractors
rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterLogger);
}
catch (Exception e)
{
if (interpreterLogger != null)
{
interpreterLogger.Dispose();
}
Console.WriteLine("error while interpreting rtf: " + e.Message);
ExitCode = ProgramExitCode.InterpretRtf;
return(null);
}
return(rtfDocument);
} // InterpretRtf
} // InterpretRtf
// ----------------------------------------------------------------------
private string SaveText(string text)
{
if (!settings.SaveText)
{
return(null);
}
string fileName = settings.BuildDestinationFileName(null, RtfTextConverter.DefaultTextFileExtension);
try
{
using (TextWriter writer = new StreamWriter(fileName, false, settings.Encoding))
{
writer.Write(text);
}
}
catch (Exception e)
{
Console.WriteLine("error while saving raw text: " + e.Message);
ExitCode = ProgramExitCode.SaveText;
return(null);
}
return(fileName);
} // SaveText
} // Execute
// ----------------------------------------------------------------------
private bool ValidateProgramSettings()
{
if (!this.settings.IsValid)
{
ExitCode = ProgramExitCode.InvalidSettings;
return(false);
}
return(true);
} // ValidateProgramSettings
} // EnsureDestinationDirectory
// ----------------------------------------------------------------------
private IRtfDocument InterpretRtf(IRtfGroup rtfStructure, IRtfVisualImageAdapter imageAdapter)
{
IRtfDocument rtfDocument;
RtfInterpreterListenerFileLogger interpreterLogger = null;
try
{
// logger
if (settings.LogInterpreter)
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfInterpreterListenerFileLogger.DefaultLogFileExtension);
interpreterLogger = new RtfInterpreterListenerFileLogger(logFileName);
}
// image converter
RtfImageConverter imageConverter = null;
if (settings.SaveImage)
{
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings(imageAdapter);
imageConvertSettings.ImagesPath = settings.DestinationDirectory;
imageConvertSettings.BackgroundColor = settings.ImageBackgroundColor;
imageConvertSettings.ScaleImage = !settings.UnscaledImages;
if (settings.ExtendedImageScale)
{
imageConvertSettings.ScaleExtension = 0.5f;
}
imageConverter = new RtfImageConverter(imageConvertSettings);
}
// rtf interpreter
RtfInterpreterSettings interpreterSettings = new RtfInterpreterSettings();
interpreterSettings.IgnoreDuplicatedFonts = settings.IgnoreDuplicatedFonts;
interpreterSettings.IgnoreUnknownFonts = settings.IgnoreUnknownFonts;
// interpret the rtf structure using the extractors
rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterSettings, interpreterLogger, imageConverter);
}
catch (Exception e)
{
if (interpreterLogger != null)
{
interpreterLogger.Dispose();
}
Console.WriteLine("error while interpreting rtf: " + e.Message);
ExitCode = ProgramExitCode.InterpretRtf;
return(null);
}
return(rtfDocument);
} // InterpretRtf
private void Exit(ProgramExitCode code)
{
if (code == ProgramExitCode.Success)
{
string config = Setting ? .Save( );
FileStream settingFile = File.OpenWrite(FileNameConst.SettingFile);
StreamWriter writer = new StreamWriter(settingFile);
writer.Write(config);
writer.Dispose( );
}
ShowExit( );
Application.Stop( );
Environment.Exit(( int )code);
}
} // ParseRtf
// ----------------------------------------------------------------------
private void EnsureDestinationDirectory()
{
try
{
if (!Directory.Exists(settings.DestinationDirectory))
{
Directory.CreateDirectory(settings.DestinationDirectory);
}
}
catch (Exception e)
{
Console.WriteLine("error while creating destination directory: " + e.Message);
ExitCode = ProgramExitCode.DestinationDirectory;
}
} // EnsureDestinationDirectory
} // EnsureDestinationDirectory
// ----------------------------------------------------------------------
private IRtfDocument InterpretRtf(IRtfGroup rtfStructure, IRtfVisualImageAdapter imageAdapter)
{
IRtfDocument rtfDocument;
RtfInterpreterListenerFileLogger interpreterLogger = null;
try
{
// logger
if (settings.LogInterpreter)
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfInterpreterListenerFileLogger.DefaultLogFileExtension);
interpreterLogger = new RtfInterpreterListenerFileLogger(logFileName);
}
// image converter
RtfImageConverter imageConverter = null;
if (settings.SaveImage)
{
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings(imageAdapter);
imageConvertSettings.ImagesPath = settings.DestinationDirectory;
imageConvertSettings.BackgroundColor = settings.ImageBackgroundColor;
if (settings.ExtendedImageScale)
{
imageConvertSettings.ScaleExtension = 0.5f;
}
imageConverter = new RtfImageConverter(imageConvertSettings);
}
// rtf parser
// interpret the rtf structure using the extractors
rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterLogger, imageConverter);
}
catch (Exception e)
{
if (interpreterLogger != null)
{
interpreterLogger.Dispose();
}
MessageBox(IntPtr.Zero, "Error while interpreting RTF:\n" + e.Message, "Itenso.Rtf2Html", 0x010000);
ExitCode = ProgramExitCode.InterpretRtf;
return(null);
}
return(rtfDocument);
} // InterpretRtf
} // 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
} // Execute
// ----------------------------------------------------------------------
private bool ValidateProgramSettings()
{
if (settings.IsHelpMode)
{
ShowHelp();
return(false);
}
if (!settings.IsValid)
{
ShowHelp();
ExitCode = ProgramExitCode.InvalidSettings;
return(false);
}
return(true);
} // ValidateProgramSettings
} // ValidateProgramSettings
// ----------------------------------------------------------------------
private IRtfGroup ParseRtf()
{
IRtfGroup rtfStructure;
RtfParserListenerFileLogger parserLogger = null;
try
{
// logger
if (settings.LogParser)
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfParserListenerFileLogger.DefaultLogFileExtension);
parserLogger = new RtfParserListenerFileLogger(logFileName);
}
// rtf parser
// open readonly - in case of dominant locks...
using (FileStream stream = File.Open(settings.SourceFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
// parse the rtf structure
RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
RtfParser parser = new RtfParser(structureBuilder);
parser.IgnoreContentAfterRootGroup = true; // support WordPad documents
if (parserLogger != null)
{
parser.AddParserListener(parserLogger);
}
parser.Parse(new RtfSource(stream));
rtfStructure = structureBuilder.StructureRoot;
}
}
catch (Exception e)
{
if (parserLogger != null)
{
parserLogger.Dispose();
}
Console.WriteLine("error while parsing rtf: " + e.Message);
ExitCode = ProgramExitCode.ParseRtf;
return(null);
}
return(rtfStructure);
} // ParseRtf
static int Main(string[] args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
ProgramExitCode exitCode = ProgramExitCode.Ok;
Microsoft.Extensions.Logging.ILogger logger = null;
if (args == null)
{
throw new ArgumentNullException(nameof(args), "Provide at least one command.");
}
try
{
switch (args[0])
{
case "upgrade":
logger = EnsureLoggerExists(logger);
UpgradeCommand upgradeCommand = new UpgradeCommand(logger);
upgradeCommand.Execute(args);
break;
case "list":
ListCommand listCommand = new ListCommand(NullLogger.Instance);
listCommand.Execute(args);
break;
default:
throw new ArgumentOutOfRangeException("command", args[0], "Unknown command");
}
}
catch (Exception e)
{
logger = EnsureLoggerExists(logger);
logger.LogError(e.ToString());
exitCode = ProgramExitCode.GeneralError;
}
return((int)exitCode);
}
} // EnsureDestinationDirectory
// ----------------------------------------------------------------------
private IRtfDocument InterpretRtf(IRtfGroup rtfStructure, IRtfVisualImageAdapter imageAdapter)
{
IRtfDocument rtfDocument;
try
{
// image converter
RtfImageConverter imageConverter = null;
if (settings.SaveImage)
{
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings(imageAdapter);
imageConvertSettings.ImagesPath = settings.DestinationDirectory;
if (settings.ImageBackgroundColor.HasValue)
{
imageConvertSettings.BackgroundColor = new Model.RtfColor(settings.ImageBackgroundColor.Value.R
, settings.ImageBackgroundColor.Value.G, settings.ImageBackgroundColor.Value.B);
}
imageConvertSettings.ScaleImage = !settings.UnscaledImages;
if (settings.ExtendedImageScale)
{
imageConvertSettings.ScaleExtension = 0.5f;
}
imageConverter = new RtfImageConverter(imageConvertSettings);
}
// rtf interpreter
RtfInterpreterSettings interpreterSettings = new RtfInterpreterSettings();
interpreterSettings.IgnoreDuplicatedFonts = settings.IgnoreDuplicatedFonts;
interpreterSettings.IgnoreUnknownFonts = settings.IgnoreUnknownFonts;
// interpret the rtf structure using the extractors
rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterSettings, imageConverter);
}
catch (Exception e)
{
Console.WriteLine("error while interpreting rtf: " + e.Message);
ExitCode = ProgramExitCode.InterpretRtf;
return(null);
}
return(rtfDocument);
} // InterpretRtf
} // ParseRtf
// ----------------------------------------------------------------------
private void EnsureDestinationDirectory()
{
if (!this.settings.HasDestinationOutput)
{
return;
}
try
{
if (!Directory.Exists(this.settings.DestinationDirectory))
{
Directory.CreateDirectory(this.settings.DestinationDirectory);
}
}
catch (Exception /*e*/)
{
//Console.WriteLine( "error while creating destination directory: " + e.Message );
ExitCode = ProgramExitCode.DestinationDirectory;
return;
}
} // EnsureDestinationDirectory
} // ParseRtf
// ----------------------------------------------------------------------
private void EnsureDestinationDirectory()
{
if (!settings.HasDestinationOutput)
{
return;
}
try
{
if (!Directory.Exists(settings.DestinationDirectory))
{
Directory.CreateDirectory(settings.DestinationDirectory);
}
}
catch (Exception e)
{
MessageBox(IntPtr.Zero, "Error while creating destination directory:\n" + e.Message, "Itenso.Rtf2Html", 0x010000);
ExitCode = ProgramExitCode.DestinationDirectory;
return;
}
} // EnsureDestinationDirectory
// ----------------------------------------------------------------------
private string SaveText( string text )
{
if ( !settings.SaveText )
{
return null;
}
string fileName = settings.BuildDestinationFileName( null, RtfTextConverter.DefaultTextFileExtension );
try
{
using ( TextWriter writer = new StreamWriter( fileName, false, settings.Encoding ) )
{
writer.Write( text );
}
}
catch ( Exception e )
{
Console.WriteLine( "error while saving raw text: " + e.Message );
ExitCode = ProgramExitCode.SaveText;
return null;
}
return fileName;
}
// ----------------------------------------------------------------------
private bool ValidateProgramSettings()
{
if ( settings.IsHelpMode )
{
ShowHelp();
return false;
}
if ( !settings.IsValid )
{
ShowHelp();
ExitCode = ProgramExitCode.InvalidSettings;
return false;
}
return true;
}
// ----------------------------------------------------------------------
private string InterpretRtf( IRtfGroup rtfStructure )
{
string text = null;
RtfInterpreterListenerFileLogger interpreterLogger = null;
try
{
// logger
if ( settings.LogInterpreter )
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfInterpreterListenerFileLogger.DefaultLogFileExtension );
interpreterLogger = new RtfInterpreterListenerFileLogger( logFileName );
}
// text converter
RtfTextConverter textConverter = null;
if ( settings.SaveText )
{
RtfTextConvertSettings textConvertSettings = new RtfTextConvertSettings();
textConvertSettings.IsShowHiddenText = settings.ShowHiddenText;
textConverter = new RtfTextConverter( textConvertSettings );
}
// image converter
RtfImageConverter imageConverter = null;
if ( settings.SaveImage )
{
RtfVisualImageAdapter imageAdapter = new RtfVisualImageAdapter(
settings.ImageFileNamePattern,
settings.ImageFormat );
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings( imageAdapter );
imageConvertSettings.ImagesPath = settings.DestinationDirectory;
imageConvertSettings.ScaleImage = settings.ScaleImage;
imageConvertSettings.BackgroundColor = settings.ImageBackgroundColor;
if ( settings.ExtendedImageScale )
{
imageConvertSettings.ScaleExtension = 0.5f;
}
imageConverter = new RtfImageConverter( imageConvertSettings );
}
// rtf parser
// interpret the rtf structure using the extractors
RtfInterpreterTool.Interpret( rtfStructure, interpreterLogger, textConverter, imageConverter );
// get the resulting text
if ( textConverter != null )
{
text = textConverter.PlainText;
}
}
catch ( Exception e )
{
if ( interpreterLogger != null )
{
interpreterLogger.Dispose();
}
Console.WriteLine( "error while interpreting rtf: " + e.Message );
ExitCode = ProgramExitCode.InterpretRtf;
return null;
}
return text;
}
// ----------------------------------------------------------------------
private IRtfGroup ParseRtf()
{
IRtfGroup rtfStructure;
RtfParserListenerFileLogger parserLogger = null;
try
{
// logger
if ( settings.LogParser )
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfParserListenerFileLogger.DefaultLogFileExtension );
parserLogger = new RtfParserListenerFileLogger( logFileName );
}
// rtf parser
// open readonly - in case of dominant locks...
using ( FileStream stream = File.Open( settings.SourceFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ) )
{
// parse the rtf structure
RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
RtfParser parser = new RtfParser( structureBuilder );
parser.IgnoreContentAfterRootGroup = true; // support WordPad documents
if ( parserLogger != null )
{
parser.AddParserListener( parserLogger );
}
parser.Parse( new RtfSource( stream ) );
rtfStructure = structureBuilder.StructureRoot;
}
}
catch ( Exception e )
{
if ( parserLogger != null )
{
parserLogger.Dispose();
}
Console.WriteLine( "error while parsing rtf: " + e.Message );
ExitCode = ProgramExitCode.ParseRtf;
return null;
}
return rtfStructure;
}
// ----------------------------------------------------------------------
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;
}
// ----------------------------------------------------------------------
private void EnsureDestinationDirectory()
{
if ( !settings.HasDestinationOutput )
{
return;
}
try
{
if ( !Directory.Exists( settings.DestinationDirectory ) )
{
Directory.CreateDirectory( settings.DestinationDirectory );
}
}
catch ( Exception e )
{
Console.WriteLine( "error while creating destination directory: " + e.Message );
ExitCode = ProgramExitCode.DestinationDirectory;
}
}
// ----------------------------------------------------------------------
private IRtfDocument InterpretRtf( IRtfGroup rtfStructure, IRtfVisualImageAdapter imageAdapter )
{
IRtfDocument rtfDocument;
RtfInterpreterListenerFileLogger interpreterLogger = null;
try
{
// logger
if ( settings.LogInterpreter )
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfInterpreterListenerFileLogger.DefaultLogFileExtension );
interpreterLogger = new RtfInterpreterListenerFileLogger( logFileName );
}
// image converter
RtfImageConverter imageConverter = null;
if ( settings.SaveImage )
{
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings( imageAdapter );
imageConvertSettings.ImagesPath = settings.DestinationDirectory;
imageConvertSettings.BackgroundColor = settings.ImageBackgroundColor;
if ( settings.ExtendedImageScale )
{
imageConvertSettings.ScaleExtension = 0.5f;
}
imageConverter = new RtfImageConverter( imageConvertSettings );
}
// rtf parser
// interpret the rtf structure using the extractors
rtfDocument = RtfInterpreterTool.BuildDoc( rtfStructure, interpreterLogger, imageConverter );
}
catch ( Exception e )
{
if ( interpreterLogger != null )
{
interpreterLogger.Dispose();
}
Console.WriteLine( "error while interpreting rtf: " + e.Message );
ExitCode = ProgramExitCode.InterpretRtf;
return null;
}
return rtfDocument;
}
} // EnsureDestinationDirectory
// ----------------------------------------------------------------------
private string InterpretRtf(IRtfGroup rtfStructure)
{
string text = null;
RtfInterpreterListenerFileLogger interpreterLogger = null;
try
{
// logger
if (settings.LogInterpreter)
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfInterpreterListenerFileLogger.DefaultLogFileExtension);
interpreterLogger = new RtfInterpreterListenerFileLogger(logFileName);
}
// text converter
RtfTextConverter textConverter = null;
if (settings.SaveText)
{
RtfTextConvertSettings textConvertSettings = new RtfTextConvertSettings();
textConvertSettings.IsShowHiddenText = settings.ShowHiddenText;
textConverter = new RtfTextConverter(textConvertSettings);
}
// image converter
RtfImageConverter imageConverter = null;
if (settings.SaveImage)
{
RtfVisualImageAdapter imageAdapter = new RtfVisualImageAdapter(
settings.ImageFileNamePattern,
settings.ImageFormat);
RtfImageConvertSettings imageConvertSettings = new RtfImageConvertSettings(imageAdapter);
imageConvertSettings.ImagesPath = settings.DestinationDirectory;
imageConvertSettings.ScaleImage = settings.ScaleImage;
imageConvertSettings.BackgroundColor = settings.ImageBackgroundColor;
imageConvertSettings.ScaleImage = !settings.UnscaledImages;
if (settings.ExtendedImageScale)
{
imageConvertSettings.ScaleExtension = 0.5f;
}
imageConverter = new RtfImageConverter(imageConvertSettings);
}
// rtf interpreter
RtfInterpreterSettings interpreterSettings = new RtfInterpreterSettings();
interpreterSettings.IgnoreDuplicatedFonts = settings.IgnoreDuplicatedFonts;
interpreterSettings.IgnoreUnknownFonts = settings.IgnoreUnknownFonts;
// interpret the rtf structure using the extractors
RtfInterpreterTool.Interpret(rtfStructure, interpreterLogger, textConverter, imageConverter);
// get the resulting text
if (textConverter != null)
{
text = textConverter.PlainText;
}
}
catch (Exception e)
{
if (interpreterLogger != null)
{
interpreterLogger.Dispose();
}
Console.WriteLine("error while interpreting rtf: " + e.Message);
ExitCode = ProgramExitCode.InterpretRtf;
return(null);
}
return(text);
} // InterpretRtf
public override void OnExit(ProgramExitCode code)
{
}
// ----------------------------------------------------------------------
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;
}
}
// ----------------------------------------------------------------------
private IRtfDocument InterpretRtf( IRtfGroup rtfStructure )
{
IRtfDocument rtfDocument;
RtfInterpreterListenerFileLogger interpreterLogger = null;
try
{
// logger
if ( settings.LogInterpreter )
{
string logFileName = settings.BuildDestinationFileName(
settings.LogDirectory,
RtfInterpreterListenerFileLogger.DefaultLogFileExtension );
interpreterLogger = new RtfInterpreterListenerFileLogger( logFileName );
}
// rtf parser
// interpret the rtf structure using the extractors
rtfDocument = RtfInterpreterTool.BuildDoc( rtfStructure, interpreterLogger );
}
catch ( Exception e )
{
if ( interpreterLogger != null )
{
interpreterLogger.Dispose();
}
Console.WriteLine( "error while interpreting rtf: " + e.Message );
ExitCode = ProgramExitCode.InterpretRtf;
return null;
}
return rtfDocument;
}
