/// <summary> /// Actually use DotLiquid to render a liquid string into output. /// </summary> /// <param name="source">Liquid source to render.</param> /// <param name="sourceIdentifier">For telemetry purposes, optional string identifying what's being rendered.</param> /// <param name="output">TextWriter to render output to.</param> /// <param name="context">DotLiquid context.</param> private static void InternalRenderLiquid(string source, string sourceIdentifier, TextWriter output, Context context) { Template template; if (!string.IsNullOrEmpty(sourceIdentifier)) { sourceIdentifier = string.Format(" ({0})", sourceIdentifier); } try { using (PerformanceProfiler.Instance.StartMarker(PerformanceMarkerName.LiquidExtension, PerformanceMarkerArea.Liquid, PerformanceMarkerTagName.LiquidSourceParsed)) { template = Template.Parse(source); } } catch (SyntaxException e) { ADXTrace.Instance.TraceError(TraceCategory.Application, string.Format("Liquid parse error{0}: {1}", sourceIdentifier, e.ToString())); output.Write(e.Message); return; } ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Rendering Liquid{0}", sourceIdentifier)); using (PerformanceProfiler.Instance.StartMarker(PerformanceMarkerName.LiquidExtension, PerformanceMarkerArea.Liquid, PerformanceMarkerTagName.RenderLiquid)) { template.Render(output, RenderParameters.FromContext(context)); } foreach (var error in template.Errors) { ADXTrace.Instance.TraceError(TraceCategory.Application, string.Format("Liquid rendering error{0}: {1}", sourceIdentifier, error.ToString())); } }
private static string Render([NotNull] string templatePath, [NotNull] Hash hash, bool rethrowErrors = false) { string templateDirectory = Path.GetDirectoryName(Path.GetFullPath(templatePath)); IFileSystem origFileSystem = Template.FileSystem; try { if (!string.IsNullOrEmpty(templateDirectory)) { Template.FileSystem = new LocalFileSystem(templateDirectory); } string templateString = FileSystemUtils.ReadTextFile(templatePath); Template template = Template.Parse(templateString); var parameters = new RenderParameters { LocalVariables = hash, RethrowErrors = rethrowErrors }; string result = template.Render(parameters) ?? string.Empty; return(result); } finally { Template.FileSystem = origFileSystem; } }
public override Render Render(RenderParameters parameters) { int margin; switch (Alignment) { case VerticalAlignment.Top: margin = 0; break; case VerticalAlignment.Center: margin = (GivenSize.Height - Child.GivenSize.Height) / 2; break; case VerticalAlignment.Bottom: margin = GivenSize.Height - Child.GivenSize.Height; break; default: throw new ArgumentOutOfRangeException(); } var buffer = new string[GivenSize.Height]; var childRender = Child.Render(parameters); Array.Copy( childRender.Buffer, 0, buffer, margin, childRender.Buffer.Length); return(new Render(buffer, GivenSize)); }
public override void Render(Context context, TextWriter result) { Template partial = LoadCachedPartials(_templateName, context); string shortenedTemplateName = _templateName.Substring(1, _templateName.Length - 2); object variable = context[_variableName ?? shortenedTemplateName]; context.Stack(() => { foreach (var keyValue in _attributes) { context[keyValue.Key] = context[keyValue.Value]; } if (variable is IEnumerable && !(variable is string)) { ((IEnumerable)variable).Cast <object>().ToList().ForEach(v => { context[shortenedTemplateName] = v; partial.Render(result, RenderParameters.FromContext(context)); }); return; } context[shortenedTemplateName] = variable; partial.Render(result, RenderParameters.FromContext(context)); }); }
public static GenerationResult GenerateFilePreview(Idea Source, string SourceTemplateText, bool FailWhenInvalid = false) { GenerationResult Result = null; System.Windows.Input.Mouse.OverrideCursor = System.Windows.Input.Cursors.Wait; try { var CompiledTemplate = CreateCompiledTemplate(Source.IdeaDefinitor.ToString(), SourceTemplateText, FailWhenInvalid).Result; var Parameters = new RenderParameters(); Parameters.LocalVariables = DotLiquid.Hash.FromAnonymousObject(Source); Parameters.RethrowErrors = true; var GeneratedOutput = CompiledTemplate.Render(Parameters); Result = new GenerationResult((Source.OwnerComposition.CompositeContentDomain.GenerationConfiguration.UseIdeaTechNameForFileNaming ? Source.TechName : Source.Name) + GenerationManager.DEFAULT_GEN_EXT, GeneratedOutput); } finally { System.Windows.Input.Mouse.OverrideCursor = null; } return(Result); }
public static string RenderWithTracing(this Template template, RenderParameters parameters) { if (template == null) { throw new ArgumentNullException("template"); } string content = null; try { content = template.Render(parameters); } catch (Exception ex) { Trace.TraceError(FlattenException(ex)); throw; } finally { if (template.Errors.Any()) { template.Errors.ForEach(e => Trace.TraceError(FlattenException(e))); } } return(content); }
/// <summary> /// Renders the reCaptcha HTML control. /// </summary> /// <param name="htmlHelper"><c>HtmlHelper</c> instance.</param> /// <param name="htmlAttributes">List of HTML attributes.</param> /// <param name="parameters"><c>ReCaptchaParameters</c> object.</param> /// <returns>Returns the reCaptcha HTML control.</returns> public static MvcHtmlString ReCaptcha(this HtmlHelper htmlHelper, RenderParameters parameters, IDictionary <string, object> htmlAttributes) { var builder = new TagBuilder("div"); if (parameters != null) { builder.MergeAttributes(parameters.ToDictionary <RenderParameters, string, object>()); } if (htmlAttributes != null) { builder.MergeAttributes(htmlAttributes); } string result; if (!builder.Attributes.TryGetValue("class", out result)) { result = "g-recaptcha"; builder.AddCssClass(result); } if (!result.Contains("g-recaptcha")) { builder.AddCssClass("g-recaptcha"); } return(builder.ToMvcHtmlString(TagRenderMode.Normal)); }
// Protected Methods (1) protected override void OnRender(ref StringBuilder builder) { if (this._SOURCE == null) { builder = null; return; } var @params = new RenderParameters(); @params.Filters = this.Filters; var tpl = Template.Parse(this._SOURCE); foreach (var item in this.GetAllVars()) { tpl.Assigns.Add(item.Key, ToLiquidObject(item.Value)); } var renderedSrc = tpl.Render(@params); if (renderedSrc != null) { builder.Append(renderedSrc); } else { builder = null; } }
public override Rss.RssItem[] GetRssFeedItems(CmsPage page, CmsPlaceholderDefinition placeholderDefinition, CmsLanguage langToRenderFor) { List <Rss.RssItem> ret = new List <Rss.RssItem>(); // -- get the news NewsArticleDb.NewsArticleAggregatorData aggData = (new NewsArticleDb()).fetchNewsAggregator(page, placeholderDefinition.Identifier, langToRenderFor, true); RenderParameters renderParams = RenderParameters.fromParamList(placeholderDefinition.ParamList, aggData); NewsAggItem[] newsItems = FetchAllNewsAggItems(page, placeholderDefinition.Identifier, langToRenderFor, renderParams, CmsUrlFormat.FullIncludingProtocolAndDomainName); int currYear = renderParams.AggregatorData.YearToDisplay; foreach (NewsAggItem newsItem in newsItems) { if (currYear < 0 || newsItem.NewsDate.Year == currYear) { Rss.RssItem rssItem = new Rss.RssItem(); rssItem = InitRssItem(rssItem, page, langToRenderFor); rssItem.Title = newsItem.Title; rssItem.Link = new Uri(newsItem.PageDisplayURL, UriKind.RelativeOrAbsolute); rssItem.Guid = new Rss.RssGuid(rssItem.Link); rssItem.PubDate_GMT = newsItem.NewsDate.ToUniversalTime(); rssItem.Description = newsItem.NewsArticleHtml; ret.Add(rssItem); } } return(ret.ToArray()); } // GetRssFeedItems
/// <summary> /// Render template to stream /// </summary> /// <param name="path">Template path</param> /// <param name="arguments">Template arguments</param> /// <param name="stream">Target stream</param> public virtual void RenderTemplate(string path, object arguments, Stream stream) { // Build template parameters var parameters = new RenderParameters(); if (arguments is IDictionary <string, object> ) { parameters.LocalVariables = Hash.FromDictionary((IDictionary <string, object>)arguments); } else { parameters.LocalVariables = Hash.FromAnonymousObject(arguments); } // Find template, display error if not found var template = Template.FileSystem.ReadTemplateFile(null, path) as Template; if (template == null) { // Can't use using directive here, see http://stackoverflow.com/questions/2666888 var writer = new StreamWriter(stream); writer.WriteLine($"template file {path} not found"); writer.Flush(); return; } // Render to stream template.Render(stream, parameters); }
public override void Render(Context context, TextWriter result) { IFileSystem fileSystem = context.Registers["file_system"] as IFileSystem ?? Template.FileSystem; string source = fileSystem.ReadTemplateFile(context, _templateName); Template partial = Template.Parse(source); string shortenedTemplateName = _templateName.Substring(1, _templateName.Length - 2); object variable = context[_variableName ?? shortenedTemplateName]; context.Stack(() => { foreach (var keyValue in _attributes) { context[keyValue.Key] = context[keyValue.Value]; } if (variable is IEnumerable) { ((IEnumerable)variable).Cast <object>().ToList().ForEach(v => { context[shortenedTemplateName] = v; partial.Render(result, RenderParameters.FromContext(context)); }); return; } context[shortenedTemplateName] = variable; partial.Render(result, RenderParameters.FromContext(context)); }); }
/// <summary> /// Render template by content and parameters /// </summary> /// <param name="templateContent"></param> /// <param name="parameters"></param> /// <returns></returns> public string RenderTemplate(string templateContent, Dictionary <string, object> parameters) { if (String.IsNullOrEmpty(templateContent)) { return(templateContent); } if (parameters == null) { parameters = new Dictionary <string, object>(); } Template.FileSystem = this; var renderParams = new RenderParameters() { LocalVariables = Hash.FromDictionary(parameters) }; var parsedTemplate = _cacheManager.Get(GetCacheKey("ParseTemplate", templateContent.GetHashCode().ToString()), "LiquidTheme", () => { return(Template.Parse(templateContent)); }); var retVal = parsedTemplate.RenderWithTracing(renderParams); //Copy key values which were generated in rendering to out parameters if (parameters != null && parsedTemplate.Registers != null) { foreach (var registerPair in parsedTemplate.Registers) { parameters[registerPair.Key] = registerPair.Value; } } return(retVal); }
public static RenderParameters FromPlaceholderParamList(string[] paramList) { RenderParameters ret = new RenderParameters(); ret.InitFromPlaceholderParamList(paramList); return(ret); }
private string GetCustomerDetailsPartial() { string templateStr = GetLiquidFileAsString("CustomerDetailsPartial.liquid"); Template template = Template.Parse(templateStr); string domain = SettingsService.Flipdish_DomainWithScheme; string customerName = _order.Customer.Name; string deliveryInstructions = _order?.DeliveryLocation?.DeliveryInstructions; string deliveryLocationAddressString = _order?.DeliveryLocation?.PrettyAddressString; string phoneNumber = _order.Customer.PhoneNumberLocalFormat; bool isDelivery = _order.DeliveryType == Order.DeliveryTypeEnum.Delivery; string resDelivery_Instructions = "Delivery Instructions"; var paramaters = new RenderParameters(CultureInfo.CurrentCulture) { LocalVariables = Hash.FromAnonymousObject(new { domain, customerName, deliveryInstructions, deliveryLocationAddressString, phoneNumber, isDelivery, resDelivery_Instructions }) }; return(template.Render(paramaters)); }
/// <summary> /// Gets the callback script. /// </summary> /// <param name="callback">Name of callback function.</param> /// <param name="elementId">Id of the placeholder element.</param> /// <param name="parameters"><c>RenderParameters</c> instance.</param> /// <returns>Returns the callback script.</returns> private static string GetCallbackScript(string callback, string elementId, RenderParameters parameters) { if (String.IsNullOrWhiteSpace(callback)) { throw new ArgumentNullException("callback"); } if (String.IsNullOrWhiteSpace(elementId)) { throw new ArgumentNullException("elementId"); } var serialised = parameters == null ? null : JsonConvert.SerializeObject(parameters.ToDictionary <RenderParameters, string, object>()) .Replace("\"data-", "\""); var sb = new StringBuilder(); sb.AppendLine(String.Format("var {0} = function() {{", callback)); sb.AppendLine(String.Format("grecaptcha.render(\"{0}\", {1});", elementId, serialised)); sb.AppendLine("};"); return(sb.ToString()); }
private string Render(Template template, RenderParameters renderParams) { var layoutTemplate = FindLayoutTemplate(template); renderParams.LocalVariables["content_for_layout"] = template.Render(renderParams); return(layoutTemplate.Render(renderParams)); }
public override Rss.RssItem[] GetRssFeedItems(CmsPage page, CmsPlaceholderDefinition placeholderDefinition, CmsLanguage langToRenderFor) { base.categoryList = db.fetchCategoryList(langToRenderFor); RenderParameters renderParams = RenderParameters.FromPlaceholderParamList(placeholderDefinition.ParamList); CmsUrlFormat pageLinkFormat = CmsUrlFormat.FullIncludingProtocolAndDomainName; CmsUrlFormat fileLinkFormat = CmsUrlFormat.FullIncludingProtocolAndDomainName; FileAggItem[] filesToShow = FetchAllFilesToShow(page, placeholderDefinition.Identifier, langToRenderFor, renderParams, pageLinkFormat, fileLinkFormat); List <Rss.RssItem> ret = new List <Rss.RssItem>(); foreach (FileAggItem file in filesToShow) { Rss.RssItem rssItem = CreateAndInitRssItem(page, langToRenderFor); // -- link directly to the file url rssItem.Link = new Uri(file.FileDownloadURL, UriKind.RelativeOrAbsolute); rssItem.Guid = new Rss.RssGuid(rssItem.Link); rssItem.Title = file.Title; rssItem.Description = file.Description; rssItem.PubDate_GMT = file.LastModified.ToUniversalTime(); ret.Add(rssItem); } // foreach file return(ret.ToArray()); } // GetRssFeedItems
public DecoratedStyle(Color color, Texture2D decoration) { sprite = new Sprite(decoration); renderParameters = new RenderParameters(); renderParameters.Color = color; this.AssignDefaultValues(); }
public override void Render(Context context, TextWriter result) { IFileSystem fileSystem = context.Registers["file_system"] as IFileSystem ?? Template.FileSystem; string source = fileSystem.ReadTemplateFile(context, _templateName); Template template = Template.Parse(source); List <Block> parentBlocks = FindBlocks(template.Root); Blocks.ForEach(block => { Block pb = parentBlocks.Find(b => b.BlockName == block.BlockName); if (pb != null) { pb.Parent = block.Parent; pb.AddParent(pb.NodeList); pb.NodeList.Clear(); pb.NodeList.AddRange(block.NodeList); } else if (IsExtending(template)) { template.Root.NodeList.Add(block); } }); template.Render(result, RenderParameters.FromContext(context)); }
public override Render Render(RenderParameters parameters) { int space = GivenSize.Width - Child.GivenSize.Width, left; switch (Alignment) { case HorizontalAlignment.Left: left = 0; break; case HorizontalAlignment.Center: left = space / 2; break; case HorizontalAlignment.Right: left = GivenSize.Width - Child.GivenSize.Width; break; default: throw new ArgumentOutOfRangeException(); } var buffer = new string[GivenSize.Height]; var childRender = Child.Render(parameters); for (var i = 0; i < buffer.Length; i++) { buffer[i] = new string(' ', left) + childRender.Buffer[i] + new string(' ', space - left); } return(new Render(buffer, GivenSize)); }
/// <summary> /// スプライトを描画キューに登録します。 /// </summary> /// <param name="sprite">描画するスプライト</param> /// <param name="rect">描画範囲</param> /// <param name="rotate">回転</param> /// <param name="rotateOrigin">中心回転座標(スプライトに対して0~1で指定する)</param> public void Draw(SpriteResource sprite, RawRectangleF rect, float rotate, RawVector2 rotateOrigin) { if (!Begining) { throw new InvalidOperationException("描画操作が開始していません。"); } RenderParameters.AddLast(new SpriteRenderParameter(sprite, rotate, rotateOrigin, rect)); }
/// <summary> Creates a new instance of the Engine class with the given parameters. </summary> public Engine(ScreenParameters screenParameters, ViewportParameters viewportParameters, RenderParameters renderParameters) { _screenParameters = screenParameters; _viewportParameters = viewportParameters; _renderParameters = renderParameters; _cameraConverter = new CameraConverter(_screenParameters, _viewportParameters); }
public GridDocumentRenderer(GridDocument grid, Document document, RenderParameters parameters) { _grid = grid; _document = document; _parameters = parameters; // create a page so that we can get the dimensions. this page will be cleared from the document _documentPageForMetrics = _document.AddPage(_parameters.PageType, _parameters.PageOrientation); }
Task <string> RenderAsync(CultureInfo culture) { var renderParams = new RenderParameters(culture) { LocalVariables = _assigns }; return(Template.Parse("{{number}}").RenderAsync(renderParams)); }
public void Begin() { if (Begining) { throw new InvalidOperationException("描画操作はすでに開始されています。"); } Begining = true; RenderParameters.Clear(); }
public void Render(ViewContext viewContext, TextWriter writer) { if (viewContext == null) { throw new ArgumentNullException("viewContext"); } // Copy data from the view context over to DotLiquid var localVars = new Hash(); if (viewContext.ViewData.Model != null) { var liquidContext = (Dictionary <string, object>)viewContext.ViewData.Model; foreach (var key in liquidContext.Keys) { localVars.Add(key, liquidContext[key]); } //var model = viewContext.ViewData.Model; //if(model.GetType().Name.EndsWith("ViewModel")) //{ // // If it's view model, just copy all properties to the localVars collection // localVars.Merge(Hash.FromAnonymousObject(model)); //} //else //{ // It it's not a view model, just add the model direct as a "model" variable //localVars.Add("model", model); //} } foreach (var item in viewContext.ViewData) { localVars.Add(Template.NamingConvention.GetMemberName(item.Key), item.Value); } foreach (var item in viewContext.TempData) { localVars.Add(Template.NamingConvention.GetMemberName(item.Key), item.Value); } var renderParams = new RenderParameters { LocalVariables = Hash.FromDictionary(localVars) }; // Render the template //var fileContents = VirtualPathProviderHelper.Load(ViewPath); //var template = Template.Parse(fileContents); var template = FindTemplate(ViewPath); string result = Render(template, renderParams); writer.Write(result); //template.Render(writer, renderParams); }
public static void AssertTemplateResult(string expected, string template, Hash localVariables, SyntaxCompatibility syntax = SyntaxCompatibility.DotLiquid20) { var parameters = new RenderParameters(System.Globalization.CultureInfo.CurrentCulture) { LocalVariables = localVariables, SyntaxCompatibilityLevel = syntax }; Assert.AreEqual(expected, Template.Parse(template).Render(parameters)); }
public static void AssertTemplateResult(string expected, string template, Hash localVariables) { var parameters = new RenderParameters(System.Globalization.CultureInfo.CurrentCulture) { LocalVariables = localVariables, }; var tpl = Template.Parse(template); var actual = tpl.Render(parameters); Assert.Equal(expected, actual); }
public static string RenderWithTracing(this Template template, RenderParameters parameters) { var content = template.Render(parameters); if (template.Errors.Any()) { template.Errors.ForEach(e => Trace.TraceError(FlattenException(e))); } return(content); }
public void Draw(SpriteBatch batch, RenderParameters renderParams) { batch.Draw(Texture, Region.Frame, null, renderParams.Color, renderParams.Rotation, renderParams.Origin, renderParams.SpriteEffect, renderParams.Layer); }