/// <summary>
/// Converts a UfDataNode structure into a very basic form HTML.
/// </summary>
/// <param name="node">Node</param>
/// <param name="formatDescriber">Microformat format describer object</param>
/// <returns>HTML string</returns>
public string Convert(UfDataNode node, UfFormatDescriber formatDescriber)
{
string output = string.Empty;
StringWriter stringWriter = new StringWriter();
UfElementDescriber elementDescriber = formatDescriber.BaseElement;
using (XhtmlTextWriter writer = new XhtmlTextWriter(stringWriter))
{
writer.WriteBeginTag("div");
writer.WriteAttribute("class", "microformats");
writer.Write(HtmlTextWriter.TagRightChar);
foreach (UfDataNode child in node.Nodes)
{
writer.WriteLine();
AddNode(child, elementDescriber, writer);
}
writer.WriteEndTag("div");
writer.WriteLine();
}
return(stringWriter.ToString());
}
public bool Render(object o, string description, int depth, XhtmlTextWriter writer)
{
//there are two principal ways of rendering an object,
// if it's an enumerable we render each object as a row in a table
// if it's jut an object we render each property of the object as a row in a table
if (!String.IsNullOrWhiteSpace(description))
{
writer.RenderBeginTag(HtmlTextWriterTag.H3);
writer.Write(description);
writer.RenderEndTag();
writer.WriteLine();
}
if (depth <= 0)
{
return(true);
}
if (o is IEnumerable && !(o is String))
{
return(RenderEnumerable((IEnumerable)o, depth, writer));
}
else
{
return(RenderObject(o, depth, writer));
}
}
public virtual Stream Render(IEnumerable dataSource)
{
XhtmlTextWriter xhtmlWriter = new XhtmlTextWriter(_writer);
//-----------------------------------------------------------------
// If the 'Renderer' supports the ITextControl interface, we will
// defer rendering of the 'Text' block to it. The assignment needs
// to take place before 'DataBind' so the 'Renderer' can act
// on the Text. (Maybe a token substitution will happen, perhaps!)
//-----------------------------------------------------------------
ITextControl _textControl = Renderer as ITextControl;
if (_textControl != null)
{
_textControl.Text = Text;
}
// Bind the Data to the Renderer
Renderer.DataSource = dataSource;
Renderer.DataBind();
xhtmlWriter.Flush();
// Render unto the Stream that which belongs to the Stream...
Renderer.RenderControl(xhtmlWriter);
xhtmlWriter.Flush();
return(_writer.BaseStream);
}
public override Stream Render(IDataSource dataSource)
{
// If we have not written anything _yet_ to the Stream, we will
// be writing a complete page with this call.
if (Writer.BaseStream.Position == 0)
{
return(RenderPage(dataSource));
}
XhtmlTextWriter xhtmlWriter = new XhtmlTextWriter(Writer);
xhtmlWriter.Indent = 3;
// Flush writer contents to output.
xhtmlWriter.Flush();
// Emit Core of Page
HTMLReportView <RenderType> view = new HTMLReportView <RenderType>(Writer);
view.Text = Text;
view.Render(dataSource);
// Flush writer contents to output.
xhtmlWriter.Flush();
return(Writer.BaseStream);
}
/// <summary>
/// Generates HTML code for the given <c>MenuPart</c>.
/// </summary>
/// <returns>HTML code as a string</returns>
public string GetHtml()
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
using (var xml = new XhtmlTextWriter(sw))
WriteHtml(xml);
return(sb.ToString());
}
private void RenderMember(MemberInfo memberInfo, object o, int depth, XhtmlTextWriter writer)
{
//try to get the value
object value = null;
try
{
value = GetValue(memberInfo, o);
}
catch (Exception ex)
{
value = "Error getting member value: " + ex.Message;
}
if (value == null)
{
writer.Write("null");
return;
}
var valueType = GetValueType(memberInfo);
if (valueType == null)
{
writer.Write("Error getting member type.");
}
else if (valueType == typeof(double) ||
valueType == typeof(decimal) ||
valueType == typeof(float))
{
//if the property seems to contain percent data we format it appropriately
if (memberInfo.Name.ToLower().Contains("percent") || memberInfo.Name.ToLower().Contains("prc"))
{
writer.Write("{0:0.00%}", value);
}
else
{
writer.Write("{0:0.00}", value);
}
}
else if (valueType == typeof(DateTime) ||
valueType == typeof(DateTimeOffset))
{
//todo: optional date time formatting
writer.Write(value);
}
else if (IsSimpleType(valueType))
{
writer.Write(value);
}
else
{
//recurively call the render method to descend one level in the object tree
Render(value, null, depth - 1, writer);
}
}
public static string PreProcessObject(object source, object value)
{
return
(value == null
? null
: SnippetModifiers
.Where(m => m.CanProcessObject(source, value))
.Select(m => m.ProcessObject(source, value))
.DefaultIfEmpty(XhtmlTextWriter.HtmlEncode(value.ToString())).First());
}
public NVelocityHtmlRenderHelper(
IHttpContext httpContext,
XhtmlTextWriter writer,
IApplicationInfo applicationInfo,
IFileCache fileCache)
{
this.httpContext = httpContext;
this.fileCache = fileCache;
this.applicationInfo = applicationInfo;
this.writer = writer;
}
public static string RenderControl(Control control)
{
if (control == null)
{
return(null);
}
using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
using (XhtmlTextWriter htmlTextWriter = new XhtmlTextWriter(stringWriter))
{
control.RenderControl(htmlTextWriter);
return(_collapseMultipleLinefeeds.Replace(HttpUtility.HtmlDecode(stringWriter.ToString())
.Trim(Environment.NewLine.ToArray()), Environment.NewLine)); // Replace multiple linefeeds with single.
}
}
/// <summary>
/// Create html file according to a matching xml
/// </summary>
/// <param name="xmlPath">the values xml</param>
/// <param name="xslPath">the xml transformation file</param>
/// <param name="targetFile">the full file name - where to save the product</param>
public static void CreateHtmlFromXslt(string xmlPath, string xslPath, string targetFile)
{
var xslTransform = new XslCompiledTransform();
//xslTransform.Load(xslPath);
xslTransform.Load(xslPath, new XsltSettings(false, true), null);
var sb = new StringBuilder();
var sw = new StringWriter(sb);
var xmlWriter = new XhtmlTextWriter(sw);
xslTransform.Transform(xmlPath, null, xmlWriter);
File.WriteAllText(targetFile, sb.ToString());
}
public bool RenderObject(object o, int depth, XhtmlTextWriter writer)
{
var objectType = o.GetType();
if (IsSimpleType(objectType))
{
writer.RenderBeginTag(HtmlTextWriterTag.P);
writer.Write(o.ToString());
writer.RenderEndTag();
writer.WriteLine();
return(true);
}
//get the members (fields and properties)
var members = GetMembers(objectType);
//create a two column table containing member and then value
writer.RenderBeginTag(HtmlTextWriterTag.Table);
//write a header containing the class name
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
writer.AddAttribute(HtmlTextWriterAttribute.Colspan, "2");
writer.RenderBeginTag(HtmlTextWriterTag.Th);
writer.Write(objectType.Name);
writer.RenderEndTag(); //th
writer.RenderEndTag(); //tr
foreach (var member in members)
{
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
writer.AddAttribute(HtmlTextWriterAttribute.Class, "left");
writer.RenderBeginTag(HtmlTextWriterTag.Th);
writer.Write(member.Name);
writer.RenderEndTag(); //th
writer.RenderBeginTag(HtmlTextWriterTag.Td);
RenderMember(member, o, depth, writer);
writer.RenderEndTag(); //td
writer.RenderEndTag(); //tr
}
writer.RenderEndTag(); //table
writer.WriteLine();
return(true);
}
public Stream RenderPageEnd()
{
XhtmlTextWriter xhtmlWriter = new XhtmlTextWriter(Writer);
xhtmlWriter.Indent = 3;
// Flush writer contents to output.
xhtmlWriter.Flush();
if (ReportFooter != null && ReportFooter.Length > 0)
{
xhtmlWriter.RenderBeginTag("hr");
xhtmlWriter.WriteEndTag("hr");
//
xhtmlWriter.AddAttribute("class", "footer");
xhtmlWriter.RenderBeginTag("div");
xhtmlWriter.Write(ReportFooter);
xhtmlWriter.WriteEndTag("div");
xhtmlWriter.RenderBeginTag("hr");
xhtmlWriter.WriteEndTag("hr");
xhtmlWriter.WriteLine(Writer.NewLine);
// </h2>
}
//--------------------------------------------------------
// No matter what state the Renderer left us in, close
// off the <body> and <html> elements.
//--------------------------------------------------------
// </body>
xhtmlWriter.WriteEndTag("body");
// </html>
xhtmlWriter.WriteEndTag("html");
// Flush writer contents to output.
xhtmlWriter.Flush();
return(Writer.BaseStream);
}
public virtual Stream Render(IDataSource dataSource)
{
XhtmlTextWriter xhtmlWriter = new XhtmlTextWriter(_writer);
// <div class='core'>
xhtmlWriter.AddAttribute("class", "core");
xhtmlWriter.RenderBeginTag("div");
xhtmlWriter.WriteLine(Writer.NewLine);
//-----------------------------------------------------------------
// If the 'Renderer' supports the ITextControl interface, we will
// defer rendering of the 'Text' block to it. The assignment needs
// to take place before 'DataBind' so the 'Renderer' can act
// on the Text. (Maybe a token substitution will happen, perhaps!)
//-----------------------------------------------------------------
ITextControl _textControl = Renderer as ITextControl;
if (_textControl != null)
{
_textControl.Text = Text;
}
// Bind the Data to the Renderer
if (dataSource != null)
{
Renderer.DataSource = dataSource;
Renderer.DataBind();
}
xhtmlWriter.Flush();
// Render unto the Stream that which belongs to the Stream...
Renderer.ID = ID;
Renderer.RenderControl(xhtmlWriter);
// </div>
xhtmlWriter.WriteEndTag("div");
xhtmlWriter.Flush();
return(_writer.BaseStream);
}
private void RenderChildrenCallback(TextWriter writer)
{
bool flush = false;
HtmlTextWriter htmlWriter = writer as HtmlTextWriter;
if (htmlWriter == null)
{
htmlWriter = new XhtmlTextWriter(writer);
flush = true;
}
this.RenderChildren(htmlWriter);
if (flush)
{
htmlWriter = new HtmlTextWriter(writer);
htmlWriter.Flush();
}
}
// <snippet3>
protected override void Render(HtmlTextWriter writer)
{
// Create an instance of the XhtmlTextWriter class,
// named w, and cast the HtmlTextWriter passed
// in the writer parameter to w.
XhtmlTextWriter w = new XhtmlTextWriter(writer);
// Create a string variable, named value, to hold
// the control's Text property value.
String value = Control.Text;
// Create a Boolean variable, named attTest,
// to test whether the Style attribute is
// valid in the page that the control is
// rendered to.
Boolean attTest = w.IsValidFormAttribute("style");
// Check whether attTest is true or false.
// If true, a style is applied to the XHTML
// content. If false, no style is applied.
if (attTest)
{
w.EnterStyle(Control.ControlStyle);
}
// Write the Text property value of the control,
// a <br> element, and a string. Consider encoding the value using WriteEncodedText.
w.Write(value);
w.WriteBreak();
w.Write("This control conditionally rendered its styles for XHTML.");
// Check whether attTest is true or false.
// If true, the XHTML style is closed.
// If false, nothing is rendered.
if (attTest)
{
w.ExitStyle(Control.ControlStyle);
}
}
public Stream RenderPage(IDataSource dataSource)
{
RenderPageBegin();
XhtmlTextWriter xhtmlWriter = new XhtmlTextWriter(Writer);
xhtmlWriter.Indent = 3;
// Flush writer contents to output.
xhtmlWriter.Flush();
// Emit Core of Page
HTMLReportView <RenderType> view = new HTMLReportView <RenderType>(Writer);
view.Text = Text;
view.Render(dataSource);
RenderPageEnd();
// Flush writer contents to output.
xhtmlWriter.Flush();
return(Writer.BaseStream);
}
/// <summary>
/// Parses source code.
/// </summary>
/// <param name="source">The source code which will be parsed.</param>
/// <param name="scannerResult">The result returned by the scanners after scanning the source code.</param>
/// <returns>The highlighted source code.</returns>
public override string Parse(string source, IList <Occurrence> scannerResult)
{
StringWriter htmlStringWriter = new StringWriter();
XhtmlTextWriter htmlWriter = new XhtmlTextWriter(htmlStringWriter);
int lastIndex = 0;
for (int i = 0; i < scannerResult.Count; i++)
{
if ((scannerResult[i].Start - lastIndex) >= 0)
{
if (scannerResult[i].Start > 0)
{
// Encode non-highlighted text first.
htmlWriter.WriteEncodedText(source.Substring(lastIndex, scannerResult[i].Start - lastIndex));
}
htmlWriter.Write(this.ParseToken(source.Substring(scannerResult[i].Start, scannerResult[i].Length), scannerResult[i].Node));
}
lastIndex = scannerResult[i].Start + scannerResult[i].Length;
}
// Encode the last bit of nonhighlighted text.
if (lastIndex < source.Length)
{
htmlWriter.WriteEncodedText(source.Substring(lastIndex));
}
string result = htmlStringWriter.ToString();
htmlWriter.Close();
htmlStringWriter.Close();
return(result);
}
protected virtual void AssignHtmlWriter(
IHttpContext httpContext,
XhtmlTextWriter xhtmlTextWriter)
{
writer = xhtmlTextWriter;
}
public XhtmlDumper(TextWriter writer)
{
this.writer = new XhtmlTextWriter(writer);;
this.renderers = new IXhtmlRenderer[] { new ObjectXhtmlRenderer(), new BasicXhtmlRenderer() };
InitHeader();
}
public bool Render(object o, string description, int depth, XhtmlTextWriter writer)
{
writer.WriteLine(o);
return(true);
}
private string GenerateHtmlReport()
{
string htmlFullFilePath = Path.GetTempFileName() + Guid.NewGuid().ToString() + ".html";
//_testsSummary = SummarizeRun();
using (StreamWriter htmlStreamWriter = new StreamWriter(htmlFullFilePath))
{
using (System.Web.UI.XhtmlTextWriter writer = new XhtmlTextWriter(htmlStreamWriter, " "))
{
writer.WriteLine("<!DOCTYPE xhtml>");
writer.RenderBeginTag(HtmlTextWriterTag.Html); // Begin Html
//Write html Head:
writer.RenderBeginTag(HtmlTextWriterTag.Head); // Begin Head
writer.WriteLine(WriteHtmlReportHead());
writer.RenderEndTag(); // End Head
//Write html Body:
using (HtmlGenericControl body = new HtmlGenericControl("body")) // Begin Body content
{
#region Header Creation
//body.Controls.Add(GenerateHeaderSection());
GenerateHeaderSection(body);
#endregion Header Creation
#region Navigation Creation
//body.Controls.Add(GenerateNavSection());
GenerateNavSection(body);
#endregion Navigator Creation
#region Article Creation
//body.Controls.Add(GenerateArticleSection());
GenerateArticleSection(body);
#endregion Article Creation
#region Modal Creation
using (HtmlGenericControl modal = new HtmlGenericControl("div"))
{
modal.Attributes.Add("id", "modal");
modal.Attributes.Add("class", "modal");
modal.Controls.Add(
new LiteralControl(
"<span class=\"close\" onclick=\"closeModal()\">×</span>"));
modal.Controls.Add(
new LiteralControl("<img class=\"modal-content\" id=\"modalImg\">"));
modal.Controls.Add(new LiteralControl("<div id=\"caption\"></div>"));
body.Controls.Add(modal);
}
#endregion Modal Creation
#region footer Creation
using (HtmlGenericControl footer = new HtmlGenericControl("footer"))
{
body.Controls.Add(footer);
}
#endregion footer Creation
body.RenderControl(writer); // End Body content
}
writer.RenderEndTag(); // End Html
}
}
return(htmlFullFilePath);
}
public Stream RenderPageBegin()
{
XhtmlTextWriter xhtmlWriter = new XhtmlTextWriter(Writer);
xhtmlWriter.Indent = 3;
xhtmlWriter.AddAttribute("xmlns", "http://www.w3.org/1999/xhtml");
xhtmlWriter.RenderBeginTag("html");
xhtmlWriter.RenderBeginTag("head");
if (ReportHeading != null && ReportHeading.Length > 0)
{
xhtmlWriter.RenderBeginTag("title");
xhtmlWriter.Write(ReportHeading);
xhtmlWriter.WriteEndTag("title");
}
// <style type='text/css'>
xhtmlWriter.WriteLine(Writer.NewLine);
xhtmlWriter.AddAttribute(HtmlTextWriterAttribute.Type, "text/css");
xhtmlWriter.RenderBeginTag("style");
foreach (var style in _styles)
{
xhtmlWriter.WriteLine(style.Key);
xhtmlWriter.WriteLine("{");
xhtmlWriter.WriteLine(style.Value);
xhtmlWriter.WriteLine("}");
}
xhtmlWriter.WriteEndTag("style");
xhtmlWriter.WriteLine(Writer.NewLine);
// </style>
xhtmlWriter.WriteEndTag("head");
// <body>
xhtmlWriter.RenderBeginTag("body");
if (ReportHeading != null && ReportHeading.Length > 0)
{
// <h2 class='heading'>
xhtmlWriter.AddAttribute("class", "heading");
xhtmlWriter.RenderBeginTag("h2");
xhtmlWriter.Write(ReportHeading);
xhtmlWriter.WriteEndTag("h2");
xhtmlWriter.WriteLine(Writer.NewLine);
// </h2>
}
if (!(Renderer is ITextControl) && Text != null && Text.Length > 0)
{
// <p class='text'>
xhtmlWriter.AddAttribute("class", "caption");
xhtmlWriter.RenderBeginTag("p");
xhtmlWriter.Write(Text);
xhtmlWriter.WriteEndTag("p");
xhtmlWriter.WriteLine(Writer.NewLine);
// </p>
}
// Flush writer contents to output.
xhtmlWriter.Flush();
return(Writer.BaseStream);
}
private void AddNode(UfDataNode node, UfElementDescriber elementDescriber, XhtmlTextWriter writer)
{
if (node.Name != string.Empty)
{
indentNum++;
writer.Indent = indentNum;
UfElementDescriber currentDescriber = elementDescriber;
foreach (UfElementDescriber childElementDescriber in elementDescriber.Elements)
{
if (node.Name == childElementDescriber.Name || node.Name == childElementDescriber.CompoundName)
{
currentDescriber = childElementDescriber;
}
}
if (currentDescriber.Attribute == "class")
{
writer.WriteBeginTag("div");
if (currentDescriber.CompoundName == "")
{
writer.WriteAttribute("class", node.Name);
}
else
{
writer.WriteAttribute("class", node.Name + " " + currentDescriber.Name);
}
if (!string.IsNullOrEmpty(node.ElementId))
{
writer.WriteAttribute("id", node.ElementId);
}
writer.Write(HtmlTextWriter.TagRightChar);
writer.WriteEncodedText(node.Value);
foreach (UfDataNode child in node.Nodes)
{
writer.WriteLine();
AddNode(child, currentDescriber, writer);
}
if (node.Name != string.Empty)
{
writer.WriteEndTag("div");
writer.WriteLine();
}
}
if (currentDescriber.Attribute == "rel")
{
writer.WriteBeginTag("a");
writer.WriteAttribute("href", node.DescendantValue("link"));
writer.WriteAttribute("rel", node.Name);
writer.Write(HtmlTextWriter.TagRightChar);
writer.WriteEncodedText(node.DescendantValue("text"));
writer.WriteEndTag("a");
writer.WriteLine();
}
indentNum--;
writer.Indent = indentNum;
}
}
public bool RenderEnumerable(IEnumerable enumerable, int depth, XhtmlTextWriter writer)
{
var elementType = GetElementTypeOfEnumerable(enumerable);
if (elementType == null)
{
return(false);
}
//get the members (fields and properties)
var members = GetMembers(elementType);
//write the headers and start the table
writer.RenderBeginTag(HtmlTextWriterTag.Table);
//if the element type is an element that needs to be rendered atomically we use a different method
if (IsSimpleType(elementType))
{
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
writer.RenderBeginTag(HtmlTextWriterTag.Th);
writer.Write(elementType.Name);
writer.RenderEndTag();
writer.RenderEndTag();
foreach (var element in enumerable)
{
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
writer.RenderBeginTag(HtmlTextWriterTag.Td);
writer.Write(element.ToString());
writer.RenderEndTag();
writer.RenderEndTag();
}
}
else
{
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
foreach (var member in members)
{
writer.RenderBeginTag(HtmlTextWriterTag.Th);
writer.Write(member.Name);
writer.RenderEndTag();
}
writer.RenderEndTag(); //tr
writer.WriteLine();
//write all the members
foreach (var element in enumerable)
{
writer.RenderBeginTag(HtmlTextWriterTag.Tr);
foreach (var member in members)
{
writer.RenderBeginTag(HtmlTextWriterTag.Td);
RenderMember(member, element, depth, writer);
writer.RenderEndTag(); //td
}
writer.RenderEndTag(); //tr
writer.WriteLine();
}
}
//end the table
writer.RenderEndTag();
writer.WriteLine();
return(true);
}
public XhtmlDumper(TextWriter writer, params IXhtmlRenderer[] renderers)
{
this.writer = new XhtmlTextWriter(writer);
this.renderers = renderers;
InitHeader();
}
/// <summary>
/// Create an XHTMStreamWriter which writes to specified writer in specified XHTML DocType
/// </summary>
/// <param name="writer">Writer to write to</param>
/// <param name="docType">DocType of XHTML document</param>
public XHTMLStreamWriter(TextWriter writer, DocType docType, XHTMLElement tree)
{
DocTyping = docType;
XhtmlWriter = new XhtmlTextWriter(writer);
Root = tree;
}
