/// <summary>Applies opacity to an element.</summary> /// <param name="cssProps">the CSS properties</param> /// <param name="context">the processor context</param> /// <param name="container">the container element</param> public static void ApplyOpacity(IDictionary<String, String> cssProps, ProcessorContext context, IPropertyContainer container) { float? opacity = CssDimensionParsingUtils.ParseFloat(cssProps.Get(CssConstants.OPACITY)); if (opacity != null) { container.SetProperty(Property.OPACITY, opacity); } }
/// <summary>Resolves a normalized form name.</summary> /// <param name="name">the proposed name</param> /// <returns>the resolved name</returns> private String ResolveNormalizedFormName(String name) { int separatorIndex = name.LastIndexOf(NAME_COUNT_SEPARATOR); int?nameIndex = null; if (separatorIndex != -1 && separatorIndex < name.Length) { String numberString = name.Substring(separatorIndex + 1); nameIndex = CssDimensionParsingUtils.ParseInteger(numberString); //Treat number as index only in case it is positive if (nameIndex != null && nameIndex > 0) { name = name.JSubstring(0, separatorIndex); } } int?savedIndex = names.Get(name); int indexToSave = savedIndex != null ? savedIndex.Value + 1 : 0; if (nameIndex != null && indexToSave < nameIndex.Value) { indexToSave = nameIndex.Value; } names.Put(name, indexToSave); return(indexToSave == 0 ? name : name + NAME_COUNT_SEPARATOR + indexToSave.ToString()); }
/// <summary> /// Creates a new /// <see cref="ColTagWorker"/> /// instance. /// </summary> /// <param name="element">the element</param> /// <param name="context">the context</param> public ColTagWorker(IElementNode element, ProcessorContext context) { int?span = CssDimensionParsingUtils.ParseInteger(element.GetAttribute(AttributeConstants.SPAN)); col = new ColWrapper(span != null ? (int)span : 1); col.SetLang(element.GetAttribute(AttributeConstants.LANG)); }
// element.setProperty(Property.POSITION, LayoutPosition.FIXED); // float em = CssUtils.parseAbsoluteLength(cssProps.get(CommonCssConstants.FONT_SIZE)); // applyLeftProperty(cssProps, element, em, Property.X); // applyTopProperty(cssProps, element, em, Property.Y); // TODO DEVSIX-4104 support "fixed" value of position property /// <summary>Applies left, right, top, and bottom properties.</summary> /// <param name="cssProps">the CSS properties</param> /// <param name="context">the processor context</param> /// <param name="element">the element</param> /// <param name="position">the position</param> private static void ApplyLeftRightTopBottom(IDictionary <String, String> cssProps, ProcessorContext context , IPropertyContainer element, String position) { float em = CssDimensionParsingUtils.ParseAbsoluteLength(cssProps.Get(CssConstants.FONT_SIZE)); float rem = context.GetCssContext().GetRootFontSize(); if (CssConstants.RELATIVE.Equals(position) && cssProps.ContainsKey(CssConstants.LEFT) && cssProps.ContainsKey (CssConstants.RIGHT)) { // When both the right CSS property and the left CSS property are defined, the position of the element is overspecified. // In that case, the left value has precedence when the container is left-to-right (that is that the right computed value is set to -left), // and the right value has precedence when the container is right-to-left (that is that the left computed value is set to -right). bool isRtl = CssConstants.RTL.Equals(cssProps.Get(CssConstants.DIRECTION)); if (isRtl) { ApplyRightProperty(cssProps, element, em, rem, Property.RIGHT); } else { ApplyLeftProperty(cssProps, element, em, rem, Property.LEFT); } } else { ApplyLeftProperty(cssProps, element, em, rem, Property.LEFT); ApplyRightProperty(cssProps, element, em, rem, Property.RIGHT); } ApplyTopProperty(cssProps, element, em, rem, Property.TOP); ApplyBottomProperty(cssProps, element, em, rem, Property.BOTTOM); }
/// <summary> /// Creates a new /// <see cref="LiTagWorker"/> /// instance. /// </summary> /// <param name="element">the element</param> /// <param name="context">the context</param> public LiTagWorker(IElementNode element, ProcessorContext context) { listItem = new ListItem(); if (element.GetAttribute(AttributeConstants.VALUE) != null) { int?indexValue = (int?)CssDimensionParsingUtils.ParseInteger(element.GetAttribute(AttributeConstants.VALUE )); if (indexValue != null) { listItem.SetListSymbolOrdinalValue(indexValue.Value); } } if (!(context.GetState().Top() is UlOlTagWorker)) { listItem.SetProperty(Property.LIST_SYMBOL_POSITION, ListSymbolPosition.INSIDE); float em = CssDimensionParsingUtils.ParseAbsoluteLength(element.GetStyles().Get(CssConstants.FONT_SIZE)); if (TagConstants.LI.Equals(element.Name())) { ListStyleApplierUtil.SetDiscStyle(listItem, em); } else { listItem.SetProperty(Property.LIST_SYMBOL, null); } list = new List(); list.Add(listItem); } inlineHelper = new WaitingInlineElementsHelper(element.GetStyles().Get(CssConstants.WHITE_SPACE), element. GetStyles().Get(CssConstants.TEXT_TRANSFORM)); AccessiblePropHelper.TrySetLangAttribute(listItem, element); }
/// <summary>Applies outlines 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 ApplyOutlines(IDictionary <String, String> cssProps, ProcessorContext context, IPropertyContainer element) { float em = CssDimensionParsingUtils.ParseAbsoluteLength(cssProps.Get(CssConstants.FONT_SIZE)); float rem = context.GetCssContext().GetRootFontSize(); Border outline = GetCertainBorder(cssProps.Get(CssConstants.OUTLINE_WIDTH), cssProps.Get(CssConstants.OUTLINE_STYLE ), GetSpecificOutlineColorOrDefaultColor(cssProps, CssConstants.OUTLINE_COLOR), em, rem); if (outline != null) { element.SetProperty(Property.OUTLINE, outline); } if (cssProps.Get(CssConstants.OUTLINE_OFFSET) != null && element.GetProperty <Border>(Property.OUTLINE) != null) { UnitValue unitValue = CssDimensionParsingUtils.ParseLengthValueToPt(cssProps.Get(CssConstants.OUTLINE_OFFSET ), em, rem); if (unitValue != null) { if (unitValue.IsPercentValue()) { LOGGER.Error("outline-width in percents is not supported"); } else { if (unitValue.GetValue() != 0) { element.SetProperty(Property.OUTLINE_OFFSET, unitValue.GetValue()); } } } } }
/* (non-Javadoc) * @see com.itextpdf.html2pdf.css.apply.impl.BlockCssApplier#apply(com.itextpdf.html2pdf.attach.ProcessorContext, com.itextpdf.html2pdf.html.node.IStylesContainer, com.itextpdf.html2pdf.attach.ITagWorker) */ public override void Apply(ProcessorContext context, IStylesContainer stylesContainer, ITagWorker tagWorker ) { if (!(tagWorker.GetElementResult() is List)) { return; } IDictionary <String, String> css = stylesContainer.GetStyles(); List list = (List)tagWorker.GetElementResult(); if (CssConstants.INSIDE.Equals(css.Get(CssConstants.LIST_STYLE_POSITION))) { list.SetProperty(Property.LIST_SYMBOL_POSITION, ListSymbolPosition.INSIDE); } else { list.SetProperty(Property.LIST_SYMBOL_POSITION, ListSymbolPosition.OUTSIDE); } ListStyleApplierUtil.ApplyListStyleTypeProperty(stylesContainer, css, context, list); ListStyleApplierUtil.ApplyListStyleImageProperty(css, context, list); base.Apply(context, stylesContainer, tagWorker); // process the padding considering the direction bool isRtl = BaseDirection.RIGHT_TO_LEFT.Equals(list.GetProperty <BaseDirection?>(Property.BASE_DIRECTION)); if ((isRtl && !list.HasProperty(Property.PADDING_RIGHT)) || (!isRtl && !list.HasProperty(Property.PADDING_LEFT ))) { float em = CssDimensionParsingUtils.ParseAbsoluteLength(css.Get(CssConstants.FONT_SIZE)); float rem = context.GetCssContext().GetRootFontSize(); UnitValue startPadding = CssDimensionParsingUtils.ParseLengthValueToPt(css.Get(CssConstants.PADDING_INLINE_START ), em, rem); list.SetProperty(isRtl ? Property.PADDING_RIGHT : Property.PADDING_LEFT, startPadding); } }
/// <summary>Gets the array that defines the borders.</summary> /// <param name="styles">the styles mapping</param> /// <param name="em">the em value</param> /// <param name="rem">the root em value</param> /// <returns>the borders array</returns> public static BorderRadius[] GetBorderRadiiArray(IDictionary <String, String> styles, float em, float rem) { BorderRadius[] borderRadii = new BorderRadius[4]; BorderRadius borderRadius = null; UnitValue borderRadiusUV = CssDimensionParsingUtils.ParseLengthValueToPt(styles.Get(CssConstants.BORDER_RADIUS ), em, rem); if (null != borderRadiusUV) { borderRadius = new BorderRadius(borderRadiusUV); } UnitValue[] borderTopLeftRadiusUV = CssDimensionParsingUtils.ParseSpecificCornerBorderRadius(styles.Get(CssConstants .BORDER_TOP_LEFT_RADIUS), em, rem); borderRadii[0] = null == borderTopLeftRadiusUV ? borderRadius : new BorderRadius(borderTopLeftRadiusUV[0], borderTopLeftRadiusUV[1]); UnitValue[] borderTopRightRadiusUV = CssDimensionParsingUtils.ParseSpecificCornerBorderRadius(styles.Get(CssConstants .BORDER_TOP_RIGHT_RADIUS), em, rem); borderRadii[1] = null == borderTopRightRadiusUV ? borderRadius : new BorderRadius(borderTopRightRadiusUV[0 ], borderTopRightRadiusUV[1]); UnitValue[] borderBottomRightRadiusUV = CssDimensionParsingUtils.ParseSpecificCornerBorderRadius(styles.Get (CssConstants.BORDER_BOTTOM_RIGHT_RADIUS), em, rem); borderRadii[2] = null == borderBottomRightRadiusUV ? borderRadius : new BorderRadius(borderBottomRightRadiusUV [0], borderBottomRightRadiusUV[1]); UnitValue[] borderBottomLeftRadiusUV = CssDimensionParsingUtils.ParseSpecificCornerBorderRadius(styles.Get (CssConstants.BORDER_BOTTOM_LEFT_RADIUS), em, rem); borderRadii[3] = null == borderBottomLeftRadiusUV ? borderRadius : new BorderRadius(borderBottomLeftRadiusUV [0], borderBottomLeftRadiusUV[1]); return(borderRadii); }
/* (non-Javadoc) * @see com.itextpdf.html2pdf.css.apply.impl.BlockCssApplier#apply(com.itextpdf.html2pdf.attach.ProcessorContext, com.itextpdf.html2pdf.html.node.IStylesContainer, com.itextpdf.html2pdf.attach.ITagWorker) */ public override void Apply(ProcessorContext context, IStylesContainer stylesContainer, ITagWorker worker) { base.Apply(context, stylesContainer, worker); IPropertyContainer cell = worker.GetElementResult(); if (cell != null) { IDictionary <String, String> cssProps = stylesContainer.GetStyles(); VerticalAlignmentApplierUtil.ApplyVerticalAlignmentForCells(cssProps, context, cell); float em = CssDimensionParsingUtils.ParseAbsoluteLength(cssProps.Get(CssConstants.FONT_SIZE)); float rem = context.GetCssContext().GetRootFontSize(); Border[] bordersArray = BorderStyleApplierUtil.GetBordersArray(cssProps, em, rem); if (bordersArray[0] == null) { cell.SetProperty(Property.BORDER_TOP, Border.NO_BORDER); } if (bordersArray[1] == null) { cell.SetProperty(Property.BORDER_RIGHT, Border.NO_BORDER); } if (bordersArray[2] == null) { cell.SetProperty(Property.BORDER_BOTTOM, Border.NO_BORDER); } if (bordersArray[3] == null) { cell.SetProperty(Property.BORDER_LEFT, Border.NO_BORDER); } } }
private static void ApplyBackgroundPositionY(BackgroundPosition position, String yPosition, float em, float rem) { foreach (String value in iText.IO.Util.StringUtil.Split(yPosition, " ")) { switch (value) { case CommonCssConstants.TOP: { position.SetPositionY(BackgroundPosition.PositionY.TOP); break; } case CommonCssConstants.BOTTOM: { position.SetPositionY(BackgroundPosition.PositionY.BOTTOM); break; } case CommonCssConstants.CENTER: { position.SetPositionY(BackgroundPosition.PositionY.CENTER); break; } default: { UnitValue unitValue = CssDimensionParsingUtils.ParseLengthValueToPt(value, em, rem); if (unitValue != null) { position.SetYShift(unitValue); } break; } } } }
/// <summary>Calculates the text rise value for <sup> and <sub> tags.</summary> /// <param name="stylesContainer">the styles container</param> /// <param name="vAlignVal">the vertical alignment value</param> /// <returns>the calculated text rise</returns> private static float CalcTextRiseForSupSub(IStylesContainer stylesContainer, String vAlignVal) { float parentFontSize = GetParentFontSize(stylesContainer); String superscriptPosition = "33%"; String subscriptPosition = "-20%"; String relativeValue = CssConstants.SUPER.Equals(vAlignVal) ? superscriptPosition : subscriptPosition; return(CssDimensionParsingUtils.ParseRelativeValue(relativeValue, parentFontSize)); }
/// <summary>Gets the width.</summary> /// <param name="resolvedCssProps">the resolved CSS properties</param> /// <param name="context">the processor context</param> /// <returns>the width</returns> public static UnitValue GetWidth(IDictionary <String, String> resolvedCssProps, ProcessorContext context) { //The Width is a special case, casue it should be transferred from <colgroup> to <col> but it not applied to <td> or <th> float em = CssDimensionParsingUtils.ParseAbsoluteLength(resolvedCssProps.Get(CssConstants.FONT_SIZE)); String width = resolvedCssProps.Get(CssConstants.WIDTH); return(width != null?CssDimensionParsingUtils.ParseLengthValueToPt(width, em, context.GetCssContext().GetRootFontSize ()) : null); }
/// <summary>Calculates text rise for percentage value text rise.</summary> /// <param name="stylesContainer">the styles container</param> /// <param name="rootFontSize">the root font size</param> /// <param name="vAlignVal">the vertical alignment value</param> /// <returns>the calculated text rise</returns> private static float CalcTextRiseForPercentageValue(IStylesContainer stylesContainer, float rootFontSize, String vAlignVal) { String ownFontSizeStr = stylesContainer.GetStyles().Get(CssConstants.FONT_SIZE); float fontSize = CssDimensionParsingUtils.ParseAbsoluteLength(ownFontSizeStr); String lineHeightStr = stylesContainer.GetStyles().Get(CssConstants.LINE_HEIGHT); float lineHeightActualValue = GetLineHeightActualValue(fontSize, rootFontSize, lineHeightStr); return(CssDimensionParsingUtils.ParseRelativeValue(vAlignVal, lineHeightActualValue)); }
/// <summary>Try to parse a page length value.</summary> /// <param name="valueChunk">a string containing a value</param> /// <param name="em">the em value</param> /// <param name="rem">the root em value</param> /// <returns>the value as a float</returns> private static float?TryParsePageLengthValue(String valueChunk, float em, float rem) { UnitValue unitValue = CssDimensionParsingUtils.ParseLengthValueToPt(valueChunk, em, rem); if (unitValue == null || unitValue.IsPercentValue()) { return(null); } return(unitValue.GetValue()); }
/// <summary>Calculates the text rise for top alignment.</summary> /// <param name="stylesContainer">the styles container</param> /// <param name="rootFontSize">the root font size</param> /// <returns>the calculated text rise</returns> private static float CalcTextRiseForTextTop(IStylesContainer stylesContainer, float rootFontSize) { String ownFontSizeStr = stylesContainer.GetStyles().Get(CssConstants.FONT_SIZE); float fontSize = CssDimensionParsingUtils.ParseAbsoluteLength(ownFontSizeStr); String lineHeightStr = stylesContainer.GetStyles().Get(CssConstants.LINE_HEIGHT); float lineHeightActualValue = GetLineHeightActualValue(fontSize, rootFontSize, lineHeightStr); float parentFontSize = GetParentFontSize(stylesContainer); float elementTopEdge = (float)(fontSize * ASCENDER_COEFFICIENT + (lineHeightActualValue - fontSize) / 2); float parentTextTop = (float)(parentFontSize * ASCENDER_COEFFICIENT); return(parentTextTop - elementTopEdge); }
/// <summary>Calculates the text rise for middle alignment.</summary> /// <param name="stylesContainer">the styles container</param> /// <returns>the calculated text rise</returns> private static float CalcTextRiseForMiddle(IStylesContainer stylesContainer) { String ownFontSizeStr = stylesContainer.GetStyles().Get(CssConstants.FONT_SIZE); float fontSize = CssDimensionParsingUtils.ParseAbsoluteLength(ownFontSizeStr); float parentFontSize = GetParentFontSize(stylesContainer); double fontMiddleCoefficient = 0.3; float elementMidPoint = (float)(fontSize * fontMiddleCoefficient); // shift to element mid point from the baseline float xHeight = parentFontSize / 4; return(xHeight - elementMidPoint); }
private static void ApplyBackgroundColor(String backgroundColorStr, IPropertyContainer element, BackgroundBox clip) { if (backgroundColorStr != null && !CssConstants.TRANSPARENT.Equals(backgroundColorStr)) { float[] rgbaColor = CssDimensionParsingUtils.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 column styles.</summary> /// <param name="node">the node</param> /// <param name="rowColHelper">the helper class to keep track of the position inside the table</param> private void ApplyColStyles(INode node, RowColHelper rowColHelper) { int col; IElementNode element; foreach (INode child in node.ChildNodes()) { if (child is IElementNode) { element = (IElementNode)child; if (TagConstants.TR.Equals(element.Name())) { ApplyColStyles(element, rowColHelper); rowColHelper.NewRow(); } else { if (TagConstants.TH.Equals(element.Name()) || TagConstants.TD.Equals(element.Name())) { int?colspan = CssDimensionParsingUtils.ParseInteger(element.GetAttribute(AttributeConstants.COLSPAN)); int?rowspan = CssDimensionParsingUtils.ParseInteger(element.GetAttribute(AttributeConstants.ROWSPAN)); colspan = colspan != null ? colspan : 1; rowspan = rowspan != null ? rowspan : 1; col = rowColHelper.MoveToNextEmptyCol(); if (GetColWrapper(col) != null) { ColWrapper colWrapper = GetColWrapper(col); if (colWrapper.GetCellCssProps() != null) { element.AddAdditionalHtmlStyles(colWrapper.GetCellCssProps()); } String elemLang = element.GetAttribute(AttributeConstants.LANG); String trLang = null; if (node is IElementNode) { trLang = ((IElementNode)node).GetAttribute(AttributeConstants.LANG); } if (trLang == null && colWrapper.GetLang() != null && elemLang == null) { element.GetAttributes().SetAttribute(AttributeConstants.LANG, colWrapper.GetLang()); } } rowColHelper.UpdateCurrentPosition((int)colspan, (int)rowspan); } else { ApplyColStyles(child, rowColHelper); } } } } }
/// <summary> /// Creates a new /// <see cref="TdTagWorker"/> /// instance. /// </summary> /// <param name="element">the element</param> /// <param name="context">the context</param> public TdTagWorker(IElementNode element, ProcessorContext context) { int?colspan = CssDimensionParsingUtils.ParseInteger(element.GetAttribute(AttributeConstants.COLSPAN)); int?rowspan = CssDimensionParsingUtils.ParseInteger(element.GetAttribute(AttributeConstants.ROWSPAN)); colspan = colspan != null ? colspan : 1; rowspan = rowspan != null ? rowspan : 1; cell = new Cell((int)rowspan, (int)colspan); cell.SetPadding(0); inlineHelper = new WaitingInlineElementsHelper(element.GetStyles().Get(CssConstants.WHITE_SPACE), element. GetStyles().Get(CssConstants.TEXT_TRANSFORM)); display = element.GetStyles() != null?element.GetStyles().Get(CssConstants.DISPLAY) : null; AccessiblePropHelper.TrySetLangAttribute(cell, element); }
/* (non-Javadoc) * @see com.itextpdf.html2pdf.css.resolve.HtmlStylesToCssConverter.IAttributeConverter#convert(com.itextpdf.styledxmlparser.html.node.IElementNode, java.lang.String) */ public virtual IList <CssDeclaration> Convert(IElementNode element, String value) { float?cellPadding = CssDimensionParsingUtils.ParseFloat(value); if (cellPadding != null) { if (TagConstants.TABLE.Equals(element.Name())) { IDictionary <String, String> styles = new Dictionary <String, String>(); styles.Put(CssConstants.PADDING, value + "px"); ApplyPaddingsToTableCells(element, styles); } } return(JavaCollectionsUtil.EmptyList <CssDeclaration>()); }
/// <summary> /// Creates a new /// <see cref="UlOlTagWorker"/> /// instance. /// </summary> /// <param name="element">the element</param> /// <param name="context">the context</param> public UlOlTagWorker(IElementNode element, ProcessorContext context) { list = new List().SetListSymbol(""); //In the case of an ordered list, see if the start attribute can be found if (element.GetAttribute(AttributeConstants.START) != null) { int?startValue = CssDimensionParsingUtils.ParseInteger(element.GetAttribute(AttributeConstants.START)); if (startValue != null) { list.SetItemStartIndex((int)startValue); } } inlineHelper = new WaitingInlineElementsHelper(element.GetStyles().Get(CssConstants.WHITE_SPACE), element. GetStyles().Get(CssConstants.TEXT_TRANSFORM)); AccessiblePropHelper.TrySetLangAttribute(list, element); }
protected override void ComparePdf(String outPath, String dest, String cmp) { CompareTool compareTool = new CompareTool(); for (int i = 0; i < PdfHtmlResponsiveDesign.pageSizes.Length; i++) { float width = CssDimensionParsingUtils.ParseAbsoluteLength(PdfHtmlResponsiveDesign.pageSizes[i].GetWidth().ToString()); String currentDest = dest.Replace("<filename>", "responsive_" + width.ToString("0.0", CultureInfo.InvariantCulture) + ".pdf"); String currentCmp = cmp.Replace("<filename>", "responsive_" + width.ToString("0.0", CultureInfo.InvariantCulture) + ".pdf"); AddError(compareTool.CompareByContent(currentDest, currentCmp, outPath, "diff_")); AddError(compareTool.CompareDocumentInfo(currentDest, currentCmp)); } }
/// <summary>Parses the box value.</summary> /// <param name="em">a measurement expressed in em</param> /// <param name="rem">a measurement expressed in rem (root em)</param> /// <param name="dimensionSize">the dimension size</param> /// <returns>a float value</returns> private static float?ParseBoxValue(String valString, float em, float rem, float dimensionSize) { UnitValue marginUnitVal = CssDimensionParsingUtils.ParseLengthValueToPt(valString, em, rem); if (marginUnitVal != null) { if (marginUnitVal.IsPointValue()) { return(marginUnitVal.GetValue()); } if (marginUnitVal.IsPercentValue()) { return(marginUnitVal.GetValue() * dimensionSize / 100); } } return(null); }
private static void ApplyBackgroundWidth(String widthValue, BackgroundImage image, float em, float rem) { if (CommonCssConstants.BACKGROUND_SIZE_VALUES.Contains(widthValue)) { if (widthValue.Equals(CommonCssConstants.CONTAIN)) { image.GetBackgroundSize().SetBackgroundSizeToContain(); } if (widthValue.Equals(CommonCssConstants.COVER)) { image.GetBackgroundSize().SetBackgroundSizeToCover(); } return; } image.GetBackgroundSize().SetBackgroundSizeToValues(CssDimensionParsingUtils.ParseLengthValueToPt(widthValue , em, rem), null); }
internal virtual float ParseDimension(CssContextNode node, String content, float maxAvailableDimension, float additionalWidthFix) { float fontSize = CssDimensionParsingUtils.ParseAbsoluteFontSize(node.GetStyles().Get(CssConstants.FONT_SIZE )); UnitValue unitValue = CssDimensionParsingUtils.ParseLengthValueToPt(content, fontSize, 0); if (unitValue == null) { return(0); } if (unitValue.IsPointValue()) { return(unitValue.GetValue() + additionalWidthFix); } return(maxAvailableDimension * unitValue.GetValue() / 100f); }
/// <summary>Applies margins to an element.</summary> /// <param name="cssProps">the CSS properties</param> /// <param name="context">the processor context</param> /// <param name="element">the element</param> /// <param name="baseValueHorizontal">value used by default for horizontal dimension</param> /// <param name="baseValueVertical">value used by default for vertical dimension</param> public static void ApplyMargins(IDictionary <String, String> cssProps, ProcessorContext context, IPropertyContainer element, float baseValueVertical, float baseValueHorizontal) { String marginTop = cssProps.Get(CssConstants.MARGIN_TOP); String marginBottom = cssProps.Get(CssConstants.MARGIN_BOTTOM); String marginLeft = cssProps.Get(CssConstants.MARGIN_LEFT); String marginRight = cssProps.Get(CssConstants.MARGIN_RIGHT); // The check for display is useful at least for images bool isBlock = element is IBlockElement || CssConstants.BLOCK.Equals(cssProps.Get(CssConstants.DISPLAY)); bool isImage = element is Image; float em = CssDimensionParsingUtils.ParseAbsoluteLength(cssProps.Get(CssConstants.FONT_SIZE)); float rem = context.GetCssContext().GetRootFontSize(); if (isBlock || isImage) { TrySetMarginIfNotAuto(Property.MARGIN_TOP, marginTop, element, em, rem, baseValueVertical); TrySetMarginIfNotAuto(Property.MARGIN_BOTTOM, marginBottom, element, em, rem, baseValueVertical); } bool isLeftAuto = !TrySetMarginIfNotAuto(Property.MARGIN_LEFT, marginLeft, element, em, rem, baseValueHorizontal ); bool isRightAuto = !TrySetMarginIfNotAuto(Property.MARGIN_RIGHT, marginRight, element, em, rem, baseValueHorizontal ); if (isBlock) { if (isLeftAuto && isRightAuto) { element.SetProperty(Property.HORIZONTAL_ALIGNMENT, HorizontalAlignment.CENTER); } else { if (isLeftAuto) { element.SetProperty(Property.HORIZONTAL_ALIGNMENT, HorizontalAlignment.RIGHT); } else { if (isRightAuto) { element.SetProperty(Property.HORIZONTAL_ALIGNMENT, HorizontalAlignment.LEFT); } } } } }
public static void Main(string[] args) { FileInfo file = new FileInfo(DEST.Replace("<filename>", "")); file.Directory.Create(); string htmlSource = SRC + "responsive.html"; PdfHtmlResponsiveDesign runner = new PdfHtmlResponsiveDesign(); // Create a pdf for each page size for (int i = 0; i < pageSizes.Length; i++) { float width = CssDimensionParsingUtils.ParseAbsoluteLength(pageSizes[i].GetWidth().ToString(CultureInfo.InvariantCulture)); string dest = DEST.Replace("<filename>", "responsive_" + width.ToString("0.0", CultureInfo.InvariantCulture) + ".pdf"); runner.ManipulatePdf(htmlSource, dest, SRC, pageSizes[i], width); } }
/// <summary>Gets the parent font size.</summary> /// <param name="stylesContainer">the styles container</param> /// <returns>the parent font size</returns> private static float GetParentFontSize(IStylesContainer stylesContainer) { float parentFontSize; if (stylesContainer is INode && ((IElementNode)stylesContainer).ParentNode() is IStylesContainer) { INode parent = ((IElementNode)stylesContainer).ParentNode(); String parentFontSizeStr = ((IStylesContainer)parent).GetStyles().Get(CssConstants.FONT_SIZE); parentFontSize = CssDimensionParsingUtils.ParseAbsoluteLength(parentFontSizeStr); } else { // let's take own font size for this unlikely case String ownFontSizeStr = stylesContainer.GetStyles().Get(CssConstants.FONT_SIZE); parentFontSize = CssDimensionParsingUtils.ParseAbsoluteLength(ownFontSizeStr); } return(parentFontSize); }
private static void SetLineHeight(IPropertyContainer elementToSet, String lineHeight, float em, float rem) { if (lineHeight != null && !CssConstants.NORMAL.Equals(lineHeight) && !CssConstants.AUTO.Equals(lineHeight) ) { if (CssTypesValidationUtils.IsNumericValue(lineHeight)) { float?number = CssDimensionParsingUtils.ParseFloat(lineHeight); if (number != null) { elementToSet.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateMultipliedValue((float)number)); } else { elementToSet.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateNormalValue()); } } else { UnitValue lineHeightValue = CssDimensionParsingUtils.ParseLengthValueToPt(lineHeight, em, rem); if (lineHeightValue != null && lineHeightValue.IsPointValue()) { elementToSet.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateFixedValue(lineHeightValue.GetValue())); } else { if (lineHeightValue != null) { elementToSet.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateMultipliedValue(lineHeightValue.GetValue() / 100f)); } else { elementToSet.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateNormalValue()); } } } } else { elementToSet.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateNormalValue()); } }
public virtual void ResponsiveIText() { PageSize[] pageSizes = new PageSize[] { null, new PageSize(PageSize.A3.GetHeight(), PageSize.A4.GetHeight( )), new PageSize(760, PageSize.A4.GetHeight()), new PageSize(PageSize.A5.GetWidth(), PageSize.A4.GetHeight ()) }; String htmlSource = sourceFolder + "responsiveIText.html"; foreach (PageSize pageSize in pageSizes) { float?pxWidth = null; if (pageSize != null) { pxWidth = CssDimensionParsingUtils.ParseAbsoluteLength(pageSize.GetWidth().ToString()); } String outName = "responsiveIText" + (pxWidth != null ? "_" + (int)(float)pxWidth : "") + ".pdf"; PdfWriter writer = new PdfWriter(destinationFolder + outName); PdfDocument pdfDoc = new PdfDocument(writer); ConverterProperties converterProperties = new ConverterProperties(); if (pageSize != null) { pdfDoc.SetDefaultPageSize(pageSize); MediaDeviceDescription mediaDescription = new MediaDeviceDescription(MediaType.SCREEN); mediaDescription.SetWidth((float)pxWidth); converterProperties.SetMediaDeviceDescription(mediaDescription); } using (FileStream fileInputStream = new FileStream(htmlSource, FileMode.Open, FileAccess.Read)) { HtmlConverter.ConvertToPdf(fileInputStream, pdfDoc, converterProperties); } pdfDoc.Close(); } foreach (PageSize pageSize in pageSizes) { float?pxWidth = null; if (pageSize != null) { pxWidth = CssDimensionParsingUtils.ParseAbsoluteLength(pageSize.GetWidth().ToString()); } String outName = "responsiveIText" + (pxWidth != null ? "_" + (int)(float)pxWidth : "") + ".pdf"; String cmpName = "cmp_" + outName; NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(destinationFolder + outName, sourceFolder + cmpName, destinationFolder, "diffResponsive_")); } }