private void ApplyUserSpaceScaling(SvgDrawContext context) { if (!this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.MARKER_UNITS) || SvgConstants.Values.STROKEWIDTH .Equals(this.attributesAndStyles.Get(SvgConstants.Attributes.MARKER_UNITS))) { String parentValue = this.GetParent().GetAttribute(SvgConstants.Attributes.STROKE_WIDTH); if (parentValue != null) { float strokeWidthScale; if (CssUtils.IsPercentageValue(parentValue)) { // If stroke width is a percentage value is always computed as a percentage of the normalized viewBox diagonal length. double rootViewPortHeight = context.GetRootViewPort().GetHeight(); double rootViewPortWidth = context.GetRootViewPort().GetWidth(); double viewBoxDiagonalLength = Math.Sqrt(rootViewPortHeight * rootViewPortHeight + rootViewPortWidth * rootViewPortWidth ); strokeWidthScale = CssUtils.ParseRelativeValue(parentValue, (float)viewBoxDiagonalLength); } else { strokeWidthScale = SvgCssUtils.ConvertPtsToPx(ParseFontRelativeOrAbsoluteLengthOnMarker(parentValue)); } context.GetCurrentCanvas().ConcatMatrix(AffineTransform.GetScaleInstance(strokeWidthScale, strokeWidthScale )); } } }
/// <summary><inheritDoc/></summary> public virtual bool IsValid(String objectString) { if (objectString == null) { return(false); } if (CommonCssConstants.INITIAL.Equals(objectString) || CommonCssConstants.INHERIT.Equals(objectString) || CommonCssConstants.UNSET.Equals(objectString)) { return(true); } if (CommonCssConstants.NORMAL.Equals(objectString)) { return(this.allowedNormal); } if (!CssUtils.IsValidNumericValue(objectString)) { return(false); } if (CssUtils.IsPercentageValue(objectString)) { return(this.allowedPercent); } return(true); }
private void ApplyCoordinatesTranslation(SvgDrawContext context) { float xScale = 1; float yScale = 1; if (this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.VIEWBOX)) { //Parse viewbox parameters stuff String viewBoxValues = attributesAndStyles.Get(SvgConstants.Attributes.VIEWBOX); IList <String> valueStrings = SvgCssUtils.SplitValueList(viewBoxValues); float[] viewBox = GetViewBoxValues(); xScale = context.GetCurrentViewPort().GetWidth() / viewBox[2]; yScale = context.GetCurrentViewPort().GetHeight() / viewBox[3]; } float moveX = DEFAULT_REF_X; if (this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.REFX)) { String refX = this.attributesAndStyles.Get(SvgConstants.Attributes.REFX); if (CssUtils.IsPercentageValue(refX)) { moveX = CssUtils.ParseRelativeValue(refX, context.GetRootViewPort().GetWidth()); } else { moveX = ParseFontRelativeOrAbsoluteLengthOnMarker(refX); } //Apply scale moveX *= -1 * xScale; } float moveY = DEFAULT_REF_Y; if (this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.REFY)) { String refY = this.attributesAndStyles.Get(SvgConstants.Attributes.REFY); if (CssUtils.IsPercentageValue(refY)) { moveY = CssUtils.ParseRelativeValue(refY, context.GetRootViewPort().GetHeight()); } else { moveY = ParseFontRelativeOrAbsoluteLengthOnMarker(refY); } moveY *= -1 * yScale; } AffineTransform translation = AffineTransform.GetTranslateInstance(moveX, moveY); if (!translation.IsIdentity()) { context.GetCurrentCanvas().ConcatMatrix(translation); } }
/// <summary>Evaluates the stop color offset value</summary> /// <returns>the stop color offset value in [0, 1] range</returns> public virtual double GetOffset() { double?offset = null; String offsetAttribute = GetAttribute(SvgConstants.Attributes.OFFSET); if (CssUtils.IsPercentageValue(offsetAttribute)) { offset = (double)CssUtils.ParseRelativeValue(offsetAttribute, 1); } else { if (CssUtils.IsNumericValue(offsetAttribute)) { offset = CssUtils.ParseDouble(offsetAttribute); } } double result = offset != null ? offset.Value : 0d; return(result > 1d ? 1d : result > 0d ? result : 0d); }
/// <summary>Parse absolute length.</summary> /// <param name="length"> /// /// <see cref="System.String"/> /// for parsing /// </param> /// <param name="percentRelativeValue">the value on which percent length is based on</param> /// <param name="defaultValue">default value if length is not recognized</param> /// <param name="context"> /// current /// <see cref="iText.Svg.Renderers.SvgDrawContext"/> /// </param> /// <returns>absolute value in points</returns> protected internal virtual float ParseAbsoluteLength(String length, float percentRelativeValue, float defaultValue , SvgDrawContext context) { if (CssUtils.IsPercentageValue(length)) { return(CssUtils.ParseRelativeValue(length, percentRelativeValue)); } else { float em = GetCurrentFontSize(); float rem = context.GetRemValue(); UnitValue unitValue = CssUtils.ParseLengthValueToPt(length, em, rem); if (unitValue != null && unitValue.IsPointValue()) { return(unitValue.GetValue()); } else { return(defaultValue); } } }
private double GetCoordinateForObjectBoundingBox(String attributeName, double defaultValue) { String attributeValue = GetAttribute(attributeName); double absoluteValue = defaultValue; if (CssUtils.IsPercentageValue(attributeValue)) { absoluteValue = CssUtils.ParseRelativeValue(attributeValue, 1); } else { if (CssUtils.IsNumericValue(attributeValue) || CssUtils.IsMetricValue(attributeValue) || CssUtils.IsRelativeValue (attributeValue)) { // if there is incorrect value metric, then we do not need to parse the value int unitsPosition = CssUtils.DeterminePositionBetweenValueAndUnit(attributeValue); if (unitsPosition > 0) { // We want to ignore the unit type. From the svg specification: // "the normal of the linear gradient is perpendicular to the gradient vector in // object bounding box space (i.e., the abstract coordinate system where (0,0) // is at the top/left of the object bounding box and (1,1) is at the bottom/right // of the object bounding box)". // Different browsers treats this differently. We chose the "Google Chrome" approach // which treats the "abstract coordinate system" in the coordinate metric measure, // i.e. for value '0.5cm' the top/left of the object bounding box would be (1cm, 1cm), // for value '0.5em' the top/left of the object bounding box would be (1em, 1em) and etc. // no null pointer should be thrown as determine absoluteValue = CssUtils.ParseDouble(attributeValue.JSubstring(0, unitsPosition)).Value; } } } // need to multiply by 0.75 as further the (top, right) coordinates of the object bbox // would be transformed into (0.75, 0.75) point instead of (1, 1). The reason described // as a comment inside the method constructing the gradient transformation return(absoluteValue * 0.75); }