Example #1
0
        public override Box CreateBox()
        {
            var result = HorizontalBox.Get();
            var margin = TEXConfiguration.main.BackdropMargin * TexContext.Scale * 2;
            var box    = baseAtom.CreateBox();

            if (this.margin)
            {
                box = VerticalBox.Get(HorizontalBox.Get(box, box.width + margin,
                                                        TexAlignment.Center), box.totalHeight + margin, TexAlignment.Center);
            }

            var bg = HorizontalRule.Get(box.height, box.width, 0, box.depth, true);

            if (color != Color.clear)
            {
                result.Add(AttrColorBox.Get(0, color));
            }
            result.Add(bg);
            if (color != Color.clear)
            {
                result.Add(AttrColorBox.Get(3, color));
            }

            result.Add(StrutBox.Get(-box.width, 0, 0, 0));
            result.Add(box);

            return(result);
        }
Example #2
0
        public override Box CreateBox(TexStyle style)
        {
            // Create box for base atom.
            var baseBox = BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox(TexUtility.GetCrampedStyle(style));
            // Find character of best scale for accent symbol.
            TexCharMetric accentChar = TEXPreference.main.GetCharMetric(AccentAtom.Name, style);

            while (accentChar.ch.nextLargerExist)
            {
                var nextLargerChar = TEXPreference.main.GetCharMetric(accentChar.ch.nextLarger, style);
                if (nextLargerChar.width > baseBox.width)
                {
                    break;
                }
                accentChar = nextLargerChar;
            }

            var resultBox = VerticalBox.Get();

            // Create and add box for accent symbol.
            var accentBox   = CharBox.Get(style, accentChar);
            var accentWidth = (accentBox.bearing + accentBox.italic) * .5f;

            accentBox.italic  = accentWidth + (accentBox.width * .5f);
            accentBox.bearing = accentWidth - (accentBox.width * .5f);
            //accentBox. = accentBox.width + accentBox.italic - accentBox.bearing;
            resultBox.Add((accentBox));

            //var delta = Mathf.Min(-accentChar.depth, baseBox.height);
            resultBox.Add(StrutBox.Get(0, TEXConfiguration.main.AccentMargin * TexUtility.SizeFactor(style), 0, 0));

            // Centre and add box for base atom. Centre base box and accent box with respect to each other.
            var boxWidthsDiff = (baseBox.width - accentBox.width) / 2f;

            accentBox.shift = Mathf.Max(boxWidthsDiff, 0);
            if (boxWidthsDiff < 0)
            {
                baseBox = HorizontalBox.Get(baseBox, accentBox.width, TexAlignment.Center);
            }
            resultBox.Add(baseBox);

            // Adjust height and depth of result box.
            var depth       = baseBox.depth;
            var totalHeight = resultBox.height + resultBox.depth;

            resultBox.depth  = depth;
            resultBox.height = totalHeight - depth;

            return(resultBox);
        }
Example #3
0
        public override Box CreateBox()
        {
            // Create box for base atom.
            TexContext.Environment.Push(TexUtility.GetCrampedStyle());
            var baseBox = BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox();

            TexContext.Environment.Pop();

            // Find character of best scale for accent symbol.
            var acct = TEXPreference.main.GetChar(AccentAtom.Name).GetMetric();

            while (acct.width < baseBox.width && acct.ch.nextLargerExist)
            {
                acct.Flush();
                acct = acct.ch.nextLarger.GetMetric();
            }

            var resultBox = VerticalBox.Get();

            // Create and add box for accent symbol.
            var accentWidth = (acct.bearing + acct.italic) * .5f;

            acct.italic  = accentWidth + (acct.width * .5f);
            acct.bearing = accentWidth - (acct.width * .5f);
            resultBox.Add(acct);

            resultBox.Add(StrutBox.Get(0, TEXConfiguration.main.AccentMargin * TexContext.Scale, 0, 0));

            // Centre and add box for base atom. Centre base box and accent box with respect to each other.
            var boxWidthsDiff = (baseBox.width - acct.width) / 2f;

            acct.shift = Mathf.Max(boxWidthsDiff, 0);
            if (boxWidthsDiff < 0)
            {
                baseBox = HorizontalBox.Get(baseBox, acct.width, TexAlignment.Center);
            }

            resultBox.Add(baseBox);

            // Adjust height and depth of result box.
            var depth       = baseBox.depth;
            var totalHeight = resultBox.height + resultBox.depth;

            resultBox.depth  = depth;
            resultBox.height = totalHeight - depth;

            return(resultBox);
        }
Example #4
0
        public override Box CreateBox(TexStyle style)
        {
            // Create box for base atom.
            var baseBox = BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox(style);

            // Create boxes for over and under atoms.
            Box overBox = null, underBox = null;
            var maxWidth = baseBox.width;

            if (OverAtom != null)
            {
                overBox  = OverAtom.CreateBox(OverScriptSmaller ? TexUtility.GetSuperscriptStyle(style) : style);
                maxWidth = Mathf.Max(maxWidth, overBox.width);
            }

            if (UnderAtom != null)
            {
                underBox = UnderAtom.CreateBox(UnderScriptSmaller ? TexUtility.GetSubscriptStyle(style) : style);
                maxWidth = Mathf.Max(maxWidth, underBox.width);
            }

            // Create result box.
            var resultBox = VerticalBox.Get();

            // Create and add box for over atom.
            if (OverAtom != null)
            {
                resultBox.Add(ChangeWidth(overBox, maxWidth));
                resultBox.Add(TexUtility.GetBox(SpaceAtom.Get(0, OverSpace, 0), style));
            }

            // Add box for base atom.
            resultBox.Add(ChangeWidth(baseBox, maxWidth));

            float totalHeight = resultBox.height + resultBox.depth - baseBox.depth;

            // Create and add box for under atom.
            if (UnderAtom != null)
            {
                resultBox.Add(TexUtility.GetBox(SpaceAtom.Get(0, UnderSpace, 0), style));
                resultBox.Add(ChangeWidth(underBox, maxWidth));
            }

            resultBox.depth  = resultBox.height + resultBox.depth - totalHeight;
            resultBox.height = totalHeight;

            return(resultBox);
        }
