Exemple #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);
        }
Exemple #2
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);
        }
        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);
        }
Exemple #4
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);
        }
        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);
        }