Esempio n. 1
0
        } // 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
Esempio n. 2
0
        private async Task <String> GetUgcPadContent()
        {
            String richText;

            #region Get RichEdit Raw Data

            this.RichBox.Document.GetText(TextGetOptions.FormatRtf, out richText);

            #endregion

            var structureBuilder = new RtfParserListenerStructureBuilder();
            var parser           = new RtfParser(structureBuilder);
            parser.IgnoreContentAfterRootGroup = true; // support WordPad documents

            parser.Parse(new RtfSource(richText));

            var rtfStructure = structureBuilder.StructureRoot;

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

            // rtf interpreter
            var interpreterSettings = new RtfInterpreterSettings();

            var rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterSettings, imageConverter);

            var htmlSegments = await RtfToHtmlSegments(rtfDocument.VisualContent);

            return(htmlSegments);
        }
Esempio n. 3
0
        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);
        }
Esempio n. 4
0
        }         // ParseResourcesTest

        // ----------------------------------------------------------------------
        protected override void DoTest(string kind, Stream testRes, string testCaseName)
        {
            RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
            RtfParser parser = new RtfParser();

            //parser.AddParserListener( new RtfParserListenerLogger() );
            parser.AddParserListener(structureBuilder);

            parser.Parse(new RtfSource(testRes));
            Assert.IsNotNull(structureBuilder.StructureRoot);
        }         // DoTest
Esempio n. 5
0
        private IRtfGroup ParseRtf(string RtfString)
        {
            IRtfGroup rtfStructure;
            // parse the rtf structure
            RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
            RtfParser parser = new RtfParser(structureBuilder);

            parser.IgnoreContentAfterRootGroup = true; // support WordPad documents
            using (TextReader reader = new StringReader(RtfString))
            {
                parser.Parse(new RtfSource(reader));
            }
            rtfStructure = structureBuilder.StructureRoot;
            return(rtfStructure);
        }
        } // ConvertRtf2Html

        private static IRtfGroup ParseRtf(string text)
        {
            IRtfGroup rtfStructure;

            using (Stream stream = GenerateStreamFromString(text))
            {
                RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
                RtfParser parser = new RtfParser(structureBuilder);
                parser.IgnoreContentAfterRootGroup = true; // support WordPad documents

                parser.Parse(new RtfSource(stream));
                rtfStructure = structureBuilder.StructureRoot;
            }
            return(rtfStructure);
        } // ParseRtf
Esempio n. 7
0
        }         // 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
Esempio n. 8
0
        } // Parse

        public static IRtfGroup Parse(IRtfSource rtfTextSource, params IRtfParserListener[] listeners)
        {
            var structureBuilder = new RtfParserListenerStructureBuilder();
            var parser           = new RtfParser(structureBuilder);

            if (listeners != null)
            {
                foreach (var listener in listeners)
                {
                    if (listener != null)
                    {
                        parser.AddParserListener(listener);
                    }
                }
            }
            parser.Parse(rtfTextSource);
            return(structureBuilder.StructureRoot);
        } // Parse
Esempio n. 9
0
        }         // ConvertRtf2Html

        // ----------------------------------------------------------------------
        private IRtfGroup ParseRtf(string fileName)
        {
            IRtfGroup rtfStructure;

            using (FileStream stream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
                RtfParser parser = new RtfParser(structureBuilder);
                parser.IgnoreContentAfterRootGroup = true;                 // support WordPad documents
                if (!string.IsNullOrEmpty(ParserLogFileName))
                {
                    parser.AddParserListener(new RtfParserListenerFileLogger(ParserLogFileName));
                }
                parser.Parse(new RtfSource(stream));
                rtfStructure = structureBuilder.StructureRoot;
            }
            return(rtfStructure);
        } // ParseRtf
Esempio n. 10
0
        private static IRtfGroup ParseRtf(RtfSource source)
        {
            IRtfGroup rtfStructure;

            try
            {
                // parse the rtf structure
                RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
                RtfParser parser = new RtfParser(structureBuilder);
                parser.IgnoreContentAfterRootGroup = true; // support WordPad documents
                parser.Parse(source);
                rtfStructure = structureBuilder.StructureRoot;
            }
            catch
            {
                return(null);
            }

            return(rtfStructure);
        } // ParseRtf