Example #5
0
        public override Box CreateBox()
        {
            // radius will be implemented later

            var margin = this.margin ? TEXConfiguration.main.BackdropMargin * TexContext.Scale : 0;

            var box = baseAtom.CreateBox();

            var hbox = HorizontalBox.Get(box, box.width + margin * 2, TexAlignment.Center);

            if (thickness.x > 0)
            {
                var rule = HorizontalRule.Get(hbox.height, thickness.x, 0, hbox.depth);
                hbox.Add(0, rule);
                rule.Set(rule.width, rule.height + margin + thickness.w, rule.depth + margin + thickness.y, 0);
            }

            if (thickness.z > 0)
            {
                var rule = HorizontalRule.Get(hbox.height, thickness.z, 0, hbox.depth);
                hbox.Add(rule);
                rule.Set(rule.width, rule.height + margin + thickness.w, rule.depth + margin + thickness.y, 0);
            }

            var vbox = VerticalBox.Get(hbox, hbox.totalHeight + margin * 2, TexAlignment.Center);

            if (thickness.y > 0)
            {
                vbox.Add(HorizontalRule.Get(thickness.y, vbox.width, 0));
            }

            if (thickness.w > 0)
            {
                vbox.Add(0, HorizontalRule.Get(thickness.w, vbox.width, 0));
            }

            if (color != Color.clear)
            {
                vbox.Add(0, AttrColorBox.Get(0, color));
                vbox.Add(AttrColorBox.Get(3, color));
            }

            // readjust
            vbox.height = box.height + margin + thickness.w;
            vbox.depth  = box.depth + margin + thickness.y;
            return(vbox);
        }
Example #6
0
        public override Box CreateBox()
        {
            var width  = size.x;
            var height = size.y;

            Box result;

            if (BaseAtom == null)
            {
                result = StrutBox.Get(width, height, 0, 0);
            }
            else if (BaseAtom is SpaceAtom)
            {
                result = StrutBox.Get(width, height, 0, 0);
            }
            else if (width == 0 && BaseAtom is SymbolAtom)
            {
                result = VerticalBox.Get(DelimiterFactory.CreateBox(((SymbolAtom)BaseAtom).Name, height), height, align);
            }
            else if (height == 0 && BaseAtom is SymbolAtom)
            {
                result = HorizontalBox.Get(DelimiterFactory.CreateBoxHorizontal(((SymbolAtom)BaseAtom).Name, width), width, align);
            }
            else if (width == 0)
            {
                result = VerticalBox.Get(BaseAtom.CreateBox(), height, align);
            }
            else if (height == 0)
            {
                result = HorizontalBox.Get(BaseAtom.CreateBox(), width, align);
            }
            else
            {
                result = VerticalBox.Get(HorizontalBox.Get(BaseAtom.CreateBox(), width, align), height, align);
            }

            if (size.x + size.y > 1e-3f)
            {
                TexUtility.CentreBox(result);
            }
            return(result);
        }
Example #7
0
        public override Box CreateBox(TexStyle style)
        {
            var result = HorizontalBox.Get();
            var margin = TEXConfiguration.main.BackdropMargin * TexUtility.SizeFactor(style);
            var box    = baseAtom.CreateBox(style);

            box = VerticalBox.Get(HorizontalBox.Get(box, box.width + (horizontalMargin ? margin * 2 : 0), TexAlignment.Center), box.totalHeight + margin * 2, TexAlignment.Center);
            var endColor   = AttrColorBox.Get(0, color, null);
            var startColor = AttrColorBox.Get(0, color, endColor);
            var bg         = HorizontalRule.Get(box.height, box.width, 0, box.depth, true);

            result.Add(startColor);
            result.Add(bg);
            result.Add(endColor);

            result.Add(StrutBox.Get(-box.width, 0, 0, 0));
            result.Add(box);

            return(result);
        }
