public void CanBeInsertedInto()
        {
            ContainerBlock container = new MockContainerBlock();

            var one = new ParagraphBlock();

            container.Insert(0, one);
            Assert.AreEqual(1, container.Count);
            Assert.AreSame(container[0], one);

            var two = new ParagraphBlock();

            container.Insert(1, two);
            Assert.AreEqual(2, container.Count);
            Assert.AreSame(container[0], one);
            Assert.AreSame(container[1], two);

            var three = new ParagraphBlock();

            container.Insert(0, three);
            Assert.AreEqual(3, container.Count);
            Assert.AreSame(container[0], three);
            Assert.AreSame(container[1], one);
            Assert.AreSame(container[2], two);

            Assert.Throws <ArgumentNullException>(() => container.Insert(0, null));
            Assert.Throws <ArgumentOutOfRangeException>(() => container.Insert(4, new ParagraphBlock()));
            Assert.Throws <ArgumentOutOfRangeException>(() => container.Insert(-1, new ParagraphBlock()));
            Assert.Throws <ArgumentException>(() => container.Insert(0, one)); // one already has a parent
        }
        public void WriteBlock_OnlyWritesChildrenIfEnableHtmlForBlockIsFalse()
        {
            // Arrange
            const string dummyChildText       = "dummyChildText";
            var          dummyContainerInline = new ContainerInline();

            dummyContainerInline.AppendChild(new LiteralInline(dummyChildText));
            var dummyParagraphBlock = new ParagraphBlock()
            {
                Inline = dummyContainerInline
            };
            FlexiSectionBlock dummyFlexiSectionBlock = CreateFlexiSectionBlock();

            dummyFlexiSectionBlock.Add(dummyParagraphBlock);
            var dummyStringWriter = new StringWriter();
            var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter)
            {
                EnableHtmlForBlock = false
            };
            ExposedFlexiSectionBlockRenderer testSubject = CreateExposedFlexiSectionBlockRenderer();

            // Act
            testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiSectionBlock);
            string result = dummyStringWriter.ToString();

            // Assert
            Assert.Equal(dummyChildText + "\n", result, ignoreLineEndingDifferences: true);
        }
        private static Block CreateParagraph(ParagraphBlock paragraphBlock)
        {
            var paragraph = new Paragraph();

            paragraph.Inlines.AddRange(CreateInlines(paragraphBlock.Inlines));
            return(paragraph);
        }
