GetKerningPairCorrection() публичный метод

Returns the kerning length correction for the character at the given index in the given string. Also, if the text is part of a textNode list, the nextNode is given so that the following node can be checked incase of two adjacent word nodes.
public GetKerningPairCorrection ( int index, string text, TextNode textNode ) : int
index int
text string
textNode TextNode
Результат int
        private float MeasureNextlineLength(string text)
        {
            var   isMonospacingActive = IsMonospacingActive();
            float xOffset             = 0;

            for (var i = 0; i < text.Length; i++)
            {
                var c = text[i];
                if (c == '\r' || c == '\n')
                {
                    break;
                }
                if (isMonospacingActive)
                {
                    xOffset += MonoSpaceWidth();
                }
                else
                {
                    QFontGlyph glyph;
                    if (c == ' ')
                    {
                        xOffset += (float)Math.Ceiling(Font.meanGlyphWidth * Options.WordSpacing);
                    }
                    else if (Font.CharSetMapping.TryGetValue(c, out glyph)) //normal character
                    {
                        xOffset +=
                            (float)
                            Math.Ceiling(glyph.rect.Width + Font.meanGlyphWidth * Options.CharacterSpacing +
                                         Font.GetKerningPairCorrection(i, text, null));
                    }
                }
            }

            return(xOffset);
        }
Пример #2
0
        private float MeasureTextNodeLength(TextNode node, QFontData fontData, QFontRenderOptions options)
        {
            bool monospaced = fontData.IsMonospacingActive(options);
            float monospaceWidth = fontData.GetMonoSpaceWidth(options);

            if (node.Type == TextNodeType.Space)
            {
                if (monospaced)
                    return monospaceWidth;

                return (float)Math.Ceiling(fontData.meanGlyphWidth * options.WordSpacing);
            }

            float length = 0f;
            if (node.Type == TextNodeType.Word)
            {

                for (int i = 0; i < node.Text.Length; i++)
                {
                    char c = node.Text[i];
                    if (fontData.CharSetMapping.ContainsKey(c))
                    {
                        if (monospaced)
                            length += monospaceWidth;
                        else
                            length += (float)Math.Ceiling(fontData.CharSetMapping[c].rect.Width + fontData.meanGlyphWidth * options.CharacterSpacing + fontData.GetKerningPairCorrection(i, node.Text, node));
                    }
                }
            }
            return length;
        }
Пример #3
0
        private float MeasureNextlineLength(string text)
        {
            float xOffset = 0;

            for (int i = 0; i < text.Length; i++)
            {
                char c = text[i];

                if (c == '\r' || c == '\n')
                {
                    break;
                }


                if (IsMonospacingActive)
                {
                    xOffset += MonoSpaceWidth;
                }
                else
                {
                    //space
                    if (c == ' ')
                    {
                        xOffset += (float)Math.Ceiling(fontData.meanGlyphWidth * Options.WordSpacing);
                    }
                    //normal character
                    else if (fontData.CharSetMapping.ContainsKey(c))
                    {
                        QFontGlyph glyph = fontData.CharSetMapping[c];
                        xOffset += (float)Math.Ceiling(glyph.rect.Width + fontData.meanGlyphWidth * Options.CharacterSpacing + fontData.GetKerningPairCorrection(i, text, null));
                    }
                }
            }
            return(xOffset);
        }
Пример #4
0
        private float MeasureTextNodeLength(TextNode node, QFontData fontData, QFontRenderOptions options)
        {
            bool  monospaced     = fontData.IsMonospacingActive(options);
            float monospaceWidth = fontData.GetMonoSpaceWidth(options);

            if (node.Type == TextNodeType.Space)
            {
                if (monospaced)
                {
                    return(monospaceWidth);
                }

                return((float)Math.Ceiling(fontData.meanGlyphWidth * options.WordSpacing));
            }

            float length = 0f;
            float height = 0f;

            if (node.Type == TextNodeType.Word)
            {
                for (int i = 0; i < node.Text.Length; i++)
                {
                    char c = node.Text[i];
                    if (fontData.CharSetMapping.ContainsKey(c))
                    {
                        var glyph = fontData.CharSetMapping[c];
                        if (monospaced)
                        {
                            length += monospaceWidth;
                        }
                        else
                        {
                            length += (float)Math.Ceiling(fontData.CharSetMapping[c].rect.Width + fontData.meanGlyphWidth * options.CharacterSpacing + fontData.GetKerningPairCorrection(i, node.Text, node));
                        }
                        height = Math.Max(height, glyph.yOffset + glyph.rect.Height);
                    }
                }
            }
            node.Height = height;
            return(length);
        }
Пример #5
0
        private float MeasureTextNodeLength(TextNode node, QFontData fontData, QFontRenderOptions options)
        {
            bool  monospaced     = fontData.IsMonospacingActive(options);
            float monospaceWidth = fontData.GetMonoSpaceWidth(options);

            if (node.Type == TextNodeType.Space)
            {
                if (monospaced)
                {
                    return(monospaceWidth);
                }

                return((float)Math.Ceiling(fontData.meanGlyphWidth * options.WordSpacing));
            }

            float length = 0f;

            if (node.Type == TextNodeType.Word)
            {
                for (int i = 0; i < node.Text.Length; i++)
                {
                    char       c = node.Text[i];
                    QFontGlyph glyph;
                    if (fontData.CharSetMapping.TryGetValue(c, out glyph))
                    {
                        if (monospaced)
                        {
                            length += monospaceWidth;
                        }
                        else
                        {
                            length += (float)Math.Ceiling(glyph.rect.Width + fontData.meanGlyphWidth * options.CharacterSpacing + fontData.GetKerningPairCorrection(i, node.Text, node));
                        }
                    }
                }
            }
            return(length);
        }