Example #8
0
        public override Box CreateBox()
        {
            // Create box for base atom.
            Box   baseBox;
            float delta;

            if (BaseAtom is SymbolAtom && BaseAtom.Type == CharType.BigOperator)
            {
                // Find character of best scale for operator symbol.
                var opChar = TEXPreference.main.GetChar(((SymbolAtom)BaseAtom).Name).GetMetric();
                if (TexContext.Environment.value < TexEnvironment.Text && opChar.ch.nextLargerExist)
                {
                    opChar.Flush();
                    opChar = opChar.ch.nextLarger.GetMetric();
                }
                opChar.shift = -(opChar.height + opChar.depth) / 2;
                baseBox      = HorizontalBox.Get(opChar);

                delta = opChar.bearing;
            }
            else
            {
                baseBox = HorizontalBox.Get(BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox());
                delta   = 0;
            }

            // Create boxes for upper and lower limits.
            Box upperLimitBox, lowerLimitBox;

            TexContext.Environment.Push(MakeSuperScripts ? TexEnvironment.ScriptScript : TexUtility.GetSuperscriptStyle());
            if (UpperLimitAtom is SymbolAtom)
            {
                upperLimitBox = DelimiterFactory.CreateBoxHorizontal(((SymbolAtom)UpperLimitAtom).Name, baseBox.width);
            }
            else
            {
                upperLimitBox = UpperLimitAtom == null ? null : UpperLimitAtom.CreateBox();
            }
            TexContext.Environment.Pop();

            TexContext.Environment.Push(MakeSuperScripts ? TexEnvironment.ScriptScript : TexUtility.GetSubscriptStyle());
            if (LowerLimitAtom is SymbolAtom)
            {
                lowerLimitBox = DelimiterFactory.CreateBoxHorizontal(((SymbolAtom)LowerLimitAtom).Name, baseBox.width);
            }
            else
            {
                lowerLimitBox = LowerLimitAtom == null ? null : LowerLimitAtom.CreateBox();
            }
            TexContext.Environment.Pop();

            // Make all component boxes equally wide.
            var maxWidth = Mathf.Max(Mathf.Max(baseBox.width, upperLimitBox == null ? 0 : upperLimitBox.width),
                                     lowerLimitBox == null ? 0 : lowerLimitBox.width);

            if (baseBox != null)
            {
                baseBox = ChangeWidth(baseBox, maxWidth);
            }
            if (upperLimitBox != null)
            {
                upperLimitBox = ChangeWidth(upperLimitBox, maxWidth);
            }
            if (lowerLimitBox != null)
            {
                lowerLimitBox = ChangeWidth(lowerLimitBox, maxWidth);
            }

            var resultBox  = VerticalBox.Get();
            var opSpacing5 = TEXConfiguration.main.BigOpMargin * TexContext.Scale;
            var kern       = 0f;

            // Create and add box for upper limit.
            if (UpperLimitAtom != null)
            {
                resultBox.Add(StrutBox.Get(0, opSpacing5, 0, 0));
                upperLimitBox.shift  = delta / 2;
                upperLimitBox.shift += TopOffset(BaseAtom);
                resultBox.Add(upperLimitBox);
                kern = Mathf.Max(TEXConfiguration.main.BigOpUpShift * TexContext.Scale,
                                 TEXConfiguration.main.BigOpUpperGap * TexContext.Scale - upperLimitBox.depth);
                resultBox.Add(StrutBox.Get(0, kern, 0, 0));
            }

            // Add box for base atom.
            resultBox.Add(baseBox);

            // Create and add box for lower limit.
            if (LowerLimitAtom != null)
            {
                resultBox.Add(StrutBox.Get(0, Mathf.Max(TEXConfiguration.main.BigOpLowShift * TexContext.Scale,
                                                        TEXConfiguration.main.BigOpLowerGap * TexContext.Scale - lowerLimitBox.height), 0, 0));
                lowerLimitBox.shift  = -delta / 2;
                lowerLimitBox.shift += BottomOffset(BaseAtom);
                resultBox.Add(lowerLimitBox);
                resultBox.Add(StrutBox.Get(0, opSpacing5, 0, 0));
            }

            // Adjust height and depth of result box.
            var baseBoxHeight = baseBox.height;
            var totalHeight   = resultBox.height + resultBox.depth;

            if (upperLimitBox != null)
            {
                baseBoxHeight += opSpacing5 + kern + upperLimitBox.height + upperLimitBox.depth;
            }
            resultBox.height = baseBoxHeight;
            resultBox.depth  = totalHeight - baseBoxHeight;
            return(resultBox);
        }
Example #9
0
        public static Box CreateBox(string symbol, float minHeight)
        {
            minHeight += TEXConfiguration.main.DelimiterRecursiveOffset;
            var ch = TEXPreference.main.GetChar(symbol).GetMetric();

            // Find first version of character that has at least minimum height.
            var totalHeight = ch.height + ch.depth;

            while (totalHeight <= minHeight && ch.ch.nextLargerExist)
            {
                ch.Flush();
                ch          = ch.ch.nextLarger.GetMetric();
                totalHeight = ch.height + ch.depth;
            }

            if (totalHeight < minHeight && ch.ch.extensionExist && !ch.ch.extensionHorizontal)
            {
                var resultBox = VerticalBox.Get();
                resultBox.ExtensionMode = true;
                // Construct box from extension character.
                ch.Flush();
                var ext = ch.ch.GetExtentMetrics();
                if (ext[0] != null)
                {
                    resultBox.Add(ext[0]);
                }
                if (ext[1] != null)
                {
                    resultBox.Add(ext[1]);
                }
                if (ext[2] != null)
                {
                    resultBox.Add(ext[2]);
                }

                // Insert repeatable part multiple times until box is high enough.
                if (ext[3] != null)
                {
                    var repeatBox = ext[3];
                    if (repeatBox.totalHeight <= 0)
                    {
                        throw new ArgumentOutOfRangeException("PULL CHAR DEL ZERO");
                    }
                    while (resultBox.height + resultBox.depth <= minHeight)
                    {
                        if (ext[0] != null && ext[2] != null)
                        {
                            resultBox.Add(1, repeatBox);
                            if (ext[1] != null)
                            {
                                resultBox.Add(resultBox.children.Count - 1, repeatBox);
                            }
                        }
                        else if (ext[2] != null)
                        {
                            resultBox.Add(0, repeatBox);
                        }
                        else
                        {
                            resultBox.Add(repeatBox);
                        }
                    }
                }
                return(resultBox);
            }
            else
            {
                // just enough
                return(ch);
            }
        }