Exemple #4
0
        /// <summary>
        /// Convert a Markdown element to a Forkdown one.
        /// </summary>
        /// <param name="mdo">Markdown object to convert.</param>
        public static Element ToForkdown(IMarkdownObject mdo)
        {
            Element result = mdo switch {
                MarkdownDocument _ => new Document(),
                HeadingBlock h => new Heading(h),
                ListBlock l => new Listing(l),
                ListItemBlock li => new ListItem(li),
                ParagraphBlock p => new Paragraph(p),
                CustomContainer c => new Section(c),
                CustomContainerInline c => new ExplicitInlineContainer(c),
                CodeInline c => new Code(c),
                FencedCodeBlock c => new CodeBlock(c),
                LinkInline l => new Link(l),
                LiteralInline t => new Text(t),
                LineBreakInline _ => new LineBreak(),
                ThematicBreakBlock _ => new Separator(),
                Tables.Table t => new Table(t),
                Tables.TableRow tr => new TableRow(tr),
                Tables.TableCell tc => new TableCell(tc),
                EmphasisInline e => new Emphasis(e),
                HtmlBlock b => new Html(b),
                _ => new Placeholder(mdo),
            };

            var subs = mdo switch {
                LeafBlock b => b.Inline,
                IEnumerable <MarkdownObject> e => e,
                _ => null
            } ?? Nil.E <MarkdownObject>();
Exemple #5
0
        public void Hyperlink_MailtoHostPart(string input, string hyperLinkUrl, string text, string superScriptText)
        {
            ParagraphBlock expected;

            if (hyperLinkUrl is null)
            {
                if (superScriptText != null)
                {
                    expected = new ParagraphBlock().AddChildren(new TextRunInline {
                        Text = text
                    }, new SuperscriptTextInline().AddChildren(new TextRunInline {
                        Text = superScriptText
                    }));
                }
                else
                {
                    expected = new ParagraphBlock().AddChildren(new TextRunInline {
                        Text = text
                    });
                }
            }
            else
            {
                expected = new ParagraphBlock().AddChildren(new HyperlinkInline {
                    Url = hyperLinkUrl, Text = text, LinkType = HyperlinkType.Email
                });
            }

            AssertEqual(input, expected);
        }
Exemple #6
0
            public static CellData Parse(ParagraphBlock paragraph)
            {
                CellData data = new CellData();

                StringBuilder buffer = new StringBuilder();

                foreach (var segment in paragraph.Inline)
                {
                    LinkInline link = segment as LinkInline;

                    if (link != null)
                    {
                        data.Link = link.Url;

                        buffer = new StringBuilder();

                        foreach (var text in link)
                        {
                            buffer.Append(text);
                        }

                        data.Text = buffer.ToString();
                        break;
                    }

                    buffer.Append(segment.ToString());
                }

                data.Text = buffer.ToString();
                return(data);
            }
Exemple #7
0
        private List <string> ReadDescription(MarkdownDocument document, ref int start)
        {
            List <string> descriptions = new List <string>();

            while (start < document.Count)
            {
                ParagraphBlock paragraph = document[start++] as ParagraphBlock;

                if (paragraph == null)
                {
                    break;
                }

                StringBuilder builder = new StringBuilder();

                foreach (var jj in paragraph.Inline)
                {
                    var linebreak = jj is Markdig.Syntax.Inlines.LineBreakInline;

                    if (linebreak)
                    {
                        descriptions.Add(builder.ToString());
                        builder.Length = 0;
                        continue;
                    }

                    builder.Append(jj.ToString());
                }

                descriptions.Add(builder.ToString());
            }

            return(descriptions);
        }
Exemple #8
0
        /// <summary>
        /// Replaces a <see cref="ProxyTableBlock"/> with a <see cref="ParagraphBlock"/>.
        /// </summary>
        /// <param name="blockProcessor">The <see cref="BlockProcessor"/> processing the <see cref="ProxyTableBlock"/> to undo.</param>
        /// <param name="proxyTableBlock">The <see cref="ProxyTableBlock"/> to undo.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="blockProcessor"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="proxyTableBlock"/> is <c>null</c>.</exception>
        protected virtual void Undo(BlockProcessor blockProcessor, ProxyTableBlock proxyTableBlock)
        {
            if (blockProcessor == null)
            {
                throw new ArgumentNullException(nameof(blockProcessor));
            }

            if (proxyTableBlock == null)
            {
                throw new ArgumentNullException(nameof(proxyTableBlock));
            }

            // Discard proxyTableBlock
            ContainerBlock parent = proxyTableBlock.Parent;

            blockProcessor.Discard(proxyTableBlock);

            // Replace with paragraph block
            ParagraphBlockParser parser = blockProcessor.Parsers.FindExact <ParagraphBlockParser>();
            var paragraphBlock          = new ParagraphBlock(parser)
            {
                Lines = proxyTableBlock.Lines,
            };

            parent.Add(paragraphBlock);
            blockProcessor.Open(paragraphBlock);
        }
        static ParagraphBlockViewModel CreateParagraphViewModel(ParagraphBlock paragraph, string prefix = null)
        {
            var viewModel = new ParagraphBlockViewModel();

            if (!string.IsNullOrEmpty(prefix))
            {
                viewModel.Spans.Add(new SpanInline {
                    Text = prefix
                });
            }

            foreach (var inline in paragraph.Inlines)
            {
                var span = GetInlineTextWithFlags(inline);
                if (span == null)
                {
                    continue;
                }

                viewModel.Spans.Add(span);
            }

            viewModel.GenerateFormattedString();
            return(viewModel);
        }
        /// <summary>
        /// Renders a paragraph element.
        /// </summary>
        protected override void RenderParagraph(ParagraphBlock element, IRenderContext context)
        {
            if (!(context is BlockCollectionRenderContext localContext))
            {
                throw new RenderContextIncorrectException();
            }

            var blockCollection = localContext.BlockCollection;

            var paragraph = new Paragraph
            {
                Margin     = ParagraphMargin,
                LineHeight = ParagraphLineHeight,
                Foreground = localContext.Foreground
            };

            var childContext = new InlineRenderContext(paragraph.Inlines, context)
            {
                Parent = paragraph
            };

            RenderInlineChildren(element.Inlines, childContext);

            blockCollection.Add(paragraph);
        }
Exemple #11
0
        public void TestParse()
        {
            const string markdown = "This is a text with some *emphasis*";

            var pipeline = new MarkdownPipelineBuilder()
                           .UsePreciseSourceLocation()
                           .Build();

            MarkdownDocument document = Markdown.Parse(markdown, pipeline);

            Assert.AreEqual(1, document.LineCount);
            Assert.AreEqual(markdown.Length, document.Span.Length);
            Assert.AreEqual(1, document.LineStartIndexes.Count);
            Assert.AreEqual(0, document.LineStartIndexes[0]);

            Assert.AreEqual(1, document.Count);
            ParagraphBlock paragraph = document[0] as ParagraphBlock;

            Assert.NotNull(paragraph);
            Assert.AreEqual(markdown.Length, paragraph.Span.Length);
            LiteralInline literal = paragraph.Inline.FirstChild as LiteralInline;

            Assert.NotNull(literal);
            Assert.AreEqual("This is a text with some ", literal.ToString());
            EmphasisInline emphasis = literal.NextSibling as EmphasisInline;

            Assert.NotNull(emphasis);
            Assert.AreEqual("*emphasis*".Length, emphasis.Span.Length);
            LiteralInline emphasisLiteral = emphasis.FirstChild as LiteralInline;

            Assert.NotNull(emphasisLiteral);
            Assert.AreEqual("emphasis", emphasisLiteral.ToString());
            Assert.Null(emphasisLiteral.NextSibling);
            Assert.Null(emphasis.NextSibling);
        }
        // Root,                           --- Done
        // Paragraph,                      --- Done
        // Header,// #(1-6)、===、---      --- Done
        // HorizontalRule,// ---、***
        // List, // +、-、*、number.       --- Done
        // Code,  // Four spaces or \t
        // Quote, // >
        // ListItemBuilder,
        // Table, // 表 | 1 | 2 |
        // LinkReference, // [name](url)

        internal static MarkdownBlock ParseBlock(string markdownText, int start, int end, out int actualEnd)
        {
            actualEnd = start;
            MarkdownBlock block        = null;
            char          nonSpaceChar = GetNonSpaceChar(markdownText, start, end, out int nonSpacePos);

            if (nonSpaceChar == '#' && nonSpacePos == start)
            {
                block = HeaderBlock.Parse(markdownText, start, end, out actualEnd);
            }

            if (block == null && (nonSpaceChar == '*' || nonSpaceChar == '-' || nonSpaceChar == '_'))
            {
                block = HorizontalRuleBlock.Parse(markdownText, start, end, out actualEnd);
            }

            if (block == null && (nonSpaceChar == '*' || nonSpaceChar == '+' || nonSpaceChar == '-' || (nonSpaceChar >= '0' && nonSpaceChar <= '9')))
            {
                block = ListElement.Parse(markdownText, start, end, out actualEnd);
            }

            if (block == null)
            {
                block = ParagraphBlock.Parse(markdownText, start, end, out actualEnd);
            }

            return(block);
        }
Exemple #13
0
        public MarkdownParagraph(ParagraphBlock paragraphBlock)
        {
            this.paragraphBlock = paragraphBlock;

            RelativeSizeAxes = Axes.X;
            AutoSizeAxes     = Axes.Y;
        }
Exemple #14
0
            private void RenderParagraph(ParagraphBlock block, UIElementCollection blockUIElementCollection)
            {
                var paragraph = new Paragraph();

                RenderInlines(block.Inlines, paragraph.Inlines);
                var textBlock = CreateOrReuseRichTextBlock(blockUIElementCollection);

                textBlock.Blocks.Add(paragraph);
            }
        private ParagraphBlock CreateBlock()
        {
            var paragraph = new ParagraphBlock();
            var cursor    = (TextCaret)paragraph.GetCaretAtStart();

            cursor.InsertText("This is some of the text")
            .InsertText("Some additional text");
            return(paragraph);
        }
Exemple #16
0
        private TableData ParseGenericTable(Table table)
        {
            var data = new TableData();

            bool                    body    = false;
            List <string>           columns = new List <string>();
            List <List <CellData> > rows    = new List <List <CellData> >();

            foreach (TableRow row in table)
            {
                if (!body)
                {
                    foreach (TableCell cell in row)
                    {
                        foreach (var content in cell)
                        {
                            ParagraphBlock paragraph = content as ParagraphBlock;

                            if (paragraph != null)
                            {
                                var cellData = CellData.Parse(paragraph);
                                columns.Add(cellData.Text);
                            }
                        }
                    }

                    body = true;
                    continue;
                }

                List <CellData> newRow = new List <CellData>();

                foreach (TableCell cell in row)
                {
                    foreach (var content in cell)
                    {
                        ParagraphBlock paragraph = content as ParagraphBlock;

                        if (paragraph != null)
                        {
                            var cellData = CellData.Parse(paragraph);
                            newRow.Add(cellData);
                        }
                    }
                }

                rows.Add(newRow);
            }

            data.Columns = columns;
            data.Rows    = rows;

            return(data);
        }
Exemple #17
0
 public void Setup()
 {
     document = new Document();
     // Workaround for a quirk in the migradoc API.
     _                = document.AddSection().Elements;
     pdfBuilder       = new PdfBuilder(document, PdfOptions.Default);
     renderer         = new ParagraphBlockRenderer();
     paragraph        = new ParagraphBlock();
     paragraphText    = "some text";
     paragraph.Inline = new ContainerInline().AppendChild(new LiteralInline(paragraphText));
 }
Exemple #18
0
        /// <summary>
        /// Renders a paragraph element.
        /// </summary>
        /// <param name="element"></param>
        /// <param name="blockUIElementCollection"></param>
        /// <param name="context"></param>
        private void RenderParagraph(ParagraphBlock element, UIElementCollection blockUIElementCollection, RenderContext context)
        {
            var paragraph = new Paragraph();

            paragraph.Margin = ParagraphMargin;
            context.TrimLeadingWhitespace = true;
            RenderInlineChildren(paragraph.Inlines, element.Inlines, paragraph, context);

            var textBlock = CreateOrReuseRichTextBlock(blockUIElementCollection, context);

            textBlock.Blocks.Add(paragraph);
        }
Exemple #19
0
        private Paragraph ConvertParagraphBlock(ParagraphBlock paragraphBlock, int numberingId, int nestLevel)
        {
            var inlineConverter    = new InlineConverter(Manipulator, UserSettingStyleMap, BaseFolderPathForRelativePath);
            var oxmlInlineElements = inlineConverter.Convert(paragraphBlock.Inline);

            var styleId       = UserSettingStyleMap.GetStyleId(UserSettingStyleMap.StyleMapKeyType.Paragraph, null);
            var oxmlParagraph = Manipulator.ElementCreator.CreateParagraphElement(oxmlInlineElements, styleId, numberingId, nestLevel);

            Manipulator.AdjustImageDimension(oxmlParagraph);

            return(oxmlParagraph);
        }
Exemple #20
0
        private void Render(ParagraphBlock block)
        {
            var style           = this.Theme.Paragraph;
            var foregroundColor = isQuoted ? this.Theme.Quote.ForegroundColor : style.ForegroundColor;
            var label           = new Label
            {
                FormattedText = CreateFormatted(block.Inline, style.FontFamily, style.Attributes, foregroundColor, style.BackgroundColor, style.FontSize),
            };

            AttachLinks(label);
            this.stack.Children.Add(label);
        }
        private IEnumerable <View> Render(ParagraphBlock block)
        {
            var style           = this.Theme.Paragraph;
            var foregroundColor = isQuoted ? this.Theme.Quote.ForegroundColor : style.ForegroundColor;
            var label           = new Label
            {
                FormattedText = CreateFormatted(block.Inline, style.FontFamily, style.Attributes, foregroundColor, style.BackgroundColor, style.FontSize),
            };

            AttachLinks(label);
            return(new View[] { label });
        }
    public void ParagraphConverterCallsInlineConverterTest()
    {
        var testInlineParser = new TestInlineParser();
        var logger           = loggerMockFactory.Get <ParagraphConverter>().Object;

        ParagraphConverter converter = new ParagraphConverter(testInlineParser, logger);

        var paragraph = new ParagraphBlock();

        converter.Execute(paragraph);

        Assert.True(testInlineParser.ParseCalled);
    }
 protected override void Write(HtmlRenderer renderer, ParagraphBlock obj)
 {
     if (!renderer.IsFirstInContainer)
     {
         renderer.EnsureLine();
     }
     renderer.WriteLeafInline(obj);
     if (!renderer.IsLastInContainer)
     {
         renderer.WriteLine("<br />");
         renderer.WriteLine("<br />");
     }
 }
Exemple #24
0
        private View Render(ParagraphBlock block)
        {
            var paragraph = ParagraphTemplate.CreateContent() as View;

            paragraph.BindingContext = new Templates.ParagraphAstNode
            {
                FormattedText = CreateFormatted(block.Inline)
            };

            AttachLinks(paragraph);

            return(paragraph);
        }
Exemple #25
0
        protected override void Write(RoundtripRenderer renderer, QuoteBlock quoteBlock)
        {
            renderer.RenderLinesBefore(quoteBlock);
            renderer.Write(quoteBlock.TriviaBefore);

            var indents = new string[quoteBlock.QuoteLines.Count];

            for (int i = 0; i < quoteBlock.QuoteLines.Count; i++)
            {
                var quoteLine           = quoteBlock.QuoteLines[i];
                var wsb                 = quoteLine.TriviaBefore.ToString();
                var quoteChar           = quoteLine.QuoteChar ? ">" : "";
                var spaceAfterQuoteChar = quoteLine.HasSpaceAfterQuoteChar ? " " : "";
                var wsa                 = quoteLine.TriviaAfter.ToString();
                indents[i] = (wsb + quoteChar + spaceAfterQuoteChar + wsa);
            }
            bool noChildren = false;

            if (quoteBlock.Count == 0)
            {
                noChildren = true;
                // since this QuoteBlock instance has no children, indents will not be rendered. We
                // work around this by adding empty LineBreakInlines to a ParagraphBlock.
                // Wanted: a more elegant/better solution (although this is not *that* bad).
                foreach (var quoteLine in quoteBlock.QuoteLines)
                {
                    var emptyLeafBlock = new ParagraphBlock
                    {
                        NewLine = quoteLine.NewLine
                    };
                    var newLine = new LineBreakInline
                    {
                        NewLine = quoteLine.NewLine
                    };
                    var container = new ContainerInline();
                    container.AppendChild(newLine);
                    emptyLeafBlock.Inline = container;
                    quoteBlock.Add(emptyLeafBlock);
                }
            }

            renderer.PushIndent(indents);
            renderer.WriteChildren(quoteBlock);
            renderer.PopIndent();

            if (!noChildren)
            {
                renderer.RenderLinesAfter(quoteBlock);
            }
        }
Exemple #26
0
        void Render(ParagraphBlock block)
        {
            var style           = Theme.Paragraph;
            var foregroundColor = isQuoted ? Theme.Quote.ForegroundColor : style.ForegroundColor;
            var label           = new Label
            {
                FormattedText           = CreateFormatted(block.Inline, style.FontFamily, style.Attributes, style.TextDecorations, foregroundColor, style.BackgroundColor, style.FontSize, style.LineHeight),
                HorizontalTextAlignment = style.HorizontalTextAlignment,
                VerticalTextAlignment   = style.VerticalTextAlignment,
            };

            AttachLinks(label);
            stack.Children.Add(label);
        }
Exemple #27
0
        protected override void RenderParagraph(ParagraphBlock element, IRenderContext context)
        {
            // Adding new paragraphs to the root of the xml document
            var doc       = context.Parent as XDocument;
            var paragraph = new XElement("p");

            doc.Root.Add(paragraph);

            // Render the paragraph's children
            RenderInlineChildren(element.Inlines, new RenderContext()
            {
                Parent = paragraph
            });
        }
        private static void Walk(MarkdownObject markdownObject)
        {
            var links = markdownObject
                        .Descendants()
                        .Where(o => o is ParagraphBlock)
                        .Cast <ParagraphBlock>();

            var p = new ParagraphBlock();

            p.Inline = new ContainerInline();

            //p.Inline.AppendChild(new Url)

            int y0 = 2;
        }
Exemple #29
0
        private static void Undo(BlockProcessor processor, GridTableState tableState, Table gridTable)
        {
            var parser = processor.Parsers.FindExact <ParagraphBlockParser>();
            // Discard the grid table
            var parent = gridTable.Parent;

            processor.Discard(gridTable);
            var paragraphBlock = new ParagraphBlock(parser)
            {
                Lines = tableState.Lines,
            };

            parent.Add(paragraphBlock);
            processor.Open(paragraphBlock);
        }
Exemple #30
0
        public void WriteBlock_OnlyWritesChildrenIfEnableHtmlForBlockIsFalse()
        {
            // Arrange
            // Dummy title part
            const string dummyTitle = "dummyTitle";
            var          dummyTitleContainerInline = new ContainerInline();

            dummyTitleContainerInline.AppendChild(new LiteralInline(dummyTitle));
            var dummyTitlePartBlock = new PlainLeafBlock(null);

            dummyTitlePartBlock.Inline = dummyTitleContainerInline;
            // Dummy content part
            const string dummyContent = "dummyContent";
            var          dummyContentContainerInline = new ContainerInline();

            dummyContentContainerInline.AppendChild(new LiteralInline(dummyContent));
            var dummyContentParagraphBlock = new ParagraphBlock()
            {
                Inline = dummyContentContainerInline
            };
            var dummyContentPartBlock = new PlainContainerBlock(null);

            dummyContentPartBlock.Add(dummyContentParagraphBlock);
            // Dummy footnote part
            const string dummyFootnote = "dummyFootnote";
            var          dummyFootnoteContainerInline = new ContainerInline();

            dummyFootnoteContainerInline.AppendChild(new LiteralInline(dummyFootnote));
            var dummyFootnotePartBlock = new PlainLeafBlock(null);

            dummyFootnotePartBlock.Inline = dummyFootnoteContainerInline;
            FlexiCardsBlock dummyFlexiCardsBlock = CreateFlexiCardsBlock(children: new List <FlexiCardBlock> {
                CreateFlexiCardBlock(titlePart: dummyTitlePartBlock, contentPart: dummyContentPartBlock, footnotePart: dummyFootnotePartBlock)
            });
            var dummyStringWriter = new StringWriter();
            var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter)
            {
                EnableHtmlForBlock = false
            };
            ExposedFlexiCardsBlockRenderer testSubject = CreateExposedFlexiCardsBlockRenderer();

            // Act
            testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiCardsBlock);
            string result = dummyStringWriter.ToString();

            // Assert
            Assert.Equal($"{dummyTitle}\n{dummyContent}\n{dummyFootnote}\n", result, ignoreLineEndingDifferences: true);
        }