/// <summary>Resolve the font size stored inside the passed renderer</summary>
/// <param name="renderer">renderer containing the font size declaration</param>
/// <param name="parentFontSize">parent font size to fall back on if the renderer does not contain a font size declarations or if the stored declaration is invalid
/// </param>
/// <returns>float containing the font-size, or the parent font size if the renderer's declaration cannot be resolved
/// </returns>
public static float ResolveFontSize(ISvgTextNodeRenderer renderer, float parentFontSize)
{
//Use own font-size declaration if it is present, parent's otherwise
float fontSize = float.NaN;
String elementFontSize = renderer.GetAttribute(SvgConstants.Attributes.FONT_SIZE);
if (null != elementFontSize && !String.IsNullOrEmpty(elementFontSize))
{
if (CssUtils.IsRelativeValue(elementFontSize) || CommonCssConstants.LARGER.Equals(elementFontSize) || CommonCssConstants
.SMALLER.Equals(elementFontSize))
{
// TODO DEVSIX-2866 Support rem value for svgs
fontSize = CssUtils.ParseRelativeFontSize(elementFontSize, parentFontSize);
}
else
{
fontSize = CssUtils.ParseAbsoluteFontSize(elementFontSize, CommonCssConstants.PX);
}
}
if ((float.IsNaN(fontSize)) || fontSize < 0f)
{
fontSize = parentFontSize;
}
return(fontSize);
}
public override float GetCurrentFontSize()
{
String fontSizeValue = GetAttribute(SvgConstants.Attributes.FONT_SIZE);
if (fontSizeValue == null)
{
fontSizeValue = CssDefaults.GetDefaultValue(CommonCssConstants.FONT_SIZE);
}
return(CssUtils.ParseAbsoluteFontSize(fontSizeValue));
}
// TODO (DEVSIX-3596) Add support of 'lh' 'ch' units and viewport-relative units
private float ParseFontRelativeOrAbsoluteLengthOnMarker(String length)
{
float value = 0f;
if (CssUtils.IsMetricValue(length) || CssUtils.IsNumericValue(length))
{
value = CssUtils.ParseAbsoluteLength(length);
}
else
{
if (CssUtils.IsFontRelativeValue(length))
{
// Defaut font-size is medium
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(CommonCssConstants.MEDIUM));
// Different browsers process font-relative units for markers differently.
// We do it according to the css specification.
if (CssUtils.IsRemValue(length))
{
ISvgNodeRenderer rootElement = GetSvgRootElement(GetParent());
if (rootElement != null && rootElement.GetAttribute(CommonCssConstants.FONT_SIZE) != null)
{
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(rootElement.GetAttribute(CommonCssConstants
.FONT_SIZE)));
}
}
else
{
if (CssUtils.IsEmValue(length))
{
ISvgNodeRenderer parentElement = this.GetParent();
if (parentElement != null && parentElement.GetAttribute(CommonCssConstants.FONT_SIZE) != null)
{
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(parentElement.GetAttribute(CommonCssConstants
.FONT_SIZE)));
}
}
else
{
if (CssUtils.IsExValue(length))
{
if (this.GetAttribute(CommonCssConstants.FONT_SIZE) != null)
{
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(this.GetAttribute(CommonCssConstants
.FONT_SIZE)));
}
}
}
}
}
}
return(value);
}
internal virtual float ParseDimension(CssContextNode node, String content, float maxAvailableDimension, float
additionalWidthFix)
{
float fontSize = CssUtils.ParseAbsoluteFontSize(node.GetStyles().Get(CssConstants.FONT_SIZE));
UnitValue unitValue = CssUtils.ParseLengthValueToPt(content, fontSize, 0);
if (unitValue == null)
{
return(0);
}
if (unitValue.IsPointValue())
{
return(unitValue.GetValue() + additionalWidthFix);
}
return(maxAvailableDimension * unitValue.GetValue() / 100f);
}
/// <summary>Create an instance of the context that is used to store information when converting SVG.</summary>
/// <param name="resourceResolver">
/// instance of
/// <see cref="iText.StyledXmlParser.Resolver.Resource.ResourceResolver"/>
/// </param>
/// <param name="fontProvider">
/// instance of
/// <see cref="iText.Layout.Font.FontProvider"/>
/// </param>
/// <param name="svgRootRenderer">svg element that is root for current file</param>
public SvgDrawContext(ResourceResolver resourceResolver, FontProvider fontProvider, ISvgNodeRenderer svgRootRenderer
)
{
if (resourceResolver == null)
{
resourceResolver = new ResourceResolver(null);
}
this.resourceResolver = resourceResolver;
if (fontProvider == null)
{
fontProvider = new BasicFontProvider();
}
this.fontProvider = fontProvider;
if (svgRootRenderer is AbstractSvgNodeRenderer)
{
remValue = ((AbstractSvgNodeRenderer)svgRootRenderer).GetCurrentFontSize();
}
else
{
// default font-size value
remValue = CssUtils.ParseAbsoluteFontSize(CssDefaults.GetDefaultValue(CommonCssConstants.FONT_SIZE));
}
}
/// <summary>Sets the root font size.</summary>
/// <param name="fontSizeStr">the new root font size</param>
public virtual void SetRootFontSize(String fontSizeStr)
{
this.rootFontSize = CssUtils.ParseAbsoluteFontSize(fontSizeStr);
}
/* (non-Javadoc)
* @see com.itextpdf.html2pdf.css.resolve.ICssResolver#resolveStyles(com.itextpdf.html2pdf.html.node.INode, com.itextpdf.html2pdf.css.resolve.CssContext)
*/
private IDictionary <String, String> ResolveStyles(INode element, CssContext context)
{
IList <CssRuleSet> ruleSets = new List <CssRuleSet>();
ruleSets.Add(new CssRuleSet(null, UserAgentCss.GetStyles(element)));
if (element is IElementNode)
{
ruleSets.Add(new CssRuleSet(null, HtmlStylesToCssConverter.Convert((IElementNode)element)));
}
ruleSets.AddAll(cssStyleSheet.GetCssRuleSets(element, deviceDescription));
if (element is IElementNode)
{
String styleAttribute = ((IElementNode)element).GetAttribute(AttributeConstants.STYLE);
if (styleAttribute != null)
{
ruleSets.Add(new CssRuleSet(null, CssRuleSetParser.ParsePropertyDeclarations(styleAttribute)));
}
}
IDictionary <String, String> elementStyles = CssStyleSheet.ExtractStylesFromRuleSets(ruleSets);
if (CssConstants.CURRENTCOLOR.Equals(elementStyles.Get(CssConstants.COLOR)))
{
// css-color-3/#currentcolor:
// If the ‘currentColor’ keyword is set on the ‘color’ property itself, it is treated as ‘color: inherit’.
elementStyles.Put(CssConstants.COLOR, CssConstants.INHERIT);
}
String parentFontSizeStr = null;
if (element.ParentNode() is IStylesContainer)
{
IStylesContainer parentNode = (IStylesContainer)element.ParentNode();
IDictionary <String, String> parentStyles = parentNode.GetStyles();
if (parentStyles == null && !(element.ParentNode() is IDocumentNode))
{
ILog logger = LogManager.GetLogger(typeof(iText.Html2pdf.Css.Resolve.DefaultCssResolver));
logger.Error(iText.Html2pdf.LogMessageConstant.ERROR_RESOLVING_PARENT_STYLES);
}
if (parentStyles != null)
{
ICollection <IStyleInheritance> inheritanceRules = new HashSet <IStyleInheritance>();
inheritanceRules.Add(cssInheritance);
foreach (KeyValuePair <String, String> entry in parentStyles)
{
elementStyles = StyleUtil.MergeParentStyleDeclaration(elementStyles, entry.Key, entry.Value, parentStyles.
Get(CommonCssConstants.FONT_SIZE), inheritanceRules);
}
parentFontSizeStr = parentStyles.Get(CssConstants.FONT_SIZE);
}
}
String elementFontSize = elementStyles.Get(CssConstants.FONT_SIZE);
if (CssUtils.IsRelativeValue(elementFontSize) || CssConstants.LARGER.Equals(elementFontSize) || CssConstants
.SMALLER.Equals(elementFontSize))
{
float baseFontSize;
if (CssUtils.IsRemValue(elementFontSize))
{
baseFontSize = context.GetRootFontSize();
}
else
{
if (parentFontSizeStr == null)
{
baseFontSize = CssUtils.ParseAbsoluteFontSize(CssDefaults.GetDefaultValue(CssConstants.FONT_SIZE));
}
else
{
baseFontSize = CssUtils.ParseAbsoluteLength(parentFontSizeStr);
}
}
float absoluteFontSize = CssUtils.ParseRelativeFontSize(elementFontSize, baseFontSize);
// Format to 4 decimal places to prevent differences between Java and C#
elementStyles.Put(CssConstants.FONT_SIZE, DecimalFormatUtil.FormatNumber(absoluteFontSize, "0.####") + CssConstants
.PT);
}
else
{
elementStyles.Put(CssConstants.FONT_SIZE, Convert.ToString(CssUtils.ParseAbsoluteFontSize(elementFontSize)
, System.Globalization.CultureInfo.InvariantCulture) + CssConstants.PT);
}
// Update root font size
if (element is IElementNode && TagConstants.HTML.Equals(((IElementNode)element).Name()))
{
context.SetRootFontSize(elementStyles.Get(CssConstants.FONT_SIZE));
}
ICollection <String> keys = new HashSet <String>();
foreach (KeyValuePair <String, String> entry in elementStyles)
{
if (CssConstants.INITIAL.Equals(entry.Value) || CssConstants.INHERIT.Equals(entry.Value))
{
// if "inherit" is not resolved till now, parents don't have it
keys.Add(entry.Key);
}
}
foreach (String key in keys)
{
elementStyles.Put(key, CssDefaults.GetDefaultValue(key));
}
// This is needed for correct resolving of content property, so doing it right here
CounterProcessorUtil.ProcessCounters(elementStyles, context, element);
ResolveContentProperty(elementStyles, element, context);
return(elementStyles);
}
/// <summary>Return font-size of the current element</summary>
/// <returns>absolute value of font-size</returns>
public virtual float GetCurrentFontSize()
{
// TODO DEVSIX-4140 check work of this method with relative unit
return(CssUtils.ParseAbsoluteFontSize(GetAttribute(SvgConstants.Attributes.FONT_SIZE)));
}
){kind=link}
){kind=link}
){kind=link}