internal static float CalculateLineHeight(AbstractRenderer renderer)
        {
            LineHeight lineHeight = renderer.GetProperty <LineHeight>(Property.LINE_HEIGHT);
            float      fontSize   = renderer.GetPropertyAsUnitValue(Property.FONT_SIZE).GetValue();
            float      lineHeightValue;

            if (lineHeight == null || lineHeight.IsNormalValue() || lineHeight.GetValue() < 0)
            {
                lineHeightValue = DEFAULT_LINE_HEIGHT_COEFF * fontSize;
                float[] fontAscenderDescender    = GetFontAscenderDescenderNormalized(renderer);
                float   fontAscenderDescenderSum = fontAscenderDescender[0] - fontAscenderDescender[1];
                if (fontAscenderDescenderSum > lineHeightValue)
                {
                    lineHeightValue = fontAscenderDescenderSum;
                }
            }
            else
            {
                if (lineHeight.IsFixedValue())
                {
                    lineHeightValue = lineHeight.GetValue();
                }
                else
                {
                    lineHeightValue = lineHeight.GetValue() * fontSize;
                }
            }
            return(lineHeightValue);
        }
        public virtual void CalculateLineHeighttTextRendererPointTest()
        {
            Document     document     = new Document(new PdfDocument(new PdfWriter(new ByteArrayOutputStream())));
            TextRenderer textRenderer = new TextRenderer(new Text("Hello"));

            textRenderer.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateFixedValue(200));
            textRenderer.SetParent(document.GetRenderer());
            float lineHeight = LineHeightHelper.CalculateLineHeight(textRenderer);

            NUnit.Framework.Assert.AreEqual(200, lineHeight, EPS);
        }
        public override void OnLayout(IGUIContext ctx, RectangleF bounds)
        {
            base.OnLayout(ctx, bounds);

            SubMenuWidgetStyle style = Style as SubMenuWidgetStyle;

            if (style != null && Font != null)
            {
                style.IconColumnWidth = LineHeight.Ceil();
            }
        }
        public virtual void LineRendererLayoutInHtmlModeWithLineHeightAndNoChildrenTest()
        {
            Document     document     = CreateDocument();
            LineRenderer lineRenderer = new LineRenderer();

            lineRenderer.SetParent(document.GetRenderer());
            lineRenderer.SetProperty(Property.RENDERING_MODE, RenderingMode.HTML_MODE);
            lineRenderer.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateNormalValue());
            lineRenderer.Layout(new LayoutContext(CreateLayoutArea(1000, 1000)));
            NUnit.Framework.Assert.AreEqual(0f, lineRenderer.maxAscent, 0f);
            NUnit.Framework.Assert.AreEqual(0f, lineRenderer.maxDescent, 0f);
        }
        public virtual void CalculateLineHeightTextRendererNormalAscenderDescenderSumForNotoSansFontTest()
        {
            Document     document     = new Document(new PdfDocument(new PdfWriter(new ByteArrayOutputStream())));
            PdfFont      font         = PdfFontFactory.CreateFont(FONTS + "NotoSans-Regular.ttf");
            TextRenderer textRenderer = new TextRenderer(new Text("Hello"));

            textRenderer.SetProperty(Property.FONT, font);
            textRenderer.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateNormalValue());
            textRenderer.SetParent(document.GetRenderer());
            float lineHeight = LineHeightHelper.CalculateLineHeight(textRenderer);

            NUnit.Framework.Assert.AreEqual(16.31999f, lineHeight, EPS);
        }
Example #6
0
 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 LineRendererLayoutInHtmlModeWithLineHeightAndChildInHtmlModeTest()
        {
            Document     document     = CreateDocument();
            LineRenderer lineRenderer = new LineRenderer();

            lineRenderer.SetParent(document.GetRenderer());
            lineRenderer.SetProperty(Property.RENDERING_MODE, RenderingMode.HTML_MODE);
            lineRenderer.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateFixedValue(50));
            TextRenderer textRenderer1 = new TextRenderer(new Text("text"));

            textRenderer1.SetProperty(Property.RENDERING_MODE, RenderingMode.HTML_MODE);
            TextRenderer textRenderer2 = new TextRenderer(new Text("text"));

            lineRenderer.AddChild(textRenderer1);
            lineRenderer.AddChild(textRenderer2);
            lineRenderer.Layout(new LayoutContext(CreateLayoutArea(1000, 1000)));
            NUnit.Framework.Assert.AreEqual(28.67920f, lineRenderer.maxAscent, EPS);
            NUnit.Framework.Assert.AreEqual(-21.32080f, lineRenderer.maxDescent, EPS);
        }
        public virtual void LineRendererLayoutInHtmlModeWithLineHeightPropertyNotSet()
        {
            LineRenderer lineRenderer = new LineRenderer();

            lineRenderer.SetParent(CreateDocument().GetRenderer());
            lineRenderer.SetProperty(Property.RENDERING_MODE, RenderingMode.HTML_MODE);
            // Set fonts with different ascent/descent to line and text
            lineRenderer.SetProperty(Property.FONT, PdfFontFactory.CreateFont(StandardFonts.HELVETICA));
            TextRenderer textRenderer = new TextRenderer(new Text("text"));

            textRenderer.SetProperty(Property.FONT, PdfFontFactory.CreateFont(StandardFonts.COURIER));
            lineRenderer.AddChild(textRenderer);
            LayoutResult layoutResLineHeightNotSet = lineRenderer.Layout(new LayoutContext(CreateLayoutArea(1000, 1000
                                                                                                            )));

            lineRenderer.SetProperty(Property.LINE_HEIGHT, LineHeight.CreateNormalValue());
            LayoutResult layoutResLineHeightNormal = lineRenderer.Layout(new LayoutContext(CreateLayoutArea(1000, 1000
                                                                                                            )));
            Rectangle bboxLineHeightNotSet = layoutResLineHeightNotSet.GetOccupiedArea().GetBBox();
            Rectangle bboxLineHeightNormal = layoutResLineHeightNormal.GetOccupiedArea().GetBBox();

            NUnit.Framework.Assert.IsTrue(bboxLineHeightNotSet.EqualsWithEpsilon(bboxLineHeightNormal));
        }
Example #9
0
        /// <summary>
        /// Calc the length of the adjacent side from the length of the opposite side and
        /// the tangent of the adjacent side angle.
        /// </summary>
        /// <param name="Tan"></param>
        /// <param name="OppLgth"></param>
        /// <returns></returns>
        public static double CalcAdjacentLgth(double Tan, LineHeight OppLgth)
        {
            var adjLgth = Math.Abs(OppLgth.Value) / Tan;

            return(adjLgth);
        }