/// <summary>
/// Creates a class report.
/// </summary>
/// <param name="class">The class.</param>
/// <param name="fileAnalyses">The file analyses that correspond to the class.</param>
public override void CreateClassReport(Class @class, IEnumerable<FileAnalysis> fileAnalyses)
{
using (var renderer = new HtmlRenderer(false, this.javaScriptContent))
{
this.CreateClassReport(renderer, @class, fileAnalyses);
}
}
public void SetupRendererAndRender()
{
var stringWriter = new StringWriter();
var htmlRenderer = new HtmlRenderer(stringWriter);
htmlRenderer.Render();
output = stringWriter.ToString();
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(true))
{
this.CreateSummaryReport(renderer, summaryResult);
}
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(false, this.javaScriptContent))
{
this.CreateSummaryReport(renderer, summaryResult);
}
}
public ReportForm()
{
InitializeComponent();
DataCollection = new List<List<Object>>();
DataCollection2 = new List<List<Object>>();
Reports = new Reports();
SimpleXmlParser = null;
HtmlRenderer = new HtmlRenderer(Reports, "Css", "JsLib");
}
public void LangCssClassAdded() {
var underlyingRendererMock = new Mock<CodeBlockRenderer>();
underlyingRendererMock
.Setup(x => x.Write(It.IsAny<HtmlRenderer>(), It.IsAny<CodeBlock>()));
var renderer = new SyntaxHighlightingCodeBlockRenderer(underlyingRendererMock.Object);
var builder = new StringBuilder();
var markdownRenderer = new HtmlRenderer(new StringWriter(builder));
var codeBlock = GetFencedCodeBlock();
renderer.Write(markdownRenderer, codeBlock);
Assert.Contains("lang-csharp", builder.ToString());
}
public void UnderlyingRendererCalledIfNotFencedCodeBlock() {
var underlyingRendererMock = new Mock<CodeBlockRenderer>();
underlyingRendererMock
.Setup(x => x.Write(It.IsAny<HtmlRenderer>(), It.IsAny<CodeBlock>()))
.Verifiable("Write was not called on the underlying renderer mock.");
var renderer = new SyntaxHighlightingCodeBlockRenderer(underlyingRendererMock.Object);
var writer = new StringWriter();
var markdownRenderer = new HtmlRenderer(writer);
var codeBlock = new CodeBlock(new IndentedCodeBlockParser());
renderer.Write(markdownRenderer, codeBlock);
underlyingRendererMock.VerifyAll();
}
public void CanParseValidStoryFile()
{
var parser = new FicdownParser();
var storyText = Encoding.UTF8.GetString(Resources.CloakOfDarkness);
var story = parser.ParseStory(storyText);
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "itest_output");
if (!Directory.Exists(path)) Directory.CreateDirectory(path);
foreach (var file in Directory.GetFiles(path))
{
File.Delete(file);
}
var rend = new HtmlRenderer();
rend.Render(story, path, true);
}
public static void Main()
{
var dsPrest = new DSPrestation();
var prestNbUniteSum = new List<Int32> {0, 0};
for (int index = 0; index < 10; index++)
{
var rn = dsPrest.Tables[0].NewRow() as DSPrestation.TableRow;
if (rn == null) continue;
rn.prest_pk = new Random().Next(99999);
rn.prest_date = DateTime.Now.AddDays(index + 1);
rn.prest_description = "blabla" + index;
rn.prest_nb_unite = index + 1;
rn.prest_taux = Convert.ToDecimal((index + 1)*1.13);
rn.prest_user_fk = index%2 == 0 ? 10 : 20;
rn.user_nom = index%2 == 0 ? "Alain" : "Bernard";
rn.user_initiales = index%2 == 0 ? "AF" : "BD";
if (rn.user_initiales.Equals("AF"))
prestNbUniteSum[0] += rn.prest_nb_unite;
else
prestNbUniteSum[1] += rn.prest_nb_unite;
dsPrest.Tables[0].Rows.Add(rn);
}
for (int index2 = 0; index2 < 2; index2++)
{
var rn = dsPrest.Tables[1].NewRow() as DSPrestation.ChartTestingRow;
if (rn == null) continue;
rn.user_initiales_sum = index2%2 == 0 ? "AF" : "BD";
rn.prest_nb_unite_sum = prestNbUniteSum[index2];
dsPrest.Tables[1].Rows.Add(rn);
}
//var dsPrest2 = DsUpdater.Update(dsPrest, new List<String> { "prest_type_fk" });
SimpleXmlUpdater.Update(dsPrest, String.Format("Xml{0}Reports.xml", Path.DirectorySeparatorChar),
"Prestation de test");
Report r = DsConverter.Convert(dsPrest); //, "user_initiales");
var sxp = new SimpleXmlParser(String.Format("Xml{0}Reports.xml", Path.DirectorySeparatorChar),
String.Format("Schemas{0}Reports.xsd", Path.DirectorySeparatorChar), r);
sxp.Parse();
var hg = new HtmlRenderer(r, "Css", "JsLib",
String.Format("Translations{0}Reports_fr_FR.pyt", Path.DirectorySeparatorChar),
"Htmls", "Mhtmls");
hg.Render();
Process.Start(String.Format("{0}{1}Htmls{2}{3}.html", Directory.GetCurrentDirectory(),
Path.DirectorySeparatorChar, Path.DirectorySeparatorChar, r.Name));
/*MhtConverter.Convert(String.Format("{0}{1}{2}.html", Directory.GetCurrentDirectory(),
Path.DirectorySeparatorChar, r.Name),
String.Format("{0}{1}{2}.mht", Directory.GetCurrentDirectory(),
Path.DirectorySeparatorChar, r.Name));*/
}
protected override void Write(HtmlRenderer renderer, QuoteBlock obj)
{
renderer.EnsureLine();
if (renderer.EnableHtmlForBlock)
{
renderer.Write("<blockquote").WriteAttributes(obj).WriteLine(">");
}
var savedImplicitParagraph = renderer.ImplicitParagraph;
renderer.ImplicitParagraph = false;
renderer.WriteChildren(obj);
renderer.ImplicitParagraph = savedImplicitParagraph;
if (renderer.EnableHtmlForBlock)
{
renderer.WriteLine("</blockquote>");
}
renderer.EnsureLine();
}
public void Setup_Renderers_InsertsExtensionBlockRendererIntoHtmlRendererIfItDoesNotContainABlockRendererOfTheSameType()
{
// Arrange
MarkdownPipeline dummyMarkdownPipeline = new MarkdownPipelineBuilder().Build();
Mock <BlockRenderer <Block> > dummyBlockRenderer = _mockRepository.Create <BlockRenderer <Block> >();
var dummyHtmlRenderer = new HtmlRenderer(new StringWriter());
Mock <BlockExtension <Block> > mockTestSubject = CreateMockBlockExtension(blockRenderer: dummyBlockRenderer.Object);
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("SetupRenderers", dummyMarkdownPipeline, dummyHtmlRenderer);
// Act
mockTestSubject.Object.Setup(dummyMarkdownPipeline, dummyHtmlRenderer);
// Assert
_mockRepository.VerifyAll();
Assert.Contains(dummyBlockRenderer.Object, dummyHtmlRenderer.ObjectRenderers);
}
public void WriteBlock_WritesNothingIfEnableHtmlForBlockIsFalse()
{
// Arrange
FlexiVideoBlock dummyFlexiVideoBlock = CreateFlexiVideoBlock();
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter)
{
EnableHtmlForBlock = false
};
ExposedFlexiVideoBlockRenderer testSubject = CreateExposedFlexiVideoBlockRenderer();
// Act
testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiVideoBlock);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal(string.Empty, result, ignoreLineEndingDifferences: true);
}
private void WriteNote(HtmlRenderer renderer, QuoteSectionNoteBlock obj)
{
string noteHeading = string.Empty;
if (_tokens?.TryGetValue(obj.NoteTypeString.ToLower(), out noteHeading) != true)
{
noteHeading = $"<h5>{obj.NoteTypeString.ToUpper()}</h5>";
}
;
renderer.Write("<div").Write($" class=\"{obj.NoteTypeString.ToUpper()}\"").WriteAttributes(obj).WriteLine(">");
var savedImplicitParagraph = renderer.ImplicitParagraph;
renderer.ImplicitParagraph = false;
renderer.WriteLine(noteHeading);
renderer.WriteChildren(obj);
renderer.ImplicitParagraph = savedImplicitParagraph;
renderer.WriteLine("</div>");
}
protected override void Write(HtmlRenderer renderer, LineBreakInline obj)
{
if (renderer.EnableHtmlForInline)
{
if (obj.IsHard || RenderAsHardlineBreak)
{
renderer.WriteLine("<br />");
}
else
{
renderer.WriteLine();
}
}
else
{
renderer.Write(" ");
}
}
protected override void Write(HtmlRenderer renderer, TaskList obj)
{
if (renderer.EnableHtmlForInline)
{
renderer.Write("<input").WriteAttributes(obj).Write(" disabled=\"disabled\" type=\"checkbox\"");
if (obj.Checked)
{
renderer.Write(" checked=\"checked\"");
}
renderer.Write(" />");
}
else
{
renderer.Write('[');
renderer.Write(obj.Checked ? "x" : " ");
renderer.Write(']');
}
}
public void Setup_Renderers_DoesNothingIfBlockRendererIsNull()
{
// Arrange
MarkdownPipeline dummyMarkdownPipeline = new MarkdownPipelineBuilder().Build();
var dummyHtmlRenderer = new HtmlRenderer(new StringWriter());
Mock <BlockExtension <Block> > mockTestSubject = CreateMockBlockExtension();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("SetupRenderers", dummyMarkdownPipeline, dummyHtmlRenderer);
int expectedNumObjectRenderers = dummyHtmlRenderer.ObjectRenderers.Count;
// Act
mockTestSubject.Object.Setup(dummyMarkdownPipeline, dummyHtmlRenderer);
// Assert
_mockRepository.VerifyAll();
Assert.Equal(expectedNumObjectRenderers, dummyHtmlRenderer.ObjectRenderers.Count);
}
public void Write_DoesNotInterfereWithBlockExceptionsWithBlockContext()
{
// Arrange
var dummyRenderer = new HtmlRenderer(new StringWriter());
Mock <Block> dummyBlock = _mockRepository.Create <Block>(null);
var dummyBlockException = new BlockException(dummyBlock.Object);
Mock <BlockRenderer <Block> > mockTestSubject = _mockRepository.Create <BlockRenderer <Block> >();
mockTestSubject.CallBase = true;
mockTestSubject.Protected().Setup("WriteBlock", dummyRenderer, dummyBlock.Object).Throws(dummyBlockException);
// Act and assert
BlockException result = Assert.Throws <BlockException>(() => mockTestSubject.Object.Write(dummyRenderer, dummyBlock.Object));
_mockRepository.VerifyAll();
Assert.Same(dummyBlockException, result);
Assert.Null(result.InnerException);
}
public void WriteTab_WritesUnselectedTabIfIndexIsLargerThan0()
{
// Arrange
FlexiTabBlock dummyFlexiTabBlock = CreateFlexiTabBlock();
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter);
FlexiTabsBlockRenderer testSubject = CreateFlexiTabsBlockRenderer();
// Act
testSubject.WriteTab(dummyHtmlRenderer, dummyFlexiTabBlock, null, 1);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal(@"<button class=""__tab"" role=""tab"" aria-selected=""false"" tabindex=""-1""></button>
",
result,
ignoreLineEndingDifferences: true);
}
public static void Run()
{
// ExStart:ManipulateCanvas
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_Data();
// Create an empty document
using (HTMLDocument document = new HTMLDocument())
{
// Create a Canvas element
var canvas = (HTMLCanvasElement)document.CreateElement("canvas");
// Set the canvas size
canvas.Width = 300;
canvas.Height = 150;
// Append created element to the document
document.Body.AppendChild(canvas);
// Initialize a canvas 2D context
var context = (ICanvasRenderingContext2D)canvas.GetContext("2d");
// Prepare a gradient brush
var gradient = context.CreateLinearGradient(0, 0, canvas.Width, 0);
gradient.AddColorStop(0, "magenta");
gradient.AddColorStop(0.5, "blue");
gradient.AddColorStop(1.0, "red");
// Set the previously prepared brush to the fill and stroke properties
context.FillStyle = gradient;
context.StrokeStyle = gradient;
// Fill a rectange
context.FillRect(0, 95, 300, 20);
// Write a text
context.FillText("Hello World!", 10, 90, 500);
// Create an instance of HTML renderer and XPS output device
using (var renderer = new HtmlRenderer())
using (var device = new XpsDevice(dataDir + "canvas.xps"))
{
// Render the document to the specified device
renderer.Render(device, document);
}
}
// ExEnd:ManipulateCanvas
}
private void Convert(FileInfo mdFile)
{
var name = mdFile.Directory.Name;
var htmlDir = Path.Combine(_config.OutputDirectory, name);
if (!Directory.Exists(htmlDir))
{
Directory.CreateDirectory(htmlDir);
}
using (var reader = mdFile.OpenText())
{
var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().UseYamlFrontMatter().Build();
var doc = Markdown.Parse(reader.ReadToEnd(), pipeline);
// Actual HTML conversion now?
var htmlFile = Path.ChangeExtension(Path.Combine(htmlDir, name), "html");
var featuredImage = string.Empty;
_log.Info($"Processing '{htmlFile}'");
foreach (var l in doc.Descendants().OfType <LinkInline>().Where(l => l.IsImage))
{
var img = new FileInfo(Path.Combine(mdFile.DirectoryName, l.Url));
if (img.Exists)
{
if (_config.InputDirectory != _config.OutputDirectory)
{
img.CopyTo(Path.Combine(htmlDir, l.Url), true);
}
l.Url = _config.ImagePrefix + name + '/' + l.Url;
if (string.IsNullOrEmpty(featuredImage))
{
featuredImage = l.Url;
}
}
}
using (var writer = new StreamWriter(new FileStream(htmlFile, FileMode.Create)))
{
var renderer = new HtmlRenderer(writer);
pipeline.Setup(renderer);
renderer.Render(doc);
writer.Flush();
}
var yaml = doc.Descendants().OfType <YamlFrontMatterBlock>().FirstOrDefault();
_index.Add(name, featuredImage, yaml?.Lines.Lines.Select(l => l.ToString()));
}
}
private static async Task <string> Render(PublishFormat format, MarkdownDocument document, string newLine)
{
MarkdownPipeline pipeline;
IMarkdownRenderer renderer;
var writer = new StringWriter();
switch (format)
{
case PublishFormat.Markdown:
pipeline = new MarkdownPipelineBuilder()
.UseNormalizeCodeBlockAnnotations()
.Build();
var normalizeRenderer = new NormalizeRenderer(writer);
normalizeRenderer.Writer.NewLine = newLine;
renderer = normalizeRenderer;
break;
case PublishFormat.HTML:
pipeline = new MarkdownPipelineBuilder()
.UseCodeBlockAnnotations(inlineControls: false)
.Build();
renderer = new HtmlRenderer(writer);
break;
default:
throw new ArgumentOutOfRangeException(nameof(format), format, null);
}
pipeline.Setup(renderer);
var blocks = document
.OfType <AnnotatedCodeBlock>()
.OrderBy(c => c.Order)
.ToList();
await Task.WhenAll(blocks.Select(b => b.InitializeAsync()));
renderer.Render(document);
writer.Flush();
var rendered = writer.ToString();
return(rendered);
}
private void WriteImageLink(HtmlRenderer renderer, LinkInline link)
{
var url = link.Url;
if (SplitRenderer.OldToNewImageUris.TryGetValue(url, out var newValue))
{
url = newValue;
}
if (renderer.EnableHtmlForInline)
{
renderer.Write("<img src=\"");
renderer.WriteEscapeUrl(url);
renderer.Write("\"");
ProcessImageLinkAttributes(link);
renderer.WriteAttributes(link);
}
if (renderer.EnableHtmlForInline)
{
renderer.Write(" alt=\"");
}
var wasEnableHtmlForInline = renderer.EnableHtmlForInline;
renderer.EnableHtmlForInline = false;
renderer.WriteChildren(link);
renderer.EnableHtmlForInline = wasEnableHtmlForInline;
if (renderer.EnableHtmlForInline)
{
renderer.Write("\"");
}
if (renderer.EnableHtmlForInline && !string.IsNullOrEmpty(link.Title))
{
renderer.Write(" title=\"");
renderer.WriteEscape(link.Title);
renderer.Write("\"");
}
if (renderer.EnableHtmlForInline)
{
renderer.Write(" />");
}
}
public void WriteBlock_OnlyRendersCodeIfEnableHtmlForBlockIsFalse(string dummyCode, string expectedResult)
{
// Arrange
FlexiCodeBlock dummyFlexiCodeBlock = CreateFlexiCodeBlock(code: dummyCode);
ExposedFlexiCodeBlockRenderer testSubject = CreateExposedFlexiCodeBlockRenderer();
// Act
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter)
{
EnableHtmlForBlock = false
};
testSubject.Write(dummyHtmlRenderer, dummyFlexiCodeBlock);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal(expectedResult, result, ignoreLineEndingDifferences: true);
}
protected override void Write(HtmlRenderer renderer, CodeInline obj)
{
if (renderer.EnableHtmlForInline)
{
renderer.Write("<code").WriteAttributes(obj).Write(">");
}
if (renderer.EnableHtmlEscape)
{
renderer.WriteEscape(obj.Content);
}
else
{
renderer.Write(obj.Content);
}
if (renderer.EnableHtmlForInline)
{
renderer.Write("</code>");
}
}
public void Startup(string pathToFileIndex)
{
var loader = new HtmlLoader();
Window = loader.LoadFromFile(pathToFileIndex);
_renderer = new HtmlRenderer(Window);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
SoundPlayer = new WindowsSoundPlayer();
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
// AFPlayer
}
RunWindow();
}
public void WriteBlock_OnlyWritesAltIfEnableHtmlForBlockIsFalse()
{
// Arrange
const string dummyAlt = "dummyAlt";
FlexiPictureBlock dummyFlexiPictureBlock = CreateFlexiPictureBlock(alt: dummyAlt);
var dummyStringWriter = new StringWriter();
var dummyHtmlRenderer = new HtmlRenderer(dummyStringWriter)
{
EnableHtmlForBlock = false
};
ExposedFlexiPictureBlockRenderer testSubject = CreateExposedFlexiPictureBlockRenderer();
// Act
testSubject.ExposedWriteBlock(dummyHtmlRenderer, dummyFlexiPictureBlock);
string result = dummyStringWriter.ToString();
// Assert
Assert.Equal($"{dummyAlt}\n", result, ignoreLineEndingDifferences: true);
}
public void CanParseValidStoryFile()
{
var parser = new FicdownParser();
var storyText = Encoding.UTF8.GetString(Resources.CloakOfDarkness);
var story = parser.ParseStory(storyText);
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "itest_output");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
foreach (var file in Directory.GetFiles(path))
{
File.Delete(file);
}
var rend = new HtmlRenderer("en");
rend.Render(story, path, true);
}
private void htmlPanel1_StylesheetLoad(object sender, HtmlRenderer.Entities.HtmlStylesheetLoadEventArgs e)
{
var path = Path.GetFullPath(Path.IsPathRooted(e.Src) ? e.Src : Path.Combine(this.fileSystemWatcher1.Path, e.Src));
watchedFiles.Add(path);
var dir = Path.GetDirectoryName(path);
if (!string.IsNullOrEmpty(dir))
{
FileSystemWatcher watcher;
if (!otherFolders.TryGetValue(dir, out watcher))
{
watcher = new FileSystemWatcher(dir) {EnableRaisingEvents = true};
watcher.Changed += watcherChanged;
watcher.Created += watcherChanged;
watcher.Deleted += watcherChanged;
otherFolders.Add(dir, watcher);
}
}
}
protected override void Write(HtmlRenderer renderer, MathBlock obj)
{
var text = string.Empty; // obj.Content.Text.Substring(obj.Content.Start, obj.Content.Length);
for (var i = 0; i < obj.Lines.Count; ++i)
{
var l = obj.Lines.Lines[i];
text += l.Slice.Text.Substring(l.Slice.Start, l.Slice.Length);
}
if (string.IsNullOrEmpty(text))
{
return;
}
renderer.WriteLine("<p><span class=\"math display\">\\[");
renderer.WriteLine(text);
renderer.WriteLine("\\]</span></p>");
}
public static IMarkdownRenderer CreateRenderer(TextWriter writer, DocumentContext context)
{
var renderer = new HtmlRenderer(writer);
renderer.ObjectRenderers.Replace <LinkInlineRenderer>(
new D2LLinkInlineRenderer(context)
);
renderer.ObjectRenderers.Replace <HeadingRenderer>(
new HeadingLinkRenderer()
);
renderer.ObjectRenderers.Add(new HtmlTableRenderer());
renderer.ObjectRenderers
.Find <CodeBlockRenderer>()
.OutputAttributesOnPre = true;
return(renderer);
}
/// <summary>
/// Writes each <see cref="KeyValuePair{TKey, TValue}"/> in <paramref name="attributes"/> as " {key}=\"{value}\"".
/// </summary>
public static HtmlRenderer WriteAttributes(this HtmlRenderer htmlRenderer, ReadOnlyDictionary <string, string> attributes)
{
if (attributes == null)
{
return(htmlRenderer);
}
foreach (KeyValuePair <string, string> attribute in attributes)
{
htmlRenderer.
Write(' ').
Write(attribute.Key).
Write("=\"").
WriteEscape(attribute.Value).
Write('"');
}
return(htmlRenderer);
}
public void TestIndexOfAny()
{
var writer = new HtmlRenderer(new StringWriter());
for (int i = 0; i < 100; i++)
{
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
writer.WriteEscape(text, 0, text.Length);
}
}
public string Render(MarkdownDocument document, MarkdownContext context, MarkdownServiceParameters parameters)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
var pipeline = CreatePipeline(context, parameters);
using (var writer = new StringWriter())
{
var renderer = new HtmlRenderer(writer);
pipeline.Setup(renderer);
renderer.Render(document);
writer.Flush();
return(writer.ToString());
}
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(new Dictionary <string, string>(), true, HtmlMode.InlineCssAndJavaScript))
{
this.CreateSummaryReport(renderer, summaryResult);
}
string targetDirectory = this.CreateTargetDirectory();
string sourcePath = Path.Combine(targetDirectory, "summary.html");
if (File.Exists(sourcePath))
{
File.Copy(
sourcePath,
Path.Combine(targetDirectory, "summary.htm"),
true);
}
}
/// <summary>
/// Renders a <see cref="FlexiFigureBlock"/> as HTML.
/// </summary>
/// <param name="htmlRenderer">The renderer to write to.</param>
/// <param name="block">The <see cref="FlexiFigureBlock"/> to render.</param>
protected override void WriteBlock(HtmlRenderer htmlRenderer, FlexiFigureBlock block)
{
if (!htmlRenderer.EnableHtmlForBlock)
{
htmlRenderer.
WriteChildren(block[0] as ContainerBlock, false).
EnsureLine().
WriteLeafInline(block[1] as LeafBlock).
EnsureLine();
return;
}
ReadOnlyDictionary <string, string> attributes = block.Attributes;
string blockName = block.BlockName,
name = block.Name,
id = block.ID;
bool hasName = block.RenderName && !string.IsNullOrWhiteSpace(name);
// Root element
htmlRenderer.
Write("<figure").
Write(" class=\"").
Write(blockName).
WriteHasFeatureClass(hasName, blockName, "name").
WriteAttributeValue(attributes, "class").
Write("\"").
WriteAttribute(!string.IsNullOrWhiteSpace(id), "id", id).
WriteAttributesExcept(attributes, "class", "id").
WriteLine(">");
// Content
htmlRenderer.
WriteElementLine("div", blockName, "content", block[0] as ContainerBlock, false);
// Caption
htmlRenderer.
WriteStartTag("figcaption", blockName, "caption").
WriteElement(hasName, "span", blockName, "name", name, ". ").
WriteLeafInline(block[1] as LeafBlock).
WriteEndTagLine("figcaption").
WriteEndTagLine("figure");
}
/// <summary>
/// Renders a <see cref="FlexiCodeBlock"/> as HTML.
/// </summary>
/// <param name="htmlRenderer">The renderer to write to.</param>
/// <param name="block">The <see cref="FlexiCodeBlock"/> to render.</param>
protected override void WriteBlock(HtmlRenderer htmlRenderer, FlexiCodeBlock block)
{
if (!htmlRenderer.EnableHtmlForBlock)
{
htmlRenderer.
WriteEscape(block.Code).
WriteLine();
return;
}
if (block.RenderingMode == FlexiCodeBlockRenderingMode.Classic)
{
WriteClassic(htmlRenderer, block);
return;
}
WriteStandard(htmlRenderer, block);
}
private string CreateHtmlFromMd(string md)
{
MarkdownDocument doc = Markdown.Parse(md, pipeline);
foreach (var table in doc.Descendants <Table>())
{
foreach (TableColumnDefinition definition in table.ColumnDefinitions)
{
definition.Alignment = TableColumnAlign.Left;
}
}
var writer = new StringWriter();
var renderer = new HtmlRenderer(writer);
pipeline.Setup(renderer);
renderer.Render(doc);
return(writer.ToString());
}
public string RenderStaticHtml(MarkdownDocument document)
{
var htmlWriter = new StringWriter();
var htmlRenderer = new HtmlRenderer(htmlWriter);
MarkdownFactory.Pipeline.Setup(htmlRenderer);
using (_codeBlockRenderer.StartRendering()) {
htmlRenderer.ObjectRenderers.Insert(0, _codeBlockRenderer);
htmlRenderer.ObjectRenderers.Insert(0, _yamlRenderer);
htmlRenderer.UseNonAsciiNoEscape = true;
htmlRenderer.Render(document);
htmlWriter.Flush();
var html = htmlWriter.ToString();
return(html);
}
}
/// <summary>
/// Converts a markdown string to HTML.
/// </summary>
/// <param name="markdown">A markdown string.</param>
/// <remarks>
/// Image URIs are assumed to be names of embedded resources. These
/// images are written to disk (in temp directory).
/// </remarks>
public static string ToHtml(string markdown)
{
if (markdown == null)
{
return(null);
}
MarkdownDocument doc = MarkdownParser.Parse(markdown);
var renderer = new HtmlRenderer(new StringWriter());
renderer.BaseUrl = new Uri(Path.GetTempPath());
renderer.Render(doc);
renderer.Writer.Flush();
string html = renderer.Writer.ToString();
// Search for all image nodes, and extract matching resource file to temp directory.
return(ParseHtmlImages(html));
}
/// <summary>
/// Converts a Markdown document to HTML.
/// </summary>
/// <param name="document">A Markdown document.</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>
/// <returns>The result of the conversion</returns>
/// <exception cref="ArgumentNullException">if markdown document variable is null</exception>
public static void ToHtml(this MarkdownDocument document, TextWriter writer, MarkdownPipeline?pipeline = null)
{
if (document is null)
{
ThrowHelper.ArgumentNullException(nameof(document));
}
if (writer is null)
{
ThrowHelper.ArgumentNullException_writer();
}
pipeline ??= DefaultPipeline;
using var rentedRenderer = pipeline.RentHtmlRenderer(writer);
HtmlRenderer renderer = rentedRenderer.Instance;
renderer.Render(document);
renderer.Writer.Flush();
}
public void SimpleTest()
{
var h = new HtmlRenderer();
h.BeginSettingsForm("TestClass");
h.AddSegment("Test");
h.AddMappedCheckbox("Test checkbox", "TestCheckBox", true);
h.EndSettingsForm();
var s = h.ToString();
var expected = ExpectedPrefix +
"<h1>Test</h1>" +
"<div class='controls'>" +
"<label class='checkbox'>" +
"<input type='checkbox' class='mappedCheckBox' name='TestCheckBox' value='True' checked='checked' />" +
"Test checkbox" +
"</label>" +
"</div>" +
ExpectedSuffix;
Assert.That(s, Is.EqualTo(expected));
}
void c_ImageLoad(object sender, HtmlRenderer.Entities.HtmlImageLoadEventArgs e)
{
System.Drawing.Image a;
try
{
a = System.Drawing.Bitmap.FromFile(e.Src);
}
catch
{
throw new Exception("Trying to load external or unexisting image in HTML. Only local images are allowed");
}
e.Callback(a);
}
private void htmlPanel1_ImageLoad(object sender, HtmlRenderer.Entities.HtmlImageLoadEventArgs e)
{
watchedFiles.Add(Path.GetFullPath(Path.Combine(this.fileSystemWatcher1.Path, e.Src)));
}
private void htmlPanel1_LinkClicked(object sender, HtmlRenderer.Entities.HtmlLinkClickedEventArgs e)
{
e.Handled = true;
if (!string.IsNullOrWhiteSpace(e.Link))
MessageBox.Show(e.Link.ToString());
}
public void WritesOutColouredCode() {
var underlyingRendererMock = new Mock<CodeBlockRenderer>();
underlyingRendererMock
.Setup(x => x.Write(It.IsAny<HtmlRenderer>(), It.IsAny<CodeBlock>()));
var renderer = new SyntaxHighlightingCodeBlockRenderer(underlyingRendererMock.Object);
var builder = new StringBuilder();
var markdownRenderer = new HtmlRenderer(new StringWriter(builder));
var codeBlock = GetFencedCodeBlock();
renderer.Write(markdownRenderer, codeBlock);
Assert.Contains("<span style=\"color:Blue;\">var</span>", builder.ToString());
}
private void htmlPanel1_RenderError(object sender, HtmlRenderer.Entities.HtmlRenderErrorEventArgs e)
{
}
private static int Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
if(e.ExceptionObject is FicdownException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine(e.ExceptionObject.ToString());
Environment.Exit(3);
}
};
string infile = null;
string output = null;
string tempdir = null;
string format = null;
string author = null;
string images = null;
var debug = false;
if (args.Length == 1)
{
if (args[0] == "/?" || args[0] == "/help" || args[0] == "-help" || args[0] == "--help")
{
ShowHelp();
return 0;
}
}
else if (args.Length > 1)
{
for (var i = 0; i < args.Length; i += 2)
{
switch (args[i])
{
case "--format":
format = args[i + 1];
break;
case "--in":
infile = args[i + 1];
break;
case "--out":
output = args[i + 1];
break;
case "--template":
tempdir = args[i + 1];
break;
case "--author":
author = args[i + 1];
break;
case "--images":
images = args[i + 1];
break;
case "--debug":
i--;
debug = true;
break;
default:
Console.WriteLine(@"Unknown option: {0}", args[i]);
return 1;
}
}
}
else
{
ShowHelp();
return 0;
}
if (string.IsNullOrWhiteSpace(format) || string.IsNullOrWhiteSpace(infile))
{
ShowHelp();
return 1;
}
if (!File.Exists(infile))
{
Console.WriteLine(@"Source file {0} not found.", infile);
return 2;
}
if (string.IsNullOrWhiteSpace(output))
if (format == "html")
output = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"html");
else if (format == "epub")
output = "output.epub";
if (!string.IsNullOrWhiteSpace(output) && (Directory.Exists(output) || File.Exists(output)))
{
Console.WriteLine(@"Specified output {0} already exists.", output);
return 2;
}
if (!string.IsNullOrWhiteSpace(tempdir))
{
if (!Directory.Exists(tempdir))
{
Console.WriteLine(@"Template directory {0} does not exist.", tempdir);
return 2;
}
if (!File.Exists(Path.Combine(tempdir, "index.html")) ||
!File.Exists(Path.Combine(tempdir, "scene.html")) ||
!File.Exists(Path.Combine(tempdir, "styles.css")))
{
Console.WriteLine(
@"Template directory must contain ""index.html"", ""scene.html"", and ""style.css"" files.");
}
}
if (!string.IsNullOrWhiteSpace(images) && !Directory.Exists(images))
{
Console.WriteLine(@"Images directory {0} does not exist.", images);
return 2;
}
var parser = new FicdownParser();
var storyText = File.ReadAllText(infile);
Console.WriteLine(@"Parsing story...");
var story = parser.ParseStory(storyText);
story.Orphans.ToList().ForEach(o =>
{
var currentColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Error.WriteLine("Warning (line {0}): {1} {2} is unreachable", o.LineNumber, o.Type, o.Name);
Console.ForegroundColor = currentColor;
});
IRenderer rend;
switch (format)
{
case "html":
Directory.CreateDirectory(output);
rend = new HtmlRenderer();
break;
case "epub":
if (string.IsNullOrWhiteSpace(author))
{
Console.WriteLine(@"Epub format requires the --author argument.");
return 1;
}
rend = new EpubRenderer(author);
break;
default:
ShowHelp();
return 1;
}
if (!string.IsNullOrWhiteSpace(tempdir))
{
rend.IndexTemplate = File.ReadAllText(Path.Combine(tempdir, "index.html"));
rend.SceneTemplate = File.ReadAllText(Path.Combine(tempdir, "scene.html"));
rend.StylesTemplate = File.ReadAllText(Path.Combine(tempdir, "styles.css"));
};
if (!string.IsNullOrWhiteSpace(images)) rend.ImageDir = images;
Console.WriteLine(@"Rendering story...");
rend.Render(story, output, debug);
Console.WriteLine(@"Done.");
return 0;
}
public void UpdateBrowser(string markdown)
{
// Generate the HTML document
string html = null;
StringWriter htmlWriter = null;
try
{
var doc = Markdown.Parse(markdown, _pipeline);
htmlWriter = htmlWriterStatic ?? (htmlWriterStatic = new StringWriter());
htmlWriter.GetStringBuilder().Clear();
var htmlRenderer = new HtmlRenderer(htmlWriter);
_pipeline.Setup(htmlRenderer);
htmlRenderer.Render(doc);
htmlWriter.Flush();
html = htmlWriter.ToString();
// TODO: use a pool for List<Block>
// Collect all blocks for sync navigation
var blocks = new List<Block>();
// This is used by live sync navigation, but we always generate them so that
// we can enable/disable the sync navigation and it will work correctly
DumpBlocks(doc, blocks);
_markdownBlocks = blocks;
}
catch (Exception ex)
{
// We could output this to the exception pane of VS?
// Though, it's easier to output it directly to the browser
html = "<p>An unexpected exception occured:</p><pre>" +
ex.ToString().Replace("<", "<").Replace("&", "&") + "</pre>";
}
finally
{
// Free any resources allocated by HtmlWriter
htmlWriter?.GetStringBuilder().Clear();
}
if (_htmlDocument != null)
{
var content = _htmlDocument.getElementById("___markdown-content___");
content.innerHTML = html;
// Makes sure that any code blocks get syntax highligted by Prism
var win = _htmlDocument.parentWindow;
win.execScript("Prism.highlightAll();", "javascript");
}
else
{
var template = string.Format(CultureInfo.InvariantCulture, _htmlTemplate, html);
Control.NavigateToString(template);
}
SyncNavigation();
}
private void htmlMessages_LinkClicked(object sender, HtmlRenderer.Entities.HtmlLinkClickedEventArgs e)
{
if (e.Link == "#on")
{
if (fb == null)
{
fb = new FileBinder();
fb.OnNewReplay += FileBinder_OnNewReplay;
fb.BindRebind(txtLastReplay.Text);
}
txtLastReplay.Enabled = false;
fb.BindRebind(txtLastReplay.Text);
LogMessage(MessageType.OK, "The FileBinder was succesfully rebound!");
}
else if (e.Link == "#off")
{
if (fb != null)
{
txtLastReplay.Enabled = true;
fb.Unbind();
LogMessage(MessageType.Warning, "The FileBinder was succesfully unbound. <b>REPLAY ARE NOT SAVED!</b>");
}
}
else if (e.Link == "#exp_help")
{
new frmExpressionHelp(AvailableRegexes()).Show();
}
else if (e.Link.StartsWith("cfg://"))
{
ShowConfig(e.Link.Substring(6));
}
e.Handled = true;
}
private XmlDocument GetDocument(WorkStep workStep)
{
var htmlRenderer = new HtmlRenderer(_wp);
var doc = new XmlDocument();
using (var writeStream = new MemoryStream())
{
htmlRenderer.Render(writeStream, workStep);
var readStream = new MemoryStream(writeStream.ToArray());
doc.Load(readStream);
}
return doc;
}
private void RenderReport( Report report )
{
if ( !Directory.Exists( ReportOutputDirectory ) )
{
Directory.CreateDirectory( ReportOutputDirectory );
}
using ( PerfMon.Profile( "Rendering report" ) )
{
var renderer = new HtmlRenderer();
renderer.Render( report, ReportOutputDirectory );
}
Console.WriteLine( "Report written to: {0}", ReportOutputDirectory );
}
