public override void Draw(PdfCanvas canvas) { float x = CssUtils.ParseAbsoluteLength(coordinates[0]); float y = CssUtils.ParseAbsoluteLength(coordinates[1]); canvas.LineTo(x, y); }
protected internal override void DoDraw(SvgDrawContext context) { if (this.attributesAndStyles != null && this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.TEXT_CONTENT )) { PdfCanvas currentCanvas = context.GetCurrentCanvas(); String xRawValue = this.attributesAndStyles.Get(SvgConstants.Attributes.X); String yRawValue = this.attributesAndStyles.Get(SvgConstants.Attributes.Y); String fontSizeRawValue = this.attributesAndStyles.Get(SvgConstants.Attributes.FONT_SIZE); IList <String> xValuesList = SvgCssUtils.SplitValueList(xRawValue); IList <String> yValuesList = SvgCssUtils.SplitValueList(yRawValue); float x = 0f; float y = 0f; float fontSize = 0f; if (fontSizeRawValue != null && !String.IsNullOrEmpty(fontSizeRawValue)) { fontSize = CssUtils.ParseAbsoluteLength(fontSizeRawValue, CommonCssConstants.PT); } if (!xValuesList.IsEmpty()) { x = CssUtils.ParseAbsoluteLength(xValuesList[0]); } if (!yValuesList.IsEmpty()) { y = CssUtils.ParseAbsoluteLength(yValuesList[0]); } currentCanvas.BeginText(); FontProvider provider = context.GetFontProvider(); FontSet tempFonts = context.GetTempFonts(); PdfFont font = null; if (!provider.GetFontSet().IsEmpty() || (tempFonts != null && !tempFonts.IsEmpty())) { String fontFamily = this.attributesAndStyles.Get(SvgConstants.Attributes.FONT_FAMILY); String fontWeight = this.attributesAndStyles.Get(SvgConstants.Attributes.FONT_WEIGHT); String fontStyle = this.attributesAndStyles.Get(SvgConstants.Attributes.FONT_STYLE); fontFamily = fontFamily != null?fontFamily.Trim() : ""; FontInfo fontInfo = ResolveFontName(fontFamily, fontWeight, fontStyle, provider, tempFonts); font = provider.GetPdfFont(fontInfo, tempFonts); } if (font == null) { try { // TODO (DEVSIX-2057) // TODO each call of createFont() create a new instance of PdfFont. // TODO FontProvider shall be used instead. font = PdfFontFactory.CreateFont(); } catch (System.IO.IOException e) { throw new SvgProcessingException(SvgLogMessageConstant.FONT_NOT_FOUND, e); } } currentCanvas.SetFontAndSize(font, fontSize); //Current transformation matrix results in the character glyphs being mirrored, correct with inverse tf currentCanvas.SetTextMatrix(1, 0, 0, -1, x, y); currentCanvas.SetColor(ColorConstants.BLACK, true); currentCanvas.ShowText(this.attributesAndStyles.Get(SvgConstants.Attributes.TEXT_CONTENT)); currentCanvas.EndText(); } }
/// <summary>Calculate the viewport based on the context.</summary> /// <param name="context">the SVG draw context</param> /// <returns>the viewport that applies to this renderer</returns> internal virtual Rectangle CalculateViewPort(SvgDrawContext context) { Rectangle currentViewPort = context.GetCurrentViewPort(); // Set default values to parent viewport in the case of a nested svg tag float portX = currentViewPort.GetX(); float portY = currentViewPort.GetY(); // Default should be parent portWidth if not outermost float portWidth = currentViewPort.GetWidth(); // Default should be parent height if not outermost float portHeight = currentViewPort.GetHeight(); if (attributesAndStyles != null) { if (attributesAndStyles.ContainsKey(SvgConstants.Attributes.X)) { portX = CssUtils.ParseAbsoluteLength(attributesAndStyles.Get(SvgConstants.Attributes.X)); } if (attributesAndStyles.ContainsKey(SvgConstants.Attributes.Y)) { portY = CssUtils.ParseAbsoluteLength(attributesAndStyles.Get(SvgConstants.Attributes.Y)); } if (attributesAndStyles.ContainsKey(SvgConstants.Attributes.WIDTH)) { portWidth = CssUtils.ParseAbsoluteLength(attributesAndStyles.Get(SvgConstants.Attributes.WIDTH)); } if (attributesAndStyles.ContainsKey(SvgConstants.Attributes.HEIGHT)) { portHeight = CssUtils.ParseAbsoluteLength(attributesAndStyles.Get(SvgConstants.Attributes.HEIGHT)); } } return(new Rectangle(portX, portY, portWidth, portHeight)); }
/// <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?)CssUtils.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 = CssUtils.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); }
/* (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 = CssUtils.ParseAbsoluteLength(css.Get(CssConstants.FONT_SIZE)); float rem = context.GetCssContext().GetRootFontSize(); UnitValue startPadding = CssUtils.ParseLengthValueToPt(css.Get(CssConstants.PADDING_INLINE_START), em, rem ); list.SetProperty(isRtl ? Property.PADDING_RIGHT : Property.PADDING_LEFT, startPadding); } }
// 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 /// <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 = CssUtils.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> /// Fetches a map of String values by calling getAttribute(Strng s) method /// and maps it's values to arc parmateter cx, cy , rx, ry respectively /// </summary> /// <returns>boolean values to indicate whether all values exit or not</returns> protected internal virtual bool SetParameters() { cx = 0; cy = 0; if (GetAttribute(SvgConstants.Attributes.CX) != null) { cx = CssUtils.ParseAbsoluteLength(GetAttribute(SvgConstants.Attributes.CX)); } if (GetAttribute(SvgConstants.Attributes.CY) != null) { cy = CssUtils.ParseAbsoluteLength(GetAttribute(SvgConstants.Attributes.CY)); } if (GetAttribute(SvgConstants.Attributes.RX) != null && CssUtils.ParseAbsoluteLength(GetAttribute(SvgConstants.Attributes .RX)) > 0) { rx = CssUtils.ParseAbsoluteLength(GetAttribute(SvgConstants.Attributes.RX)); } else { return(false); } //No drawing if rx is absent if (GetAttribute(SvgConstants.Attributes.RY) != null && CssUtils.ParseAbsoluteLength(GetAttribute(SvgConstants.Attributes .RY)) > 0) { ry = CssUtils.ParseAbsoluteLength(GetAttribute(SvgConstants.Attributes.RY)); } else { return(false); } //No drawing if ry is absent return(true); }
/* (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 = CssUtils.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); } } }
/// <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 = CssUtils.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 = CssUtils.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()); } } } } }
/// <summary> /// Creates a new /// <see cref="BodyTagWorker"/> /// instance. /// </summary> /// <param name="element">the element</param> /// <param name="context">the context</param> public BodyTagWorker(IElementNode element, ProcessorContext context) : base(element, context) { parentTagWorker = context.GetState().Empty() ? null : context.GetState().Top(); if (parentTagWorker != null && parentTagWorker.GetElementResult() != null) { // TODO this is not in css applier because css applier is called after the elements are added to the document // We need to apply font styles here specifically to set font-size to the document because this is needed for // inline-blocks with fixed height when the height is smaller than the defined font size float em = CssUtils.ParseAbsoluteLength(element.GetStyles().Get(CssConstants.FONT_SIZE)); if (em != 0) { parentTagWorker.GetElementResult().SetProperty(Property.FONT_SIZE, UnitValue.CreatePointValue(em)); } } PdfDocument pdfDocument = context.GetPdfDocument(); if (pdfDocument != null) { lang = element.GetAttribute(AttributeConstants.LANG); if (lang != null) { pdfDocument.GetCatalog().SetLang(new PdfString(lang, PdfEncodings.UNICODE_BIG)); } } else { lang = element.GetLang(); } }
public virtual void ThreeRotateValuesTest() { AffineTransform expected = AffineTransform.GetRotateInstance(MathUtil.ToRadians(23), CssUtils.ParseAbsoluteLength ("58"), CssUtils.ParseAbsoluteLength("57")); AffineTransform actual = TransformUtils.ParseTransform("rotate(23, 58, 57)"); NUnit.Framework.Assert.AreEqual(expected, actual); }
public virtual void NormalRotateTest() { AffineTransform expected = AffineTransform.GetRotateInstance(MathUtil.ToRadians(10), CssUtils.ParseAbsoluteLength ("5"), CssUtils.ParseAbsoluteLength("10")); AffineTransform actual = TransformUtils.ParseTransform("rotate(10, 5, 10)"); NUnit.Framework.Assert.AreEqual(expected, actual); }
/// <summary>Draws a quadratic Bezier curve from the current point to (x,y) using (x1,y1) as the control point /// </summary> public override void Draw(PdfCanvas canvas) { float x1 = CssUtils.ParseAbsoluteLength(coordinates[0]); float y1 = CssUtils.ParseAbsoluteLength(coordinates[1]); float x = CssUtils.ParseAbsoluteLength(coordinates[2]); float y = CssUtils.ParseAbsoluteLength(coordinates[3]); canvas.CurveTo(x1, y1, x, y); }
/*TODO Note: visibility doesn't work on "chrome" or "safari" and though it technically works on "firefox" and "edge" the results differ, * with "edge" surprisingly giving the closest result to expected one. * The supported values are 'collapse' and 'visible'. The expected behaviour for 'collapse' is not to render those cols * (the table layout should change ann the width should be diminished), and to clip cells that are spaned to none-collapsed one. * The state of the content in clipped cells is not specified*/ /// <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 = CssUtils.ParseAbsoluteLength(resolvedCssProps.Get(CssConstants.FONT_SIZE)); String width = resolvedCssProps.Get(CssConstants.WIDTH); return(width != null?CssUtils.ParseLengthValueToPt(width, em, context.GetCssContext().GetRootFontSize()) : null); }
/// <summary>Parses the absolute font size.</summary> /// <param name="fontSizeValue"> /// the font size value as a /// <see cref="System.String"/> /// </param> /// <returns> /// the font size value as a /// <c>float</c> /// </returns> public static float ParseAbsoluteFontSize(String fontSizeValue) { if (CssConstants.FONT_ABSOLUTE_SIZE_KEYWORDS.Contains(fontSizeValue)) { switch (fontSizeValue) { case CssConstants.XX_SMALL: { fontSizeValue = "9px"; break; } case CssConstants.X_SMALL: { fontSizeValue = "10px"; break; } case CssConstants.SMALL: { fontSizeValue = "13px"; break; } case CssConstants.MEDIUM: { fontSizeValue = "16px"; break; } case CssConstants.LARGE: { fontSizeValue = "18px"; break; } case CssConstants.X_LARGE: { fontSizeValue = "24px"; break; } case CssConstants.XX_LARGE: { fontSizeValue = "32px"; break; } default: { fontSizeValue = "16px"; break; } } } try { /* Styled XML Parser will throw an exception when it can't parse the given value * but in html2pdf, we want to fall back to the default value of 0 */ return(CssUtils.ParseAbsoluteLength(fontSizeValue)); } catch (StyledXMLParserException) { return(0f); } }
public override void Draw(PdfCanvas canvas) { for (int i = 0; i < coordinates.Length; i++) { float x = CssUtils.ParseAbsoluteLength(coordinates[i][0]); float y = CssUtils.ParseAbsoluteLength(coordinates[i][1]); canvas.LineTo(x, y); } }
/// <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 = CssUtils.ParseAbsoluteLength(ownFontSizeStr); String lineHeightStr = stylesContainer.GetStyles().Get(CssConstants.LINE_HEIGHT); float lineHeightActualValue = GetLineHeightActualValue(fontSize, rootFontSize, lineHeightStr); return(CssUtils.ParseRelativeValue(vAlignVal, lineHeightActualValue)); }
internal virtual float GetAttribute(IDictionary <String, String> attributes, String key) { String value = attributes.Get(key); if (value != null && !String.IsNullOrEmpty(value)) { return(CssUtils.ParseAbsoluteLength(attributes.Get(key))); } return(0); }
// transformation already happened in AbstractSvgNodeRenderer, so no need to do a transformation here /// <summary>Applies a transformation based on a viewBox for a given branch node.</summary> /// <param name="context">current svg draw context</param> internal virtual void ApplyViewBox(SvgDrawContext context) { if (this.attributesAndStyles != null && this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.VIEWBOX )) { //Parse aspect ratio related stuff String viewBoxValues = attributesAndStyles.Get(SvgConstants.Attributes.VIEWBOX); IList <String> valueStrings = SvgCssUtils.SplitValueList(viewBoxValues); float[] values = new float[valueStrings.Count]; for (int i = 0; i < values.Length; i++) { values[i] = CssUtils.ParseAbsoluteLength(valueStrings[i]); } Rectangle currentViewPort = context.GetCurrentViewPort(); String[] alignAndMeet = RetrieveAlignAndMeet(); String align = alignAndMeet[0]; String meetOrSlice = alignAndMeet[1]; float scaleWidth = currentViewPort.GetWidth() / values[2]; float scaleHeight = currentViewPort.GetHeight() / values[3]; bool forceUniformScaling = !(SvgConstants.Values.NONE.Equals(align)); if (forceUniformScaling) { //Scaling should preserve aspect ratio if (SvgConstants.Values.MEET.Equals(meetOrSlice)) { scaleWidth = Math.Min(scaleWidth, scaleHeight); } else { scaleWidth = Math.Max(scaleWidth, scaleHeight); } scaleHeight = scaleWidth; } AffineTransform scale = AffineTransform.GetScaleInstance(scaleWidth, scaleHeight); float[] scaledViewBoxValues = ScaleViewBoxValues(values, scaleWidth, scaleHeight); AffineTransform transform = ProcessAspectRatioPosition(context, scaledViewBoxValues, align, scaleWidth, scaleHeight ); if (!scale.IsIdentity()) { context.GetCurrentCanvas().ConcatMatrix(scale); //Inverse scaling needs to be applied to viewport dimensions context.GetCurrentViewPort().SetWidth(currentViewPort.GetWidth() / scaleWidth).SetX(currentViewPort.GetX() / scaleWidth).SetHeight(currentViewPort.GetHeight() / scaleHeight).SetY(currentViewPort.GetY() / scaleHeight ); } if (!transform.IsIdentity()) { context.GetCurrentCanvas().ConcatMatrix(transform); //Apply inverse translation to viewport to make it line up nicely context.GetCurrentViewPort().SetX(currentViewPort.GetX() + -1 * (float)transform.GetTranslateX()).SetY(currentViewPort .GetY() + -1 * (float)transform.GetTranslateY()); } } }
/// <summary>Operations to perform before drawing an element.</summary> /// <remarks> /// Operations to perform before drawing an element. /// This includes setting stroke color and width, fill color. /// </remarks> /// <param name="context">the svg draw context</param> internal virtual void PreDraw(SvgDrawContext context) { if (this.attributesAndStyles != null) { PdfCanvas currentCanvas = context.GetCurrentCanvas(); if (!partOfClipPath) { { // fill String fillRawValue = GetAttribute(SvgConstants.Attributes.FILL); this.doFill = !SvgConstants.Values.NONE.EqualsIgnoreCase(fillRawValue); if (doFill && CanElementFill()) { Color color = ColorConstants.BLACK; if (fillRawValue != null) { color = WebColors.GetRGBColor(fillRawValue); } currentCanvas.SetFillColor(color); } } { // stroke String strokeRawValue = GetAttribute(SvgConstants.Attributes.STROKE); if (!SvgConstants.Values.NONE.EqualsIgnoreCase(strokeRawValue)) { DeviceRgb rgbColor = WebColors.GetRGBColor(strokeRawValue); if (strokeRawValue != null && rgbColor != null) { currentCanvas.SetStrokeColor(rgbColor); String strokeWidthRawValue = GetAttribute(SvgConstants.Attributes.STROKE_WIDTH); float strokeWidth = 1f; if (strokeWidthRawValue != null) { strokeWidth = CssUtils.ParseAbsoluteLength(strokeWidthRawValue); } currentCanvas.SetLineWidth(strokeWidth); doStroke = true; } } } { // opacity String opacityValue = GetAttribute(SvgConstants.Attributes.FILL_OPACITY); if (opacityValue != null && !SvgConstants.Values.NONE.EqualsIgnoreCase(opacityValue)) { PdfExtGState gs1 = new PdfExtGState(); gs1.SetFillOpacity(float.Parse(opacityValue, System.Globalization.CultureInfo.InvariantCulture)); currentCanvas.SetExtGState(gs1); } } } } }
/// <summary>Creates a translate transformation.</summary> /// <param name="values">values of the transformation</param> /// <returns>AffineTransform for the translate operation</returns> private static AffineTransform CreateTranslateTransformation(IList <String> values) { if (values.Count == 0 || values.Count > 2) { throw new SvgProcessingException(SvgLogMessageConstant.TRANSFORM_INCORRECT_NUMBER_OF_VALUES); } float translateX = CssUtils.ParseAbsoluteLength(values[0]); float translateY = values.Count == 2 ? CssUtils.ParseAbsoluteLength(values[1]) : 0; return(AffineTransform.GetTranslateInstance(translateX, translateY)); }
internal virtual float[] GetViewBoxValues() { String viewBoxValues = attributesAndStyles.Get(SvgConstants.Attributes.VIEWBOX); IList <String> valueStrings = SvgCssUtils.SplitValueList(viewBoxValues); float[] values = new float[valueStrings.Count]; for (int i = 0; i < values.Length; i++) { values[i] = CssUtils.ParseAbsoluteLength(valueStrings[i]); } return(values); }
/// <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 = CssUtils.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); }
/// <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 = CssUtils.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>Parses an absolute length.</summary> /// <param name="value"> /// the absolute length as a /// <see cref="System.String"/> /// value /// </param> /// <returns> /// the absolute length as a /// <c>float</c> /// value /// </returns> private static float ParseAbsoluteLength(String value) { if (CssUtils.IsRelativeValue(value)) { // TODO here should be used default font size of the browser, it probably should be fetched from the more generic place than private class constant return(CssUtils.ParseRelativeValue(value, DEFAULT_FONT_SIZE)); } else { return(CssUtils.ParseAbsoluteLength(value)); } }
internal override void PreDraw(SvgDrawContext context) { base.PreDraw(context); float[] markerWidthHeight = GetMarkerWidthHeightValues(); float markerWidth = markerWidthHeight[0]; float markerHeight = markerWidthHeight[1]; Rectangle markerViewport = new Rectangle(CssUtils.ParseAbsoluteLength(this.GetAttribute(SvgConstants.Attributes .X)), CssUtils.ParseAbsoluteLength(this.GetAttribute(SvgConstants.Attributes.Y)), markerWidth, markerHeight ); context.AddViewPort(markerViewport); }
// 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); }
public override void Draw(PdfCanvas canvas) { for (int i = 0; i < coordinates.Length; i++) { float x1 = CssUtils.ParseAbsoluteLength(coordinates[i][0]); float y1 = CssUtils.ParseAbsoluteLength(coordinates[i][1]); float x2 = CssUtils.ParseAbsoluteLength(coordinates[i][2]); float y2 = CssUtils.ParseAbsoluteLength(coordinates[i][3]); float x = CssUtils.ParseAbsoluteLength(coordinates[i][4]); float y = CssUtils.ParseAbsoluteLength(coordinates[i][5]); canvas.CurveTo(x1, y1, x2, y2, x, y); } }
/// <summary>Extract and parse the font-size declaration stored inside the attributes of the passed renderer</summary> /// <param name="renderer">renderer to extract font-size declaration from</param> /// <returns>a float containing the font-size interpreted as pt, or NaN if the font-size was not specified in the passed renderer /// </returns> private static float ExtractFontSize(ISvgTextNodeRenderer renderer) { float fontSize = float.NaN; if (renderer.GetAttribute(SvgConstants.Attributes.FONT_SIZE) != null) { String fontSizeRawValue = renderer.GetAttribute(SvgConstants.Attributes.FONT_SIZE); if (fontSizeRawValue != null && !String.IsNullOrEmpty(fontSizeRawValue)) { fontSize = CssUtils.ParseAbsoluteLength(fontSizeRawValue, CommonCssConstants.PT); } } return(fontSize); }
private static float[] GetPositionsFromString(String rawValuesString) { float[] result = null; IList <String> valuesList = SvgCssUtils.SplitValueList(rawValuesString); if (!valuesList.IsEmpty()) { result = new float[valuesList.Count]; for (int i = 0; i < valuesList.Count; i++) { result[i] = CssUtils.ParseAbsoluteLength(valuesList[i]); } } return(result); }