Example #10
0
        public static Box CreateBox(string symbol, float minHeight, TexStyle style)
        {
            minHeight += TEXConfiguration.main.DelimiterRecursiveOffset;
            var charInfo = TEXPreference.main.GetCharMetric(symbol, style);

            // Find first version of character that has at least minimum height.
            var totalHeight = charInfo.height + charInfo.depth;

            //var alter = 0;
            while (totalHeight <= minHeight && charInfo.ch.nextLargerExist)
            {
                //Debug.LogWarningFormat("will: {3} min: {0} cur: {1}+{2}", minHeight, charInfo.height, charInfo.depth, alter);
                charInfo    = TEXPreference.main.GetCharMetric(charInfo.ch.nextLarger, style);
                totalHeight = charInfo.height + charInfo.depth;
                //alter++;
            }

            if (totalHeight > minHeight)
            {
                // Character of sufficient height was found.
                //Debug.LogFormat("owning: {2} min: {0} cur: {1}", minHeight, totalHeight, alter);
                return(CharBox.Get(style, charInfo));
            }
            else if (charInfo.ch.extensionExist && !charInfo.ch.extensionHorizontal)
            {
                var resultBox = VerticalBox.Get();
                resultBox.ExtensionMode = true;
                // Construct box from extension character.
                var extension = charInfo.ch.GetExtentMetrics(style);
                if (extension[0] != null)
                {
                    resultBox.Add(CharBox.Get(style, extension[0]));
                }
                if (extension[1] != null)
                {
                    resultBox.Add(CharBox.Get(style, extension[1]));
                }
                if (extension[2] != null)
                {
                    resultBox.Add(CharBox.Get(style, extension[2]));
                }

                // Insert repeatable part multiple times until box is high enough.
                if (extension[3] != null)
                {
                    var repeatBox = CharBox.Get(style, extension[3]);
                    if (repeatBox.totalHeight <= 0)
                    {
                        throw new ArgumentOutOfRangeException("PULL CHAR DEL ZERO");
                    }
                    while (resultBox.height + resultBox.depth <= minHeight)
                    {
                        if (extension[0] != null && extension[2] != null)
                        {
                            resultBox.Add(1, repeatBox);
                            if (extension[1] != null)
                            {
                                resultBox.Add(resultBox.children.Count - 1, repeatBox);
                            }
                        }
                        else if (extension[2] != null)
                        {
                            resultBox.Add(0, repeatBox);
                        }
                        else
                        {
                            resultBox.Add(repeatBox);
                        }
                    }
                }
                return(resultBox);
            }
            else
            {
                // No extensions available, so use tallest available version of character.
                return(CharBox.Get(style, charInfo));
            }
        }
