protected override void Write(XamlMarkdownWriter renderer, LinkInline link)
{
var url = link.GetDynamicUrl != null?link.GetDynamicUrl() ?? link.Url : link.Url;
if (link.IsImage)
{
if (!Uri.IsWellFormedUriString(url, UriKind.RelativeOrAbsolute))
{
url = "#";
}
renderer.WriteStartObject(typeof(Image));
renderer.WriteResourceMember(null, MarkdownXamlStyle.Image);
if (!String.IsNullOrEmpty(link.Title))
{
renderer.WriteMember(ToolTipService.ToolTipProperty, link.Title);
}
renderer.WriteMember(Image.SourceProperty, new Uri(url, UriKind.RelativeOrAbsolute));
renderer.WriteEndObject();
}
else
{
WriteStartHyperlink(renderer, url, link.Title);
renderer.WriteItems(link);
WriteEndHyperlink(renderer);
}
} // proc Write
protected override void Write(XamlMarkdownWriter renderer, LiteralInline obj)
{
if (obj.Content.IsEmpty)
{
return;
}
renderer.WriteText(ref obj.Content);
} // proc Write
protected override void Write(XamlMarkdownWriter renderer, CodeInline code)
{
renderer.WriteStartObject(typeof(Span));
renderer.WriteResourceMember(null, MarkdownXamlStyle.Code);
renderer.WriteStartItems(nameof(Span.Inlines), true);
renderer.WriteText(code.Content);
renderer.WriteEndItems();
renderer.WriteEndObject();
} // proc Write
/// <summary></summary>
/// <param name="renderer"></param>
/// <param name="taskList"></param>
protected override void Write(XamlMarkdownWriter renderer, TaskList taskList)
{
//var checkBox = new CheckBox
//{
// IsEnabled = false,
// IsChecked = taskList.Checked,
//};
//checkBox.SetResourceReference(FrameworkContentElement.StyleProperty, Styles.TaskListStyleKey);
//renderer.WriteInline(new InlineUIContainer(checkBox));
} // proc Write
protected override void Write(XamlMarkdownWriter renderer, LineBreakInline obj)
{
if (obj.IsHard)
{
renderer.WriteLineBreak();
}
else // Soft line break.
{
renderer.WriteText(" ");
}
} // proc Write
protected override void Write(XamlMarkdownWriter renderer, HtmlEntityInline obj)
{
var txt = obj.Transcoded.Text.Substring(obj.Transcoded.Start, obj.Transcoded.Length);
using (var xaml = new XamlXmlReader(new StringReader(txt), new XamlXmlReaderSettings()
{
}))
{
while (xaml.Read())
{
switch (xaml.NodeType)
{
case XamlNodeType.NamespaceDeclaration:
renderer.WriteNamespace(xaml.Namespace);
break;
case XamlNodeType.StartObject:
renderer.WriteStartObject(xaml.Type);
break;
case XamlNodeType.GetObject:
renderer.WriteGetObject();
break;
case XamlNodeType.EndObject:
renderer.WriteEndObject();
break;
case XamlNodeType.StartMember:
renderer.WriteStartMember(xaml.Member);
break;
case XamlNodeType.EndMember:
renderer.WriteEndMember();
break;
case XamlNodeType.Value:
if (xaml.Value is string text)
{
renderer.WriteValue(text);
}
else
{
renderer.WriteValue(xaml.Value.ToString()); // todo: use xaml to text converter
}
break;
default:
throw new InvalidOperationException();
}
}
}
} // proc Write
} // proc WriteSpan
protected override void Write(XamlMarkdownWriter renderer, EmphasisInline span)
{
if (WriteSpan(renderer, span))
{
renderer.WriteItems(span);
renderer.WriteEndObject();
}
else
{
renderer.WriteChildren(span);
}
} // proc Write
protected override void Write(XamlMarkdownWriter renderer, AutolinkInline link)
{
var url = link.Url;
var title = url;
if (link.IsEmail)
{
url = "mailto:" + url;
}
LinkInlineRenderer.WriteStartHyperlink(renderer, url, title);
renderer.WriteText(title);
LinkInlineRenderer.WriteEndHyperlink(renderer);
} // proc Write
internal static void WriteStartHyperlink(XamlMarkdownWriter renderer, string url, string linkTitle)
{
// check for valid url
if (!url.StartsWith("#") &&
!Uri.IsWellFormedUriString(url, UriKind.RelativeOrAbsolute))
{
url = "#";
}
renderer.WriteStartObject(typeof(Hyperlink));
renderer.WriteResourceMember(null, MarkdownXaml.HyperlinkStyleKey);
//renderer.WriteMember(Hyperlink.CommandProperty, Commands.Hyperlink);
//renderer.WriteMember(Hyperlink.CommandParameterProperty, url);
renderer.WriteMember(Hyperlink.NavigateUriProperty, new Uri(url, UriKind.RelativeOrAbsolute));
renderer.WriteMember(FrameworkContentElement.ToolTipProperty, String.IsNullOrEmpty(linkTitle) ? url : linkTitle);
} // proc WriteStartHyperlink
} // func ToXaml
/// <summary>Converts a Markdown string to XAML and output to the specified writer.</summary>
/// <param name="markdown">A Markdown text.</param>
/// <param name="writer">The destination <see cref="TextWriter"/> that will receive the result of the conversion.</param>
/// <param name="pipeline">The pipeline used for the conversion.</param>
public static object ToXaml(string markdown, XamlWriter writer, MarkdownPipeline pipeline = null)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
pipeline = pipeline ?? new MarkdownPipelineBuilder().Build();
var renderer = new XamlMarkdownWriter(writer);
pipeline.Setup(renderer);
var document = Markdown.Parse(markdown, pipeline);
return(renderer.Render(document));
} // proc ToXaml
private static bool WriteSpan(XamlMarkdownWriter renderer, EmphasisInline span)
{
switch (span.DelimiterChar)
{
case '*' when span.DelimiterCount == 2: // bold
case '_' when span.DelimiterCount == 2: // bold
renderer.WriteStartObject(typeof(Bold));
return(true);
case '*': // italic
case '_': // italic
renderer.WriteStartObject(typeof(Italic));
return(true);
case '~': // strike through
renderer.WriteStartObject(typeof(Span));
renderer.WriteResourceMember(null, MarkdownXamlStyle.StrikeThrough);
return(true);
case '^': // superscript, subscript
renderer.WriteStartObject(typeof(Span));
if (span.DelimiterCount == 2)
{
renderer.WriteResourceMember(null, MarkdownXamlStyle.Superscript);
}
else
{
renderer.WriteResourceMember(null, MarkdownXamlStyle.Subscript);
}
return(true);
case '+': // underline
renderer.WriteStartObject(typeof(Span));
renderer.WriteResourceMember(null, MarkdownXamlStyle.Inserted);
return(true);
case '=': // Marked
renderer.WriteStartObject(typeof(Span));
renderer.WriteResourceMember(null, MarkdownXamlStyle.Marked);
return(true);
default:
return(false);
}
} // proc WriteSpan
protected override void Write(XamlMarkdownWriter renderer, LinkInline link)
{
var url = link.GetDynamicUrl != null?link.GetDynamicUrl() ?? link.Url : link.Url;
if (link.IsImage)
{
if (!Uri.IsWellFormedUriString(url, UriKind.RelativeOrAbsolute))
{
url = "#";
}
renderer.WriteStartObject(typeof(Image));
renderer.WriteResourceMember(null, MarkdownXamlStyle.Image);
if (!String.IsNullOrEmpty(link.Title))
{
renderer.WriteMember(ToolTipService.ToolTipProperty, link.Title);
}
renderer.WriteMember(Image.SourceProperty, renderer.GetUri(new Uri(url, UriKind.RelativeOrAbsolute), false));
var attr = link.TryGetAttributes();
if (attr.TryGetPropertyInt32("width", out var width))
{
renderer.WriteMember(FrameworkElement.WidthProperty, width);
}
if (attr.TryGetPropertyInt32("height", out var height))
{
renderer.WriteMember(FrameworkElement.HeightProperty, height);
}
renderer.WriteEndObject();
}
else
{
WriteStartHyperlink(renderer, url, link.Title);
renderer.WriteItems(link);
WriteEndHyperlink(renderer);
}
} // proc Write
protected override void Write(XamlMarkdownWriter renderer, DelimiterInline obj)
{
renderer.WriteText(obj.ToLiteral());
renderer.WriteChildren(obj);
} // proc Write
internal static void WriteEndHyperlink(XamlMarkdownWriter renderer) => renderer.WriteEndObject();
protected override void Write(XamlMarkdownWriter renderer, MdTable table)
{
renderer.WriteStartObject(typeof(WpfTable));
renderer.WriteResourceMember(null, MarkdownXamlStyle.Table);
var t = new WpfTable();
renderer.WriteStartItems(nameof(WpfTable.Columns));
foreach (var col in table.ColumnDefinitions)
{
renderer.WriteStartObject(typeof(WpfTableColumn));
renderer.WriteMember(nameof(WpfTableColumn.Width),
(col?.Width ?? 0) != 0
? new GridLength(col.Width, GridUnitType.Star)
: GridLength.Auto
);
renderer.WriteEndObject();
}
renderer.WriteEndItems();
renderer.WriteStartItems(nameof(WpfTable.RowGroups));
renderer.WriteStartObject(typeof(WpfTableRowGroup));
renderer.WriteStartItems(nameof(WpfTableRowGroup.Rows));
foreach (var c in table)
{
var row = (MdTableRow)c;
renderer.WriteStartObject(typeof(WpfTableRow));
if (row.IsHeader)
{
renderer.WriteResourceMember(null, MarkdownXamlStyle.TableHeader);
}
renderer.WriteStartItems(nameof(WpfTableRow.Cells));
for (var i = 0; i < row.Count; i++)
{
var cell = (MdTableCell)row[i];
renderer.WriteStartObject(typeof(WpfTableCell));
renderer.WriteResourceMember(null, MarkdownXamlStyle.TableCell);
if (cell.ColumnSpan > 1)
{
renderer.WriteMember(nameof(WpfTableCell.ColumnSpan), cell.ColumnSpan);
}
if (cell.RowSpan > 1)
{
renderer.WriteMember(nameof(WpfTableCell.RowSpan), cell.RowSpan);
}
var columnIndex = cell.ColumnIndex < 0 || cell.ColumnIndex >= table.ColumnDefinitions.Count ? i : cell.ColumnIndex;
columnIndex = columnIndex >= table.ColumnDefinitions.Count ? table.ColumnDefinitions.Count - 1 : columnIndex;
var alignment = table.ColumnDefinitions[columnIndex].Alignment;
if (alignment.HasValue)
{
switch (alignment)
{
case TableColumnAlign.Center:
renderer.WriteMember(nameof(WpfTableCell.TextAlignment), TextAlignment.Center);
break;
case TableColumnAlign.Right:
renderer.WriteMember(nameof(WpfTableCell.TextAlignment), TextAlignment.Right);
break;
case TableColumnAlign.Left:
renderer.WriteMember(nameof(WpfTableCell.TextAlignment), TextAlignment.Left);
break;
}
}
renderer.WriteItems(cell);
renderer.WriteEndObject();
}
renderer.WriteEndItems();
renderer.WriteEndObject();
}
renderer.WriteEndItems();
renderer.WriteEndObject();
renderer.WriteEndItems();
renderer.WriteEndObject();
} // proc Write
