/// <summary>
/// Renders a superscript element.
/// </summary>
/// <param name="element"> The parsed inline element to render. </param>
/// <param name="context"> Persistent state. </param>
protected override void RenderSuperscriptRun(SuperscriptTextInline element, IRenderContext context)
{
var localContext = context as InlineRenderContext;
var parent = localContext?.Parent as TextElement;
if (localContext == null && parent == null)
{
throw new RenderContextIncorrectException();
}
// Le <sigh>, InlineUIContainers are not allowed within hyperlinks.
if (localContext.WithinHyperlink)
{
RenderInlineChildren(element.Inlines, context);
return;
}
var paragraph = new Paragraph
{
FontSize = parent.FontSize * 0.8,
FontFamily = parent.FontFamily,
FontStyle = parent.FontStyle,
FontWeight = parent.FontWeight
};
var childContext = new InlineRenderContext(paragraph.Inlines, context)
{
Parent = paragraph
};
RenderInlineChildren(element.Inlines, childContext);
var richTextBlock = CreateOrReuseRichTextBlock(new UIElementCollectionRenderContext(null, context));
richTextBlock.Blocks.Add(paragraph);
var border = new Border
{
Padding = new Thickness(0, 0, 0, paragraph.FontSize * 0.2),
Child = richTextBlock
};
var inlineUIContainer = new InlineUIContainer
{
Child = border
};
// Add it to the current inlines
localContext.InlineCollection.Add(inlineUIContainer);
}
static Common()
{
BoldItalicTextInline.AddTripChars(_triggerList);
BoldTextInline.AddTripChars(_triggerList);
ItalicTextInline.AddTripChars(_triggerList);
MarkdownLinkInline.AddTripChars(_triggerList);
HyperlinkInline.AddTripChars(_triggerList);
CommentInline.AddTripChars(_triggerList);
StrikethroughTextInline.AddTripChars(_triggerList);
SuperscriptTextInline.AddTripChars(_triggerList);
SubscriptTextInline.AddTripChars(_triggerList);
CodeInline.AddTripChars(_triggerList);
ImageInline.AddTripChars(_triggerList);
EmojiInline.AddTripChars(_triggerList);
LinkAnchorInline.AddTripChars(_triggerList);
// Create an array of characters to search against using IndexOfAny.
_tripCharacters = _triggerList.Select(trigger => trigger.FirstChar).Distinct().ToArray();
}
/// <summary>
/// Renders a link element
/// </summary>
/// <param name="element"> The parsed inline element to render. </param>
/// <param name="context"> Persistent state. </param>
protected override void RenderMarkdownLink(MarkdownLinkInline element, IRenderContext context)
{
var localContext = context as InlineRenderContext;
if (localContext == null)
{
throw new RenderContextIncorrectException();
}
// HACK: Superscript is not allowed within a hyperlink. But if we switch it around, so
// that the superscript is outside the hyperlink, then it will render correctly.
// This assumes that the entire hyperlink is to be rendered as superscript.
if (AllTextIsSuperscript(element) == false)
{
// Regular ol' hyperlink.
var link = new Hyperlink();
// Register the link
LinkRegister.RegisterNewHyperLink(link, element.Url);
// Remove superscripts.
RemoveSuperscriptRuns(element, insertCaret: true);
// Render the children into the link inline.
var childContext = new InlineRenderContext(link.Inlines, context)
{
Parent = link,
WithinHyperlink = true
};
if (localContext.OverrideForeground)
{
link.Foreground = localContext.Foreground;
}
else if (LinkForeground != null)
{
link.Foreground = LinkForeground;
}
RenderInlineChildren(element.Inlines, childContext);
context.TrimLeadingWhitespace = childContext.TrimLeadingWhitespace;
ToolTipService.SetToolTip(link, element.Tooltip ?? element.Url);
// Add it to the current inlines
localContext.InlineCollection.Add(link);
}
else
{
// THE HACK IS ON!
// Create a fake superscript element.
var fakeSuperscript = new SuperscriptTextInline
{
Inlines = new List <MarkdownInline>
{
element
}
};
// Remove superscripts.
RemoveSuperscriptRuns(element, insertCaret: false);
// Now render it.
RenderSuperscriptRun(fakeSuperscript, context);
}
}
/// <summary>
/// Attempts to parse a superscript text span.
/// </summary>
/// <param name="markdown"> The markdown text. </param>
/// <param name="start"> The location to start parsing. </param>
/// <param name="maxEnd"> The location to stop parsing. </param>
/// <returns> A parsed superscript text span, or <c>null</c> if this is not a superscript text span. </returns>
internal static InlineParseResult Parse(string markdown, int start, int maxEnd)
{
// Check the first character.
bool isHTMLSequence = false;
if (start == maxEnd || (markdown[start] != '^' && markdown[start] != '<'))
{
return(null);
}
if (markdown[start] != '^')
{
if (maxEnd - start < 5)
{
return(null);
}
else if (markdown.Substring(start, 5) != "<sup>")
{
return(null);
}
else
{
isHTMLSequence = true;
}
}
if (isHTMLSequence)
{
int innerStart = start + 5;
int innerEnd, end;
innerEnd = Common.IndexOf(markdown, "</sup>", innerStart, maxEnd);
if (innerEnd == -1)
{
return(null);
}
if (innerEnd == innerStart)
{
return(null);
}
if (ParseHelpers.IsMarkdownWhiteSpace(markdown[innerStart]) || ParseHelpers.IsMarkdownWhiteSpace(markdown[innerEnd - 1]))
{
return(null);
}
// We found something!
end = innerEnd + 6;
var result = new SuperscriptTextInline
{
Inlines = Common.ParseInlineChildren(markdown, innerStart, innerEnd)
};
return(new InlineParseResult(result, start, end));
}
else
{
// The content might be enclosed in parentheses.
int innerStart = start + 1;
int innerEnd, end;
if (innerStart < maxEnd && markdown[innerStart] == '(')
{
// Find the end parenthesis.
innerStart++;
innerEnd = Common.IndexOf(markdown, ')', innerStart, maxEnd);
if (innerEnd == -1)
{
return(null);
}
end = innerEnd + 1;
}
else
{
// Search for the next whitespace character.
innerEnd = Common.FindNextWhiteSpace(markdown, innerStart, maxEnd, ifNotFoundReturnLength: true);
if (innerEnd == innerStart)
{
// No match if the character after the caret is a space.
return(null);
}
end = innerEnd;
}
// We found something!
var result = new SuperscriptTextInline
{
Inlines = Common.ParseInlineChildren(markdown, innerStart, innerEnd)
};
return(new InlineParseResult(result, start, end));
}
}
/// <summary>
/// Finds the next inline element by matching trip chars and verifying the match.
/// </summary>
/// <param name="markdown"> The markdown text to parse. </param>
/// <param name="start"> The position to start parsing. </param>
/// <param name="end"> The position to stop parsing. </param>
/// <param name="ignoreLinks"> Indicates whether to parse links. </param>
/// <returns>Returns the next element</returns>
private static InlineParseResult FindNextInlineElement(string markdown, int start, int end, bool ignoreLinks)
{
// Search for the next inline sequence.
for (int pos = start; pos < end; pos++)
{
// IndexOfAny should be the fastest way to skip characters we don't care about.
pos = markdown.IndexOfAny(_tripCharacters, pos, end - pos);
if (pos < 0)
{
break;
}
// Find the trigger(s) that matched.
char currentChar = markdown[pos];
foreach (InlineTripCharHelper currentTripChar in _triggerList)
{
// Check if our current char matches the suffix char.
if (currentChar == currentTripChar.FirstChar)
{
// Don't match if the previous character was a backslash.
if (pos > start && markdown[pos - 1] == '\\')
{
continue;
}
// If we are here we have a possible match. Call into the inline class to verify.
InlineParseResult parseResult = null;
switch (currentTripChar.Method)
{
case InlineParseMethod.BoldItalic:
parseResult = BoldItalicTextInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Comment:
parseResult = CommentInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.LinkReference:
parseResult = LinkAnchorInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Bold:
parseResult = BoldTextInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Italic:
parseResult = ItalicTextInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.MarkdownLink:
if (!ignoreLinks)
{
parseResult = MarkdownLinkInline.Parse(markdown, pos, end);
}
break;
case InlineParseMethod.AngleBracketLink:
if (!ignoreLinks)
{
parseResult = HyperlinkInline.ParseAngleBracketLink(markdown, pos, end);
}
break;
case InlineParseMethod.Url:
if (!ignoreLinks)
{
parseResult = HyperlinkInline.ParseUrl(markdown, pos, end);
}
break;
case InlineParseMethod.RedditLink:
if (!ignoreLinks)
{
parseResult = HyperlinkInline.ParseRedditLink(markdown, pos, end);
}
break;
case InlineParseMethod.PartialLink:
if (!ignoreLinks)
{
parseResult = HyperlinkInline.ParsePartialLink(markdown, pos, end);
}
break;
case InlineParseMethod.Email:
if (!ignoreLinks)
{
parseResult = HyperlinkInline.ParseEmailAddress(markdown, start, pos, end);
}
break;
case InlineParseMethod.Strikethrough:
parseResult = StrikethroughTextInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Superscript:
parseResult = SuperscriptTextInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Subscript:
parseResult = SubscriptTextInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Code:
parseResult = CodeInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Image:
parseResult = ImageInline.Parse(markdown, pos, end);
break;
case InlineParseMethod.Emoji:
parseResult = EmojiInline.Parse(markdown, pos, end);
break;
}
if (parseResult != null)
{
return(parseResult);
}
}
}
}
// If we didn't find any elements we have a normal text block.
// Let us consume the entire range.
return(new InlineParseResult(TextRunInline.Parse(markdown, start, end), start, end));
}