Esempio n. 11
0
        private async void ContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
        {
            String richText;

            this.RichBox.Document.GetText(TextGetOptions.FormatRtf, out richText);

            var structureBuilder = new RtfParserListenerStructureBuilder();
            var parser           = new RtfParser(structureBuilder);

            parser.IgnoreContentAfterRootGroup = true; // support WordPad documents

            parser.Parse(new RtfSource(richText));

            var rtfStructure = structureBuilder.StructureRoot;

            // image converter
            var imageAdapter         = new RtfVisualImageAdapter(ImageFormat.Jpeg);
            var imageConvertSettings = new RtfImageConvertSettings(imageAdapter);

            imageConvertSettings.ScaleImage = true; // scale images
            var imageConverter = new RtfImageConverter(imageConvertSettings);

            // rtf interpreter
            var interpreterSettings = new RtfInterpreterSettings();

            var rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, interpreterSettings, imageConverter);

            var htmlSegments = await RtfToHtmlSegments(rtfDocument.VisualContent);

            var anonymited = this.Anonymity.IsChecked.HasValue && this.Anonymity.IsChecked.Value == true;

            this.Result = new UgcDialogResult(anonymited, htmlSegments);

            //var deferral = args.GetDeferral();

            //deferral.Complete();
        }
Esempio n. 12
0
        public void ParseStructureBuilderTest()
        {
            RtfParser parser = new RtfParser();
            RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();

            parser.AddParserListener(structureBuilder);
            parser.Parse(new RtfSource(@"{\rtf1foobar}"));

            IRtfGroup rtfStructure = structureBuilder.StructureRoot;

            Assert.IsNotNull(rtfStructure);

            Assert.AreEqual(RtfElementKind.Group, rtfStructure.Kind);
            Assert.AreEqual(2, rtfStructure.Contents.Count);

            Assert.AreEqual(RtfElementKind.Tag, rtfStructure.Contents[0].Kind);
            Assert.AreEqual("rtf", ((IRtfTag)rtfStructure.Contents[0]).Name);
            Assert.AreEqual(true, ((IRtfTag)rtfStructure.Contents[0]).HasValue);
            Assert.AreEqual("1", ((IRtfTag)rtfStructure.Contents[0]).ValueAsText);
            Assert.AreEqual(1, ((IRtfTag)rtfStructure.Contents[0]).ValueAsNumber);

            Assert.AreEqual(RtfElementKind.Text, rtfStructure.Contents[1].Kind);
            Assert.AreEqual("foobar", ((IRtfText)rtfStructure.Contents[1]).Text);
        }         // ParseStructureBuilderTest
Esempio n. 13
0
        /// <summary>
        /// Process the submissions absolute path
        /// </summary>
        /// <returns>Was the submission able to be loaded?</returns>
        public override bool Process()
        {
            _loaded = false;

            try
            {
#if NETCORE
                // Add a reference to the NuGet package System.Text.Encoding.CodePages for .Net core only
                Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
#endif

                IRtfGroup rtfStructure;
                RtfParserListenerStructureBuilder structureBuilder = new RtfParserListenerStructureBuilder();
                RtfParser parser = new RtfParser(structureBuilder);
                parser.IgnoreContentAfterRootGroup = true; // support WordPad documents
                parser.Parse(new RTFDocumentSource(_target.AbsolutePath));
                rtfStructure = structureBuilder.StructureRoot;

                var intSettings = new RtfInterpreterSettings()
                {
                    IgnoreDuplicatedFonts = true, IgnoreUnknownFonts = true
                };
                var rtfDocument = RtfInterpreterTool.BuildDoc(rtfStructure, intSettings);


                if (rtfDocument.DocumentInfo.Author != null)
                {
                    _target.MetaCreator = rtfDocument.DocumentInfo.Author;
                }

                if (rtfDocument.DocumentInfo.CreationTime != null)
                {
                    _target.MetaDateCreated = (DateTime)rtfDocument.DocumentInfo.CreationTime;
                }

                if (rtfDocument.DocumentInfo.PrintTime != null)
                {
                    _target.MetaDateLastPrinted = (DateTime)rtfDocument.DocumentInfo.PrintTime;
                }

                if (rtfDocument.DocumentInfo.RevisionTime != null)
                {
                    _target.MetaDateModified = (DateTime)rtfDocument.DocumentInfo.RevisionTime;
                }

                // Build our content
                StringBuilder builder = new StringBuilder();
                foreach (IRtfVisual v in rtfDocument.VisualContent)
                {
                    if (v.Kind == RtfVisualKind.Text)
                    {
                        builder.Append(v.ToString());
                    }
                }

                _target.Content       = builder.ToString();
                _target.ContentLength = _target.Content.Length;
                _target.ContentHash   = Compare.Hash(_target.Content);

                _loaded = true;
            }
            catch (Exception e)
            {
                _target.Logging.Add("- " + Markdown.Bold("An exception occured when processing " + _target.AbsolutePath + ", " + e.Message));
            }

            return(_loaded);
        }