/// <summary>Resolves counters.</summary> /// <param name="counterName">the counter name</param> /// <param name="counterSeparatorStr">the counter separator</param> /// <param name="listSymbolType">the list symbol type</param> /// <returns> /// the counters as a /// <see cref="System.String"/> /// </returns> public virtual String ResolveCounters(String counterName, String counterSeparatorStr, CounterDigitsGlyphStyle listSymbolType) { IList <String> resolvedCounters = new List <String>(); if (counters.ContainsKey(counterName)) { foreach (int?value in counters.Get(counterName)) { resolvedCounters.Add(HtmlUtils.ConvertNumberAccordingToGlyphStyle(listSymbolType, (int)value)); } } int?currentValue = counterValues.Get(counterName); if (currentValue != null) { resolvedCounters.Add(HtmlUtils.ConvertNumberAccordingToGlyphStyle(listSymbolType, (int)currentValue)); } if (resolvedCounters.IsEmpty()) { return(HtmlUtils.ConvertNumberAccordingToGlyphStyle(listSymbolType, 0)); } else { return(BuildCountersStringFromList(resolvedCounters, counterSeparatorStr)); } }
/// <summary>Gets target-counter value for specified ID and counterName.</summary> /// <remarks>Gets target-counter value for specified ID and counterName. Value is converted according to listSymbolType. /// </remarks> /// <param name="id"> /// ID of the element. The first call adds ID to the Map, which means we require its value. /// The second call returns corresponding value if we already encountered corresponding element /// </param> /// <param name="counterName"> /// name of the counter. The first call adds counterName to the Map, /// which means we require its value. /// The second call returns corresponding value if we already encountered corresponding element /// </param> /// <param name="listSymbolType">the list symbol type to convert counter's value. null if conversion is not required. /// </param> /// <returns>target-counter value.</returns> public virtual String ResolveTargetCounter(String id, String counterName, CounterDigitsGlyphStyle listSymbolType ) { int?counterValue = null; if (targetCounterMap.ContainsKey(id)) { IDictionary <String, int?> countersForThisId = targetCounterMap.Get(id); if (countersForThisId.ContainsKey(counterName)) { counterValue = countersForThisId.Get(counterName); } else { countersForThisId.Put(counterName, null); } } else { targetCounterMap.Put(id, new Dictionary <String, int?>()); targetCounterMap.Get(id).Put(counterName, null); } return(counterValue == null ? null : HtmlUtils.ConvertNumberAccordingToGlyphStyle(listSymbolType, (int)counterValue )); }
/* (non-Javadoc) * @see com.itextpdf.layout.renderer.TextRenderer#layout(com.itextpdf.layout.layout.LayoutContext) */ public override LayoutResult Layout(LayoutContext layoutContext) { PageCountType pageCountType = (PageCountType)this.GetProperty <PageCountType?>(Html2PdfProperty.PAGE_COUNT_TYPE ); String previousText = GetText().ToString(); // If typography is enabled and the page counter element has a non-default direction, // iText processes its content (see LineRenderer#updateBidiLevels) before layouting it. // This might result in an ArrayIndexOutOfBounds exception, because currently iText updates the page counter's content on layout. // To solve this, this workaround has been implemented: the renderer's strToBeConverted shouldn't be updated by layout. bool textHasBeenReplaced = false; if (pageCountType == PageCountType.CURRENT_PAGE_NUMBER) { SetText(HtmlUtils.ConvertNumberAccordingToGlyphStyle(digitsGlyphStyle, layoutContext.GetArea().GetPageNumber ())); textHasBeenReplaced = true; } else { if (pageCountType == PageCountType.TOTAL_PAGE_COUNT) { IRenderer rootRenderer = this; while (rootRenderer is AbstractRenderer && ((AbstractRenderer)rootRenderer).GetParent() != null) { rootRenderer = ((AbstractRenderer)rootRenderer).GetParent(); } if (rootRenderer is HtmlDocumentRenderer && ((HtmlDocumentRenderer)rootRenderer).GetEstimatedNumberOfPages () > 0) { SetText(HtmlUtils.ConvertNumberAccordingToGlyphStyle(digitsGlyphStyle, ((HtmlDocumentRenderer)rootRenderer ).GetEstimatedNumberOfPages())); textHasBeenReplaced = true; } else { if (rootRenderer is DocumentRenderer && rootRenderer.GetModelElement() is Document) { SetText(HtmlUtils.ConvertNumberAccordingToGlyphStyle(digitsGlyphStyle, ((Document)rootRenderer.GetModelElement ()).GetPdfDocument().GetNumberOfPages())); textHasBeenReplaced = true; } } } } LayoutResult result = base.Layout(layoutContext); if (textHasBeenReplaced) { SetText(previousText); } return(result); }
/// <summary>Resolves a counter.</summary> /// <param name="counterName">the counter name</param> /// <param name="listSymbolType">the list symbol type</param> /// <returns> /// the counter value as a /// <see cref="System.String"/> /// </returns> public virtual String ResolveCounter(String counterName, CounterDigitsGlyphStyle listSymbolType) { int?result = counterValues.Get(counterName); if (result == null) { if (!counters.ContainsKey(counterName) || counters.Get(counterName).IsEmpty()) { result = 0; } else { result = counters.Get(counterName).JGetLast(); } } return(HtmlUtils.ConvertNumberAccordingToGlyphStyle(listSymbolType, (int)result)); }
/// <summary><inheritDoc/></summary> public override LayoutResult Layout(LayoutContext layoutContext) { String previousText = GetText().ToString(); int? page = TargetCounterHandler.GetPageByID(this, target); if (page == null) { SetText(UNDEFINED_VALUE); } else { SetText(HtmlUtils.ConvertNumberAccordingToGlyphStyle(digitsGlyphStyle, (int)page)); } LayoutResult result = base.Layout(layoutContext); SetText(previousText); return(result); }
/// <summary>Gets target-counter value for specified ID and counterName.</summary> /// <remarks>Gets target-counter value for specified ID and counterName. Value is converted according to listSymbolType. /// </remarks> /// <param name="id"> /// ID of the element. The first call adds ID at the Map, /// which means we require its value. The second call returns corresponding value /// if we already encountered this element /// </param> /// <param name="counterName"> /// name of the counter. The first call adds name at the Map, /// which means we require its value. The second call returns corresponding value /// if we already encountered this element /// </param> /// <param name="counterSeparatorStr">separator to separate counters values.</param> /// <param name="listSymbolType">the list symbol type to convert counter's value. null if conversion is not required. /// </param> /// <returns>target-counter value.</returns> public virtual String ResolveTargetCounters(String id, String counterName, String counterSeparatorStr, CounterDigitsGlyphStyle listSymbolType) { String countersStr = null; if (targetCountersMap.ContainsKey(id)) { IDictionary <String, String> countersForThisId = targetCountersMap.Get(id); if (countersForThisId.ContainsKey(counterName)) { countersStr = countersForThisId.Get(counterName); } else { countersForThisId.Put(counterName, null); } } else { targetCountersMap.Put(id, new Dictionary <String, String>()); targetCountersMap.Get(id).Put(counterName, null); } if (countersStr == null) { return(null); } else { String[] resolvedCounters = iText.IO.Util.StringUtil.Split(countersStr, "\\."); IList <String> convertedCounters = new List <String>(); foreach (String counter in resolvedCounters) { convertedCounters.Add(HtmlUtils.ConvertNumberAccordingToGlyphStyle(listSymbolType, Convert.ToInt32(counter , System.Globalization.CultureInfo.InvariantCulture))); } return(BuildCountersStringFromList(convertedCounters, counterSeparatorStr)); } }