Example #11
0
        public override Box CreateBox()
        {
            List <List <Box> > boxes = ListPool <List <Box> > .Get();

            List <float> boxesHeight = ListPool <float> .Get();

            List <float> boxesShift = ListPool <float> .Get();

            List <float> boxesWidth = ListPool <float> .Get();

            TexContext.Environment.Push(TexUtility.GetCrampedStyle());

            float padding = TEXConfiguration.main.MatrixMargin * TexContext.Scale;

            for (int i = 0; i < Elements.Count; i++)
            {
                boxes.Add(ListPool <Box> .Get());
                float h = 0f, d = 0f;
                for (int j = 0; j < Elements[i].Count; j++)
                {
                    Box box;
                    if (Elements[i][j] != null)
                    {
                        box = (Elements[i][j].CreateBox());
                    }
                    else
                    {
                        box = (ObjPool <StrutBox> .Get());
                    }
                    boxes[i].Add(box);
                    if (j >= boxesWidth.Count)
                    {
                        boxesWidth.Add(box.width);
                    }
                    else
                    {
                        boxesWidth[j] = Mathf.Max(boxesWidth[j], box.width);
                    }
                    h = Mathf.Max(h, box.height);
                    d = Mathf.Max(d, box.depth);
                }
                boxesHeight.Add(Mathf.Max(h + d, padding / 2f));
                boxesShift.Add(h);
            }

            bool outsideGap = (horizontalLine > 0 && (enumContains(horizontalLine, 0) || enumContains(horizontalLine, 4))) ||
                              (verticalLine > 0 && (enumContains(verticalLine, 0) || enumContains(verticalLine, 4)));

            var vBox      = VerticalBox.Get();
            Box resultBox = vBox;

            Box kern     = null;
            Box kernHalf = null;

            if (boxesWidth.Count > 1 || boxesHeight.Count > 1)
            {
                kern = StrutBox.Get(padding, padding, 0, 0);
            }
            if (outsideGap)
            {
                kernHalf = StrutBox.Get(padding / 2f, padding / 2f, 0, 0);
                vBox.Add(kernHalf);
            }

            TexAlignment firstRowH = alterH(horizontalAlign % 8);
            TexAlignment firstRowV = alterV(verticalAlign % 8);
            TexAlignment firstColH = alterH((horizontalAlign >> 3) % 8);
            TexAlignment firstColV = alterV((verticalAlign >> 3) % 8);
            TexAlignment bodyH     = alterH((horizontalAlign >> 6) % 8);
            TexAlignment bodyV     = alterV((verticalAlign >> 6) % 8);

            for (int i = 0; i < Elements.Count; i++)
            {
                var list = HorizontalBox.Get();
                if (outsideGap)
                {
                    list.Add(kernHalf);
                }
                for (int j = 0; j < Elements[i].Count; j++)
                {
                    if (i == 0)
                    {
                        list.Add(VerticalBox.Get(HorizontalBox.Get(boxes[i][j], boxesWidth[j], firstRowH), boxesHeight[i], firstRowV));
                    }
                    else if (j == 0)
                    {
                        list.Add(VerticalBox.Get(HorizontalBox.Get(boxes[i][j], boxesWidth[j], firstColH), boxesHeight[i], firstColV));
                    }
                    else
                    {
                        list.Add(VerticalBox.Get(HorizontalBox.Get(boxes[i][j], boxesWidth[j], bodyH), boxesHeight[i], bodyV));
                    }

                    if (j < Elements[i].Count - 1)
                    {
                        list.Add(kern);
                    }
                    else if (outsideGap)
                    {
                        list.Add(kernHalf);
                    }
                }
                list.depth = boxesHeight[i] - list.height;
                vBox.Add(list);
                if (i < Elements.Count - 1)
                {
                    vBox.Add(kern);
                }
                else if (outsideGap)
                {
                    vBox.Add(kernHalf);
                }
            }

            var lineThick = TEXConfiguration.main.LineThickness * TexContext.Scale;

            //Add horizontal lines for table
            if (horizontalLine > 0)
            {
                var outside      = enumContains(horizontalLine, 0);
                var first        = enumContains(horizontalLine, 1);
                var inset        = enumContains(horizontalLine, 2);
                var firstThick   = enumContains(horizontalLine, 3);
                var outsideThick = enumContains(horizontalLine, 4);

                float gapX      = (padding - lineThick);
                float gapXThick = (padding - (lineThick * 2));
                float gapXNone  = (padding);

                float gapOutside  = (outside ? (outsideThick ? gapXThick : gapX) : gapXNone);
                float gapInset    = (inset ? gapX : gapXNone);
                float lineOutside = outsideThick ? lineThick * 2 : lineThick;
                var   insideBox   = resultBox;

                var hBox = HorizontalBox.Get(resultBox);
                resultBox = hBox;

                if (outsideGap)
                {
                    hBox.Add(StrutBox.Get(-insideBox.width - lineOutside / 2f, 0, 0, 0));
                }
                else
                {
                    hBox.Add(StrutBox.Get(-insideBox.width - lineOutside * 1.5f, 0, 0, 0));
                }

                for (int i = 0; i < boxesWidth.Count; i++)
                {
                    if (i == 0)
                    {
                        if (outside)
                        {
                            hBox.Add(HorizontalRule.Get(insideBox.height, lineOutside, 0, insideBox.depth));
                        }
                        hBox.Add(StrutBox.Get(boxesWidth[i] + gapOutside, 0, 0, 0));
                        continue;
                    }
                    if (i == 1)
                    {
                        if (first)
                        {
                            hBox.Add(HorizontalRule.Get(insideBox.height, firstThick ? lineThick * 2 : lineThick, 0, insideBox.depth));
                        }
                        hBox.Add(StrutBox.Get(boxesWidth[i] + (first ? (firstThick ? gapXThick : gapX) : gapXNone), 0, 0, 0));
                        continue;
                    }
                    if (inset)
                    {
                        hBox.Add(HorizontalRule.Get(insideBox.height, lineThick, 0, insideBox.depth));
                    }
                    hBox.Add(StrutBox.Get(boxesWidth[i] + gapInset, 0, 0, 0));
                }
                if (outside)
                {
                    hBox.Add(HorizontalRule.Get(insideBox.height, lineOutside, 0, insideBox.depth));
                }
            }

            if (verticalLine > 0)
            {
                var outside      = enumContains(verticalLine, 0);
                var first        = enumContains(verticalLine, 1);
                var inset        = enumContains(verticalLine, 2);
                var firstThick   = enumContains(verticalLine, 3);
                var outsideThick = enumContains(verticalLine, 4);

                float gapX      = (padding - lineThick);
                float gapXThick = (padding - (lineThick * 2));
                float gapXNone  = (padding);

                float gapOutside  = (outside ? (outsideThick ? gapXThick : gapX) : gapXNone);
                float gapInset    = (inset ? gapX : gapXNone);
                float lineOutside = outsideThick ? lineThick * 2 : lineThick;
                var   insideBox   = resultBox;
                var   size        = insideBox.width;

                vBox      = VerticalBox.Get(resultBox);
                resultBox = vBox;

                if (outsideGap)
                {
                    vBox.Add(StrutBox.Get(0, -insideBox.totalHeight - lineOutside / 2f, 0, 0));
                }
                else
                {
                    vBox.Add(StrutBox.Get(0, -insideBox.totalHeight, 0, 0));
                }

                for (int i = 0; i < boxesHeight.Count; i++)
                {
                    if (i == 0)
                    {
                        if (outside)
                        {
                            vBox.Add(HorizontalRule.Get(lineOutside, size, 0));
                        }
                        vBox.Add(StrutBox.Get(0, boxesHeight[i] + (outsideGap ? gapOutside : gapOutside / 2f), 0, 0));
                    }
                    else if (i == 1)
                    {
                        if (first)
                        {
                            vBox.Add(HorizontalRule.Get(firstThick ? lineThick * 2 : lineThick, size, 0));
                        }
                        var thick = (first ? (firstThick ? gapXThick : gapX) : gapXNone);
                        vBox.Add(StrutBox.Get(0, boxesHeight[i] + (boxesHeight.Count == 2 && !outsideGap ? thick / 2f : thick), 0, 0));
                    }
                    else
                    {
                        if (inset)
                        {
                            vBox.Add(HorizontalRule.Get(lineThick, size, 0));
                        }
                        vBox.Add(StrutBox.Get(0, boxesHeight[i] + (i < boxesHeight.Count - 1 || outsideGap ? gapInset : gapInset / 2f), 0, 0));
                    }
                }
                if (outside && outsideGap)
                {
                    vBox.Add(HorizontalRule.Get(lineOutside, size, 0, 0));
                }
            }

            TexUtility.CentreBox(resultBox);

            TexContext.Environment.Pop();

            //Clear resources
            ListPool <float> .Release(boxesHeight);

            ListPool <float> .Release(boxesWidth);

            ListPool <float> .Release(boxesShift);

            for (int i = 0; i < boxes.Count; i++)
            {
                ListPool <Box> .ReleaseNoFlush(boxes[i]);
            }
            ListPool <List <Box> > .ReleaseNoFlush(boxes);


            return(resultBox);
        }
