private static void ApplyBackgroundColor(String backgroundColorStr, IPropertyContainer element, BackgroundBox
clip)
{
if (backgroundColorStr != null && !CssConstants.TRANSPARENT.Equals(backgroundColorStr))
{
float[] rgbaColor = CssUtils.ParseRgbaColor(backgroundColorStr);
Color color = new DeviceRgb(rgbaColor[0], rgbaColor[1], rgbaColor[2]);
float opacity = rgbaColor[3];
Background backgroundColor = new Background(color, opacity, clip);
element.SetProperty(Property.BACKGROUND, backgroundColor);
}
}
/// <summary>Applies background to an element.</summary>
/// <param name="cssProps">the CSS properties</param>
/// <param name="context">the processor context</param>
/// <param name="element">the element</param>
public static void ApplyBackground(IDictionary <String, String> cssProps, ProcessorContext context, IPropertyContainer
element)
{
String backgroundColorStr = cssProps.Get(CssConstants.BACKGROUND_COLOR);
if (backgroundColorStr != null && !CssConstants.TRANSPARENT.Equals(backgroundColorStr))
{
float[] rgbaColor = CssUtils.ParseRgbaColor(backgroundColorStr);
Color color = new DeviceRgb(rgbaColor[0], rgbaColor[1], rgbaColor[2]);
float opacity = rgbaColor[3];
Background backgroundColor = new Background(color, opacity);
element.SetProperty(Property.BACKGROUND, backgroundColor);
}
String backgroundImageStr = cssProps.Get(CssConstants.BACKGROUND_IMAGE);
if (backgroundImageStr != null && !backgroundImageStr.Equals(CssConstants.NONE))
{
String backgroundRepeatStr = cssProps.Get(CssConstants.BACKGROUND_REPEAT);
PdfXObject image = context.GetResourceResolver().RetrieveImageExtended(CssUtils.ExtractUrl(backgroundImageStr
));
bool repeatX = true;
bool repeatY = true;
if (backgroundRepeatStr != null)
{
repeatX = backgroundRepeatStr.Equals(CssConstants.REPEAT) || backgroundRepeatStr.Equals(CssConstants.REPEAT_X
);
repeatY = backgroundRepeatStr.Equals(CssConstants.REPEAT) || backgroundRepeatStr.Equals(CssConstants.REPEAT_Y
);
}
if (image != null)
{
BackgroundImage backgroundImage = null;
if (image is PdfImageXObject)
{
backgroundImage = new BackgroundImage((PdfImageXObject)image, repeatX, repeatY);
}
else
{
if (image is PdfFormXObject)
{
backgroundImage = new BackgroundImage((PdfFormXObject)image, repeatX, repeatY);
}
else
{
throw new InvalidOperationException();
}
}
element.SetProperty(Property.BACKGROUND_IMAGE, backgroundImage);
}
}
}
/// <summary>Applies font styles to an element.</summary>
/// <param name="cssProps">the CSS props</param>
/// <param name="context">the processor context</param>
/// <param name="stylesContainer">the styles container</param>
/// <param name="element">the element</param>
public static void ApplyFontStyles(IDictionary <String, String> cssProps, ProcessorContext context, IStylesContainer
stylesContainer, IPropertyContainer element)
{
float em = CssUtils.ParseAbsoluteLength(cssProps.Get(CssConstants.FONT_SIZE));
float rem = context.GetCssContext().GetRootFontSize();
if (em != 0)
{
element.SetProperty(Property.FONT_SIZE, UnitValue.CreatePointValue(em));
}
if (cssProps.Get(CssConstants.FONT_FAMILY) != null)
{
// TODO DEVSIX-2534
IList <String> fontFamilies = FontFamilySplitter.SplitFontFamily(cssProps.Get(CssConstants.FONT_FAMILY));
element.SetProperty(Property.FONT, fontFamilies.ToArray(new String[fontFamilies.Count]));
}
if (cssProps.Get(CssConstants.FONT_WEIGHT) != null)
{
element.SetProperty(Property.FONT_WEIGHT, cssProps.Get(CssConstants.FONT_WEIGHT));
}
if (cssProps.Get(CssConstants.FONT_STYLE) != null)
{
element.SetProperty(Property.FONT_STYLE, cssProps.Get(CssConstants.FONT_STYLE));
}
String cssColorPropValue = cssProps.Get(CssConstants.COLOR);
if (cssColorPropValue != null)
{
TransparentColor transparentColor;
if (!CssConstants.TRANSPARENT.Equals(cssColorPropValue))
{
float[] rgbaColor = CssUtils.ParseRgbaColor(cssColorPropValue);
Color color = new DeviceRgb(rgbaColor[0], rgbaColor[1], rgbaColor[2]);
float opacity = rgbaColor[3];
transparentColor = new TransparentColor(color, opacity);
}
else
{
transparentColor = new TransparentColor(ColorConstants.BLACK, 0f);
}
element.SetProperty(Property.FONT_COLOR, transparentColor);
}
// Make sure to place that before text-align applier
String direction = cssProps.Get(CssConstants.DIRECTION);
if (CssConstants.RTL.Equals(direction))
{
element.SetProperty(Property.BASE_DIRECTION, BaseDirection.RIGHT_TO_LEFT);
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.RIGHT);
}
else
{
if (CssConstants.LTR.Equals(direction))
{
element.SetProperty(Property.BASE_DIRECTION, BaseDirection.LEFT_TO_RIGHT);
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.LEFT);
}
}
if (stylesContainer is IElementNode && ((IElementNode)stylesContainer).ParentNode() is IElementNode && CssConstants
.RTL.Equals(((IElementNode)((IElementNode)stylesContainer).ParentNode()).GetStyles().Get(CssConstants.
DIRECTION)) && !element.HasProperty(Property.HORIZONTAL_ALIGNMENT))
{
// We should only apply horizontal alignment if parent has dir attribute or direction property
element.SetProperty(Property.HORIZONTAL_ALIGNMENT, HorizontalAlignment.RIGHT);
}
// Make sure to place that after direction applier
String align = cssProps.Get(CssConstants.TEXT_ALIGN);
if (CssConstants.LEFT.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.LEFT);
}
else
{
if (CssConstants.RIGHT.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.RIGHT);
}
else
{
if (CssConstants.CENTER.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.CENTER);
}
else
{
if (CssConstants.JUSTIFY.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.JUSTIFIED);
element.SetProperty(Property.SPACING_RATIO, 1f);
}
}
}
}
String whiteSpace = cssProps.Get(CssConstants.WHITE_SPACE);
element.SetProperty(Property.NO_SOFT_WRAP_INLINE, CssConstants.NOWRAP.Equals(whiteSpace) || CssConstants.PRE
.Equals(whiteSpace));
String textDecorationProp = cssProps.Get(CssConstants.TEXT_DECORATION);
if (textDecorationProp != null)
{
String[] textDecorations = iText.IO.Util.StringUtil.Split(textDecorationProp, "\\s+");
IList <Underline> underlineList = new List <Underline>();
foreach (String textDecoration in textDecorations)
{
if (CssConstants.BLINK.Equals(textDecoration))
{
logger.Error(iText.Html2pdf.LogMessageConstant.TEXT_DECORATION_BLINK_NOT_SUPPORTED);
}
else
{
if (CssConstants.LINE_THROUGH.Equals(textDecoration))
{
underlineList.Add(new Underline(null, .75f, 0, 0, 1 / 4f, PdfCanvasConstants.LineCapStyle.BUTT));
}
else
{
if (CssConstants.OVERLINE.Equals(textDecoration))
{
underlineList.Add(new Underline(null, .75f, 0, 0, 9 / 10f, PdfCanvasConstants.LineCapStyle.BUTT));
}
else
{
if (CssConstants.UNDERLINE.Equals(textDecoration))
{
underlineList.Add(new Underline(null, .75f, 0, 0, -1 / 10f, PdfCanvasConstants.LineCapStyle.BUTT));
}
else
{
if (CssConstants.NONE.Equals(textDecoration))
{
underlineList = null;
// if none and any other decoration are used together, none is displayed
break;
}
}
}
}
}
}
element.SetProperty(Property.UNDERLINE, underlineList);
}
String textIndent = cssProps.Get(CssConstants.TEXT_INDENT);
if (textIndent != null)
{
UnitValue textIndentValue = CssUtils.ParseLengthValueToPt(textIndent, em, rem);
if (textIndentValue != null)
{
if (textIndentValue.IsPointValue())
{
element.SetProperty(Property.FIRST_LINE_INDENT, textIndentValue.GetValue());
}
else
{
logger.Error(MessageFormatUtil.Format(iText.Html2pdf.LogMessageConstant.CSS_PROPERTY_IN_PERCENTS_NOT_SUPPORTED
, CssConstants.TEXT_INDENT));
}
}
}
String letterSpacing = cssProps.Get(CssConstants.LETTER_SPACING);
if (letterSpacing != null && !letterSpacing.Equals(CssConstants.NORMAL))
{
UnitValue letterSpacingValue = CssUtils.ParseLengthValueToPt(letterSpacing, em, rem);
if (letterSpacingValue.IsPointValue())
{
element.SetProperty(Property.CHARACTER_SPACING, letterSpacingValue.GetValue());
}
}
// browsers ignore values in percents
String wordSpacing = cssProps.Get(CssConstants.WORD_SPACING);
if (wordSpacing != null)
{
UnitValue wordSpacingValue = CssUtils.ParseLengthValueToPt(wordSpacing, em, rem);
if (wordSpacingValue != null)
{
if (wordSpacingValue.IsPointValue())
{
element.SetProperty(Property.WORD_SPACING, wordSpacingValue.GetValue());
}
}
}
// browsers ignore values in percents
String lineHeight = cssProps.Get(CssConstants.LINE_HEIGHT);
// specification does not give auto as a possible lineHeight value
// nevertheless some browsers compute it as normal so we apply the same behaviour.
// What's more, it's basically the same thing as if lineHeight is not set in the first place
if (lineHeight != null && !CssConstants.NORMAL.Equals(lineHeight) && !CssConstants.AUTO.Equals(lineHeight)
)
{
if (CssUtils.IsNumericValue(lineHeight))
{
float?mult = CssUtils.ParseFloat(lineHeight);
if (mult != null)
{
element.SetProperty(Property.LEADING, new Leading(Leading.MULTIPLIED, (float)mult));
}
}
else
{
UnitValue lineHeightValue = CssUtils.ParseLengthValueToPt(lineHeight, em, rem);
if (lineHeightValue != null && lineHeightValue.IsPointValue())
{
element.SetProperty(Property.LEADING, new Leading(Leading.FIXED, lineHeightValue.GetValue()));
}
else
{
if (lineHeightValue != null)
{
element.SetProperty(Property.LEADING, new Leading(Leading.MULTIPLIED, lineHeightValue.GetValue() / 100));
}
}
}
}
else
{
element.SetProperty(Property.LEADING, new Leading(Leading.MULTIPLIED, 1.2f));
}
}
/// <summary>
/// Creates a
/// <see cref="iText.Layout.Borders.Border"/>
/// instance based on specific properties.
/// </summary>
/// <param name="outlineWidth">the outline width</param>
/// <param name="outlineStyle">the outline style</param>
/// <param name="outlineColor">the outline color</param>
/// <param name="em">the em value</param>
/// <param name="rem">the root em value</param>
/// <returns>the border</returns>
public static Border GetCertainBorder(String outlineWidth, String outlineStyle, String outlineColor, float
em, float rem)
{
if (outlineStyle == null || CssConstants.NONE.Equals(outlineStyle))
{
return(null);
}
if (outlineWidth == null)
{
outlineWidth = CssDefaults.GetDefaultValue(CssConstants.OUTLINE_WIDTH);
}
float outlineWidthValue;
if (CssConstants.BORDER_WIDTH_VALUES.Contains(outlineWidth))
{
if (CssConstants.THIN.Equals(outlineWidth))
{
outlineWidth = "1px";
}
else
{
if (CssConstants.MEDIUM.Equals(outlineWidth))
{
outlineWidth = "2px";
}
else
{
if (CssConstants.THICK.Equals(outlineWidth))
{
outlineWidth = "3px";
}
}
}
}
UnitValue unitValue = CssUtils.ParseLengthValueToPt(outlineWidth, em, rem);
if (unitValue == null)
{
return(null);
}
if (unitValue.IsPercentValue())
{
LOGGER.Error("outline-width in percents is not supported");
return(null);
}
outlineWidthValue = unitValue.GetValue();
Border outline = null;
if (outlineWidthValue > 0)
{
DeviceRgb color = (DeviceRgb)ColorConstants.BLACK;
float opacity = 1f;
if (outlineColor != null)
{
if (!CssConstants.TRANSPARENT.Equals(outlineColor))
{
float[] rgbaColor = CssUtils.ParseRgbaColor(outlineColor);
color = new DeviceRgb(rgbaColor[0], rgbaColor[1], rgbaColor[2]);
opacity = rgbaColor[3];
}
else
{
opacity = 0f;
}
}
else
{
if (CssConstants.GROOVE.Equals(outlineStyle) || CssConstants.RIDGE.Equals(outlineStyle) || CssConstants.INSET
.Equals(outlineStyle) || CssConstants.OUTSET.Equals(outlineStyle))
{
color = new DeviceRgb(212, 208, 200);
}
}
switch (outlineStyle)
{
case CssConstants.SOLID:
case CssConstants.AUTO: {
outline = new SolidBorder(color, outlineWidthValue, opacity);
break;
}
case CssConstants.DASHED: {
outline = new DashedBorder(color, outlineWidthValue, opacity);
break;
}
case CssConstants.DOTTED: {
outline = new DottedBorder(color, outlineWidthValue, opacity);
break;
}
case CssConstants.DOUBLE: {
outline = new DoubleBorder(color, outlineWidthValue, opacity);
break;
}
case CssConstants.GROOVE: {
outline = new GrooveBorder(color, outlineWidthValue, opacity);
break;
}
case CssConstants.RIDGE: {
outline = new RidgeBorder(color, outlineWidthValue, opacity);
break;
}
case CssConstants.INSET: {
outline = new InsetBorder(color, outlineWidthValue, opacity);
break;
}
case CssConstants.OUTSET: {
outline = new OutsetBorder(color, outlineWidthValue, opacity);
break;
}
default: {
outline = null;
break;
}
}
}
return(outline);
}
/// <summary>Applies font styles to an element.</summary>
/// <param name="cssProps">the CSS props</param>
/// <param name="context">the processor context</param>
/// <param name="stylesContainer">the styles container</param>
/// <param name="element">the element</param>
public static void ApplyFontStyles(IDictionary <String, String> cssProps, ProcessorContext context, IStylesContainer
stylesContainer, IPropertyContainer element)
{
float em = CssUtils.ParseAbsoluteLength(cssProps.Get(CssConstants.FONT_SIZE));
float rem = context.GetCssContext().GetRootFontSize();
if (em != 0)
{
element.SetProperty(Property.FONT_SIZE, UnitValue.CreatePointValue(em));
}
if (cssProps.Get(CssConstants.FONT_FAMILY) != null)
{
// TODO DEVSIX-2534
IList <String> fontFamilies = FontFamilySplitter.SplitFontFamily(cssProps.Get(CssConstants.FONT_FAMILY));
element.SetProperty(Property.FONT, fontFamilies.ToArray(new String[fontFamilies.Count]));
}
if (cssProps.Get(CssConstants.FONT_WEIGHT) != null)
{
element.SetProperty(Property.FONT_WEIGHT, cssProps.Get(CssConstants.FONT_WEIGHT));
}
if (cssProps.Get(CssConstants.FONT_STYLE) != null)
{
element.SetProperty(Property.FONT_STYLE, cssProps.Get(CssConstants.FONT_STYLE));
}
String cssColorPropValue = cssProps.Get(CssConstants.COLOR);
if (cssColorPropValue != null)
{
TransparentColor transparentColor;
if (!CssConstants.TRANSPARENT.Equals(cssColorPropValue))
{
float[] rgbaColor = CssUtils.ParseRgbaColor(cssColorPropValue);
Color color = new DeviceRgb(rgbaColor[0], rgbaColor[1], rgbaColor[2]);
float opacity = rgbaColor[3];
transparentColor = new TransparentColor(color, opacity);
}
else
{
transparentColor = new TransparentColor(ColorConstants.BLACK, 0f);
}
element.SetProperty(Property.FONT_COLOR, transparentColor);
}
// Make sure to place that before text-align applier
String direction = cssProps.Get(CssConstants.DIRECTION);
if (CssConstants.RTL.Equals(direction))
{
element.SetProperty(Property.BASE_DIRECTION, BaseDirection.RIGHT_TO_LEFT);
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.RIGHT);
}
else
{
if (CssConstants.LTR.Equals(direction))
{
element.SetProperty(Property.BASE_DIRECTION, BaseDirection.LEFT_TO_RIGHT);
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.LEFT);
}
}
if (stylesContainer is IElementNode && ((IElementNode)stylesContainer).ParentNode() is IElementNode && CssConstants
.RTL.Equals(((IElementNode)((IElementNode)stylesContainer).ParentNode()).GetStyles().Get(CssConstants.
DIRECTION)) && !element.HasProperty(Property.HORIZONTAL_ALIGNMENT))
{
// We should only apply horizontal alignment if parent has dir attribute or direction property
element.SetProperty(Property.HORIZONTAL_ALIGNMENT, HorizontalAlignment.RIGHT);
}
// Make sure to place that after direction applier
String align = cssProps.Get(CssConstants.TEXT_ALIGN);
if (CssConstants.LEFT.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.LEFT);
}
else
{
if (CssConstants.RIGHT.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.RIGHT);
}
else
{
if (CssConstants.CENTER.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.CENTER);
}
else
{
if (CssConstants.JUSTIFY.Equals(align))
{
element.SetProperty(Property.TEXT_ALIGNMENT, TextAlignment.JUSTIFIED);
element.SetProperty(Property.SPACING_RATIO, 1f);
}
}
}
}
String whiteSpace = cssProps.Get(CssConstants.WHITE_SPACE);
element.SetProperty(Property.NO_SOFT_WRAP_INLINE, CssConstants.NOWRAP.Equals(whiteSpace) || CssConstants.PRE
.Equals(whiteSpace));
float[] colors = new float[4];
Color textDecorationColor;
float opacity_1 = 1f;
String textDecorationColorProp = cssProps.Get(CssConstants.TEXT_DECORATION_COLOR);
if (textDecorationColorProp == null || CssConstants.CURRENTCOLOR.Equals(textDecorationColorProp))
{
if (element.GetProperty <TransparentColor>(Property.FONT_COLOR) != null)
{
TransparentColor transparentColor = element.GetProperty <TransparentColor>(Property.FONT_COLOR);
textDecorationColor = transparentColor.GetColor();
opacity_1 = transparentColor.GetOpacity();
}
else
{
textDecorationColor = ColorConstants.BLACK;
}
}
else
{
if (textDecorationColorProp.StartsWith("hsl"))
{
logger.Error(iText.Html2pdf.LogMessageConstant.HSL_COLOR_NOT_SUPPORTED);
textDecorationColor = ColorConstants.BLACK;
}
else
{
colors = CssUtils.ParseRgbaColor(textDecorationColorProp);
textDecorationColor = new DeviceRgb(colors[0], colors[1], colors[2]);
opacity_1 = colors[3];
}
}
String textDecorationLineProp = cssProps.Get(CssConstants.TEXT_DECORATION_LINE);
if (textDecorationLineProp != null)
{
String[] textDecorationLines = iText.IO.Util.StringUtil.Split(textDecorationLineProp, "\\s+");
IList <Underline> underlineList = new List <Underline>();
foreach (String textDecorationLine in textDecorationLines)
{
if (CssConstants.BLINK.Equals(textDecorationLine))
{
logger.Error(iText.Html2pdf.LogMessageConstant.TEXT_DECORATION_BLINK_NOT_SUPPORTED);
}
else
{
if (CssConstants.LINE_THROUGH.Equals(textDecorationLine))
{
underlineList.Add(new Underline(textDecorationColor, opacity_1, .75f, 0, 0, 1 / 4f, PdfCanvasConstants.LineCapStyle
.BUTT));
}
else
{
if (CssConstants.OVERLINE.Equals(textDecorationLine))
{
underlineList.Add(new Underline(textDecorationColor, opacity_1, .75f, 0, 0, 9 / 10f, PdfCanvasConstants.LineCapStyle
.BUTT));
}
else
{
if (CssConstants.UNDERLINE.Equals(textDecorationLine))
{
underlineList.Add(new Underline(textDecorationColor, opacity_1, .75f, 0, 0, -1 / 10f, PdfCanvasConstants.LineCapStyle
.BUTT));
}
else
{
if (CssConstants.NONE.Equals(textDecorationLine))
{
underlineList = null;
// if none and any other decoration are used together, none is displayed
break;
}
}
}
}
}
}
element.SetProperty(Property.UNDERLINE, underlineList);
}
String textIndent = cssProps.Get(CssConstants.TEXT_INDENT);
if (textIndent != null)
{
UnitValue textIndentValue = CssUtils.ParseLengthValueToPt(textIndent, em, rem);
if (textIndentValue != null)
{
if (textIndentValue.IsPointValue())
{
element.SetProperty(Property.FIRST_LINE_INDENT, textIndentValue.GetValue());
}
else
{
logger.Error(MessageFormatUtil.Format(iText.Html2pdf.LogMessageConstant.CSS_PROPERTY_IN_PERCENTS_NOT_SUPPORTED
, CssConstants.TEXT_INDENT));
}
}
}
String letterSpacing = cssProps.Get(CssConstants.LETTER_SPACING);
if (letterSpacing != null && !CssConstants.NORMAL.Equals(letterSpacing))
{
UnitValue letterSpacingValue = CssUtils.ParseLengthValueToPt(letterSpacing, em, rem);
if (letterSpacingValue.IsPointValue())
{
element.SetProperty(Property.CHARACTER_SPACING, letterSpacingValue.GetValue());
}
}
// browsers ignore values in percents
String wordSpacing = cssProps.Get(CssConstants.WORD_SPACING);
if (wordSpacing != null)
{
UnitValue wordSpacingValue = CssUtils.ParseLengthValueToPt(wordSpacing, em, rem);
if (wordSpacingValue != null)
{
if (wordSpacingValue.IsPointValue())
{
element.SetProperty(Property.WORD_SPACING, wordSpacingValue.GetValue());
}
}
}
// browsers ignore values in percents
String lineHeight = cssProps.Get(CssConstants.LINE_HEIGHT);
SetLineHeight(element, lineHeight, em, rem);
SetLineHeightByLeading(element, lineHeight, em, rem);
}