Example #12
0
        public override Box CreateBox(TexStyle style)
        {
            // Create box for base atom.
            var baseBox = (BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox(style));

            if (SubscriptAtom == null && SuperscriptAtom == null)
            {
                return(baseBox);
            }

            // Save it shift and use it later
            var shift = baseBox.shift;

            // Create result box.
            var resultBox = HorizontalBox.Get(baseBox);

            var subscriptStyle   = TexUtility.GetSubscriptStyle(style);
            var superscriptStyle = TexUtility.GetSuperscriptStyle(style);

            // Set delta value and preliminary shift-up and shift-down amounts depending on type of base atom.
            var   delta = 0f;
            float shiftUp, shiftDown;

            if (BaseAtom is AccentedAtom)
            {
                var accentedBox = ((AccentedAtom)BaseAtom).BaseAtom.CreateBox(TexUtility.GetCrampedStyle(style));
                shiftUp   = accentedBox.height - TEXConfiguration.main.SupDrop * TexUtility.SizeFactor(superscriptStyle);
                shiftDown = accentedBox.depth + TEXConfiguration.main.SubDrop * TexUtility.SizeFactor(subscriptStyle);
            }
            else if (BaseAtom is CharSymbol)
            {
                var charFont = ((CharSymbol)BaseAtom).GetChar();
                if (!((CharSymbol)BaseAtom).IsTextSymbol)
                {
                    delta = TEXPreference.main.GetCharMetric(charFont, style).advanceDelta;
                }
                if (delta > TexUtility.FloatPrecision && SubscriptAtom == null)
                {
                    resultBox.Add(StrutBox.Get(delta, 0, 0, 0));
                    delta = 0;
                }

                shiftUp   = baseBox.height - TEXConfiguration.main.SupDrop * TexUtility.SizeFactor(superscriptStyle);
                shiftDown = baseBox.depth + TEXConfiguration.main.SubDrop * TexUtility.SizeFactor(subscriptStyle);
            }
            else
            {
                shiftUp   = baseBox.height - TEXConfiguration.main.SupDrop * TexUtility.SizeFactor(superscriptStyle);
                shiftDown = baseBox.depth + TEXConfiguration.main.SubDrop * TexUtility.SizeFactor(subscriptStyle);
            }

            Box superscriptBox          = null;
            Box superscriptContainerBox = null;
            Box subscriptBox            = null;
            Box subscriptContainerBox   = null;

            if (SuperscriptAtom != null)
            {
                // Create box for superscript atom.
                superscriptBox          = SuperscriptAtom.CreateBox(superscriptStyle);
                superscriptContainerBox = HorizontalBox.Get(superscriptBox);

                // Add box for script space.
                superscriptContainerBox.Add(scriptSpaceAtom.CreateBox(style));

                // Adjust shift-up amount.
                float p;
                if (style == TexStyle.Display)
                {
                    p = TEXConfiguration.main.SupMin * TexUtility.SizeFactor(style);
                }
                else                // if (TexUtility.GetCrampedStyle (style) == style)
                {
                    p = TEXConfiguration.main.SupMinNarrow * TexUtility.SizeFactor(style);
                }
                //else
                //	p = TEXConfiguration.main.SupMinNarrow * TexUtility.SizeFactor(style);
                shiftUp = Mathf.Max(shiftUp, p);
            }

            if (SubscriptAtom != null)
            {
                // Create box for subscript atom.
                subscriptBox          = SubscriptAtom.CreateBox(subscriptStyle);
                subscriptContainerBox = HorizontalBox.Get(subscriptBox);

                // Add box for script space.
                subscriptContainerBox.Add(scriptSpaceAtom.CreateBox(style));
            }

            // Check if only superscript is set.
            if (subscriptBox == null)
            {
                superscriptContainerBox.shift = -shiftUp;
                resultBox.Add(superscriptContainerBox);
                resultBox.height = shiftUp + superscriptBox.height;
                return(resultBox);
            }

            // Check if only subscript is set.
            if (superscriptBox == null)
            {
                subscriptBox.shift = Mathf.Max(shiftDown, TEXConfiguration.main.SubMinNoSup * TexUtility.SizeFactor(style));
                resultBox.Add(subscriptContainerBox);
                resultBox.depth = shiftDown + subscriptBox.depth;
                return(resultBox);
            }

            // Adjust shift-down amount.
            shiftDown = Mathf.Max(shiftDown, TEXConfiguration.main.SubMinOnSup * TexUtility.SizeFactor(style));

            // Space between subscript and superscript.
            float scriptsInterSpace = shiftUp - superscriptBox.depth + shiftDown - subscriptBox.height;

            /*if (scriptsInterSpace < 4 * defaultLineThickness)
             * {
             *      shiftUp += 4 * defaultLineThickness - scriptsInterSpace;
             *
             *      // Position bottom of superscript at least 4/5 of X-height above baseline.
             *      float psi = 0.8f * TexUtility.SizeFactor(style) - (shiftUp - superscriptBox.depth);
             *      if (psi > 0)
             *      {
             *              shiftUp += psi;
             *              shiftDown -= psi;
             *      }
             * }*/
            scriptsInterSpace = shiftUp - superscriptBox.depth + shiftDown - subscriptBox.height;

            // If baseAtom is null, make it right-aligned

            if (BaseAtom is SpaceAtom && ((SpaceAtom)BaseAtom).policy == StrutPolicy.Misc)
            {
                var max = Mathf.Max(superscriptContainerBox.width, subscriptContainerBox.width);
                if (superscriptContainerBox.width < max)
                {
                    superscriptContainerBox.Add(0, StrutBox.Get(max - superscriptContainerBox.width, 0, 0, 0));
                }
                if (subscriptContainerBox.width < max)
                {
                    subscriptContainerBox.Add(0, StrutBox.Get(max - subscriptContainerBox.width, 0, 0, 0));
                }
            }

            // Create box containing both superscript and subscript.
            var scriptsBox = VerticalBox.Get();

            scriptsBox.Add(superscriptContainerBox);
            scriptsBox.Add(StrutBox.Get(0, scriptsInterSpace, 0, 0));
            scriptsBox.Add(subscriptContainerBox);
            scriptsBox.height = shiftUp + superscriptBox.height;
            scriptsBox.depth  = shiftDown + subscriptBox.depth;
            scriptsBox.shift  = shift;
            resultBox.Add(scriptsBox);

            return(resultBox);
        }
Example #13
0
        public override Box CreateBox()
        {
            // Create box for base atom.

            // Save it shift and use it later

            // Create result box.


            // Set delta value and preliminary shift-up and shift-down amounts depending on type of base atom.
            float shiftUp = 0, shiftDown = 0;

            Box baseBox; HorizontalBox resultBox;

            if (SubscriptAtom == null && SuperscriptAtom == null)
            {
                return(BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox());
            }
            if (BaseAtom is AccentedAtom)
            {
                TexContext.Environment.Push(TexUtility.GetCrampedStyle());
                baseBox = ((AccentedAtom)BaseAtom).BaseAtom.CreateBox();
                TexContext.Environment.Pop();
            }
            else
            {
                baseBox = (BaseAtom == null ? StrutBox.Empty : BaseAtom.CreateBox());
                //if (BaseAtom is CharSymbol)
                //{
                //    var delta = 0f;
                //    var ch = ((CharSymbol)BaseAtom).GetChar();
                //    if (!((CharSymbol)BaseAtom).IsTextSymbol)
                //        delta =  ch.italix + bearing - width;
                //    if (delta > TexUtility.FloatPrecision && SubscriptAtom == null)
                //    {
                //        resultBox.Add(StrutBox.Get(delta, 0, 0, 0));
                //        delta = 0;
                //    }
                //}
            }

            resultBox = HorizontalBox.Get(baseBox);

            var shift = baseBox.shift;


            Box           superscriptBox          = null;
            HorizontalBox superscriptContainerBox = null;
            Box           subscriptBox            = null;
            HorizontalBox subscriptContainerBox   = null;

            TexContext.Environment.Push(TexUtility.GetSuperscriptStyle());
            shiftUp = baseBox.height - TEXConfiguration.main.SupDrop * TexContext.Scale;

            if (SuperscriptAtom != null)
            {
                // Create box for superscript atom.
                superscriptBox          = SuperscriptAtom.CreateBox();
                superscriptContainerBox = HorizontalBox.Get(superscriptBox);

                // Add box for script space.
                superscriptContainerBox.Add(scriptSpaceAtom.CreateBox());

                // Adjust shift-up amount.
                float p;
                if (TexContext.Environment.value == TexEnvironment.Display)
                {
                    p = TEXConfiguration.main.SupMin * TexContext.Scale;
                }
                else
                {
                    p = TEXConfiguration.main.SupMinNarrow * TexContext.Scale;
                }

                shiftUp = Mathf.Max(shiftUp, p);
            }

            TexContext.Environment.Pop();

            TexContext.Environment.Push(TexUtility.GetSubscriptStyle());
            shiftDown = baseBox.depth + TEXConfiguration.main.SubDrop * TexContext.Scale;

            if (SubscriptAtom != null)
            {
                // Create box for subscript atom.
                subscriptBox          = SubscriptAtom.CreateBox();
                subscriptContainerBox = HorizontalBox.Get(subscriptBox);

                // Add box for script space.
                subscriptContainerBox.Add(scriptSpaceAtom.CreateBox());
            }

            TexContext.Environment.Pop();

            // Check if only superscript is set.
            if (subscriptBox == null)
            {
                superscriptContainerBox.shift = -shiftUp;
                resultBox.Add(superscriptContainerBox);
                resultBox.height = shiftUp + superscriptBox.height;
                return(resultBox);
            }

            // Check if only subscript is set.
            if (superscriptBox == null)
            {
                subscriptBox.shift = Mathf.Max(shiftDown, TEXConfiguration.main.SubMinNoSup * TexContext.Scale);
                resultBox.Add(subscriptContainerBox);
                resultBox.depth = shiftDown + subscriptBox.depth;
                return(resultBox);
            }



            // Adjust shift-down amount.
            shiftDown = Mathf.Max(shiftDown, TEXConfiguration.main.SubMinOnSup * TexContext.Scale);

            // Space between subscript and superscript.
            float scriptsInterSpace = shiftUp - superscriptBox.depth + shiftDown - subscriptBox.height;


            scriptsInterSpace = shiftUp - superscriptBox.depth + shiftDown - subscriptBox.height;

            // If baseAtom is null, make it right-aligned

            if (BaseAtom is SpaceAtom && ((SpaceAtom)BaseAtom).policy == StrutPolicy.Misc)
            {
                var max = Mathf.Max(superscriptContainerBox.width, subscriptContainerBox.width);
                if (superscriptContainerBox.width < max)
                {
                    superscriptContainerBox.Add(0, StrutBox.Get(max - superscriptContainerBox.width, 0, 0, 0));
                }
                if (subscriptContainerBox.width < max)
                {
                    subscriptContainerBox.Add(0, StrutBox.Get(max - subscriptContainerBox.width, 0, 0, 0));
                }
            }

            // Create box containing both superscript and subscript.
            var scriptsBox = VerticalBox.Get();

            scriptsBox.Add(superscriptContainerBox);
            scriptsBox.Add(StrutBox.Get(0, scriptsInterSpace, 0, 0));
            scriptsBox.Add(subscriptContainerBox);
            scriptsBox.height = shiftUp + superscriptBox.height;
            scriptsBox.depth  = shiftDown + subscriptBox.depth;
            scriptsBox.shift  = shift;
            resultBox.Add(scriptsBox);

            return(resultBox);
        }
Example #14
0
        public override Box CreateBox(TexStyle style)
        {
            float lineHeight = lineThickness * TexUtility.SizeFactor(style);

            // Create boxes for numerator and demoninator atoms, and make them of equal width.
            var numeratorBox = numerator == null ? StrutBox.Empty :
                               numerator.CreateBox(TexUtility.GetNumeratorStyle(style));
            var denominatorBox = denominator == null ? StrutBox.Empty :
                                 denominator.CreateBox(TexUtility.GetDenominatorStyle(style));

            float maxWidth = (numeratorBox.width < denominatorBox.width ? denominatorBox.width : numeratorBox.width) + TEXConfiguration.main.FractionMargin * TexUtility.SizeFactor(style);

            numeratorBox   = HorizontalBox.Get(numeratorBox, maxWidth, numeratorAlignment);
            denominatorBox = HorizontalBox.Get(denominatorBox, maxWidth, denominatorAlignment);

            // Calculate preliminary shift-up and shift-down amounts.
            float shiftUp, shiftDown;
            var   styleFactor = TexUtility.SizeFactor(style);

            if (style >= TexStyle.Text)
            {
                styleFactor *= TEXConfiguration.main.FractionNarrowFactor;
            }

            shiftUp   = TEXConfiguration.main.NumeratorShift * styleFactor;
            shiftDown = TEXConfiguration.main.DenominatorShift * styleFactor;

            // Create result box.
            var resultBox = VerticalBox.Get();

            // add box for numerator.
            resultBox.Add(numeratorBox);

            // Calculate clearance and adjust shift amounts.
            //var axis = TEXConfiguration.main.AxisHeight * TexUtility.SizeFactor(style);

            // Calculate clearance amount.
            float clearance = lineHeight > 0 ? TEXConfiguration.main.FractionGap : TEXConfiguration.main.FractionGapNoLine;

            // Adjust shift amounts.
            var kern1  = shiftUp - numeratorBox.depth;
            var kern2  = shiftDown - denominatorBox.height;
            var delta1 = clearance - kern1;
            var delta2 = clearance - kern2;

            if (delta1 > 0)
            {
                shiftUp += delta1;
                kern1   += delta1;
            }
            if (delta2 > 0)
            {
                shiftDown += delta2;
                kern2     += delta2;
            }

            if (lineHeight > 0)
            {
                // Draw fraction line.

                resultBox.Add(StrutBox.Get(0, kern1, 0, 0));
                resultBox.Add(HorizontalRule.Get(lineHeight, numeratorBox.width, 0));
                resultBox.Add(StrutBox.Get(0, kern2, 0, 0));
            }
            else
            {
                // Do not draw fraction line.

                var kern = kern1 + kern2;
                resultBox.Add(StrutBox.Get(0, kern, 0, 0));
            }

            // add box for denominator.
            resultBox.Add(denominatorBox);

            // Adjust height and depth of result box.
            resultBox.height = shiftUp + numeratorBox.height;
            resultBox.depth  = shiftDown + lineHeight + denominatorBox.depth;

            TexUtility.CentreBox(resultBox, style);
            return(resultBox);
        }