1. Поправила баг : для inline формул не учитывается приоритет операторов

2. Реализовала функцию, в которой для операторов, мат объектов, стоящих в начале/конце строки, GapLeft/GapRight обнуляются.
3. Для ускорения доработала следующее (http://bugzserver/show_bug.cgi?id=29274):
a) Убрала из Correct_Content выставление текстовых настроек для пустых Run, также убрала удаление/добавление Placeholder без необходимости
b) Реализовала Save_RecalculateObject, Load_RecalculateObject, Prepare_RecalculateObject

git-svn-id: svn://192.168.3.15/activex/AVS/Sources/TeamlabOffice/trunk/OfficeWeb@62426 954022d7-b5bf-4e40-9824-e11837661b57

Word/Editor/Math.js

@@ -855,9 +855,14 @@ ParaMath.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     RPI.MergeMathInfo(this.ParaMathRPI);
     var ArgSize = new CMathArgSize();
 
-    this.Root.Set_Paragraph(Para);
-    this.Root.Set_ParaMath(this, null);
-    this.Root.PreRecalc(null, this, ArgSize, RPI);
+    // в случае если нужно сделать для пересчета каждой строки этот блоки, необходимо переделать PreRecalc, чтобы не перезаписывались Gaps, которые были уже рассчитаны на UpdateOperators
+    if(this.Root.IsFirstRange(ParaLine, ParaRange))
+    {
+        this.Root.Set_Paragraph(Para);
+        this.Root.Set_ParaMath(this, null);
+        this.Root.PreRecalc(null, this, ArgSize, RPI);
+    }
+
 
     ////////////////////////////////////////////////////////////
 
@@ -899,18 +904,27 @@ ParaMath.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
     this.Root.Recalculate_Range(PRS, ParaPr, Depth);
 
-    if(CurrentPage == 0 && PRS.bMathWordLarge && this.State !== ALIGN_EMPTY)
-    {
-        this.UpdateInfoForBreak(PRS);
-        this.State++;
-    }
-
     if(PRS.NewRange == false)
     {
+        // обнуляем GapRight для операторов
+        PRS.OperGapRight       = 0;
+
         var WidthLine = PRS.X - PRS.XRange + PRS.SpaceLen + PRS.WordLen;
+
+        if(PRS.FirstItemOnLine == true && PRS.X + PRS.SpaceLen + PRS.WordLen > PRS.XEnd)
+        {
+            PRS.bMathWordLarge = true;
+        }
+
         this.UpdateWidthLine(PRS, WidthLine);
     }
 
+    if(CurrentPage == 0 && PRS.bMathWordLarge && this.State !== ALIGN_EMPTY)
+    {
+        this.UpdateInfoForBreak(PRS);
+        this.State++;
+    }
+
     this.ParaMathRPI.ClearRecalculate();
 };
 ParaMath.prototype.UpdateInfoForBreak = function(PRS)
@@ -938,6 +952,8 @@ ParaMath.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
 {
     var SpaceLen   = PRSC.SpaceLen;
 
+    this.Root.UpdateOperators(_CurLine, _CurRange);
+
     this.Root.Recalculate_Range_Width(PRSC, _CurLine, _CurRange);
 
     PRSC.Range.W        += PRSC.SpaceLen - SpaceLen;
@@ -952,6 +968,8 @@ ParaMath.prototype.UpdateWidthLine = function(PRS, Width)
     var MaxW    = this.CurPageInfo.MaxLineW,
         CurLine = PRS.Line - this.Root.StartLine;
 
+    Width -= PRS.OperGapRight + PRS.OperGapLeft;
+
     if(MaxW < Width && CurLine !== 0 && RecalCurrentMath == true)
     {
         this.CurPageInfo.MaxLineW = Width;
@@ -978,20 +996,15 @@ ParaMath.prototype.Recalculate_PageEndInfo = function(PRSI, _CurLine, _CurRange)
 };
 ParaMath.prototype.Save_RecalculateObject = function(Copy)
 {
-    var RecalcObj = new CRunRecalculateObject(this.StartLine, this.StartRange);
-    RecalcObj.Save_Lines( this, Copy );
-
-    // TODO: Сделать сохранение пересчета у формулы
-
-    return RecalcObj;
+    return this.Root.Save_RecalculateObject(Copy);
 };
 ParaMath.prototype.Load_RecalculateObject = function(RecalcObj)
 {
-    RecalcObj.Load_Lines(this);
+    this.Root.Load_RecalculateObject(RecalcObj);
 };
 ParaMath.prototype.Prepare_RecalculateObject = function()
 {
-    this.protected_ClearLines();
+    this.Root.Prepare_RecalculateObject();
 };
 ParaMath.prototype.Is_EmptyRange = function(_CurLine, _CurRange)
 {

Word/Editor/Paragraph_Recalculate.js

@@ -2177,6 +2177,10 @@ function CParagraphRecalculateStateWrap(Para)
     this.WrapIndent         = 0; // WrapIndent нужен для сравнения с длиной слова (когда слово разбивается по Compare Oper): ширина первой строки формулы не должна быть меньше WrapIndent
     this.bFirstCompareOper  = true;
 
+    // у "крайних" в строке операторов/мат объектов сооответствующий Gap равен нулю
+    this.OperGapRight       = 0;
+    this.OperGapLeft        = 0;
+    this.bInsideOper        = false; // учитываем есть ли разбивка внутри мат объекта, чтобы случайно не вставить в конец пред оператора (при Brk_Before == false)
 }
 
 CParagraphRecalculateStateWrap.prototype =
@@ -2205,8 +2209,11 @@ CParagraphRecalculateStateWrap.prototype =
         this.bEndRunToContent    = false;
         this.PosEndRun           = new CParagraphContentPos();
 
+        this.OperGapRight        = 0;
+        this.OperGapLeft         = 0;
         this.WrapIndent          = 0;
         this.bFirstCompareOper   = true;
+        this.bInsideOper        = false;
     },
 
     // Обнуляем некоторые параметры перед новым отрезком
@@ -2234,8 +2241,11 @@ CParagraphRecalculateStateWrap.prototype =
         this.bEndRunToContent = false;
         this.PosEndRun        = new CParagraphContentPos();
 
+        this.OperGapRight       = 0;
+        this.OperGapLeft         = 0;
         this.WrapIndent         = 0;
         this.bFirstCompareOper  = true;
+        this.bInsideOper        = false;
     },
 
     Reset_PrevLineRecalcInfo : function()

Word/Math/accent.js

@@ -547,6 +547,7 @@ CAccent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     var WordLen = PRS.WordLen; // запоминаем, чтобы внутр мат объекты не увеличили WordLen
 
     PRS.bMath_OneLine = true;
+    PRS.bInsideOper   = false;
 
     var oBase = this.getBase();
     oBase.Recalculate_Reset(PRS.Range, PRS.Line ); // обновим StartLine и StartRange

Word/Math/base.js

@@ -1747,6 +1747,8 @@ CMathBase.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
         this.BrGapRight = this.GapRight;
     }
 
+    PRS.bInsideOper   = false;
+
     if(this.bOneLine == true)
     {
         PRS.bMath_OneLine = this.bOneLine;
@@ -1763,7 +1765,7 @@ CMathBase.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                 }
                 else
                 {
-                    Item.Recalculate_Reset( PRS.Range, PRS.Line ); // обновим StartLine и StartRange
+                    Item.Recalculate_Reset(PRS.Range, PRS.Line); // обновим StartLine и StartRange
                     Item.Recalculate_Range(PRS, ParaPr, Depth);
                 }
             }
@@ -1796,6 +1798,7 @@ CMathBase.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
             PRS.WordLen += this.BrGapLeft;
         }
 
+
         for(var Pos = RangeStartPos; Pos < Len; Pos++)
         {
             var Item = this.Content[Pos];
@@ -2024,6 +2027,35 @@ CMathBase.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange
 
     this.Bounds.SetWidth(CurLine, PRSC.Range.W - RangeW);
 };
+CMathBase.prototype.UpdateOperators = function(_CurLine, _CurRange)
+{
+    var CurLine  = _CurLine - this.StartLine;
+    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );
+
+    if(this.bOneLine == true)
+    {
+        result = true;
+    }
+    else
+    {
+        var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
+        var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);
+
+        var result = true;
+
+        if(this.ParaMath.Is_BrkBinBefore() == true)
+        {
+            result = this.Content[StartPos].UpdateOperators(_CurLine, _CurRange);
+        }
+        else
+        {
+            result = this.Content[EndPos].UpdateOperators(_CurLine, _CurRange);
+
+        }
+    }
+
+    return result;
+};
 CMathBase.prototype.Is_EmptyRange = function()
 {
     return false;

Word/Math/borderBox.js

@@ -528,6 +528,20 @@ CBox.prototype.Update_WordLen = function(PRS, WordLen)
 {
     PRS.WordLen   = WordLen;
 };
+CBox.prototype.UpdateOperators = function(_CurLine, _CurRange)
+{
+    if(true == this.ParaMath.Is_BrkBinBefore())
+    {
+        this.GapLeft = 0;
+    }
+    else
+    {
+        this.GapRight = 0;
+    }
+
+    this.size.width = this.Content[0].size.width + this.GapLeft + this.GapRight;
+
+};
 
 
 function CMathBarPr()

Word/Math/degree.js

@@ -862,6 +862,8 @@ CDegreeSubSup.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 {
     this.bOneLine = PRS.bMath_OneLine;
 
+    PRS.bInsideOper   = false;
+
     if(this.bOneLine === true)
     {
         CDegreeSubSup.superclass.Recalculate_Range.call(this, PRS, ParaPr, Depth);
@@ -890,6 +892,8 @@ CDegreeSubSup.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
         PRS.Update_CurPos(0, Depth);
         PRS.bMath_OneLine  = false;
 
+        PRS.bInsideOper   = false;
+
         if(this.Pr.type == DEGREE_SubSup) // baseContent, iters
             this.baseContent.Recalculate_Range(PRS, ParaPr, Depth+1);
 

Word/Math/mathContent.js

@@ -1100,9 +1100,6 @@ CMathContent.prototype.private_CorrectContent = function()
     {
         current = this.Content[currPos];
 
-        if(currPos < len && para_Math_Run === current.Type)
-            current.Math_Correct_Content();
-
         var bLeftRun  = currPos > 0 ? this.Content[currPos-1].Type == para_Math_Run : false,
             bRightRun = currPos < len - 1 ? this.Content[currPos + 1].Type === para_Math_Run : false;
 
@@ -1123,13 +1120,13 @@ CMathContent.prototype.private_CorrectContent = function()
             currPos += 2;
 
         }
-        else if(bCurrComp && bLeftEmptyRun)
+        /*else if(bCurrComp && bLeftEmptyRun)
         {
             emptyRun = this.Content[currPos-1];
 
             this.Apply_TextPrForRunEmpty(emptyRun, current);
             currPos++;
-        }
+        }*/
         else if(bDeleteEmptyRun)
         {
             this.Remove_FromContent(currPos, 1);
@@ -1168,12 +1165,12 @@ CMathContent.prototype.private_CorrectContent = function()
             this.Apply_TextPrForRunEmpty(emptyRun, this.Content[len - 1]);
             this.Internal_Content_Add(currPos, emptyRun);
         }
-        else if(bLastRunEmpty)
+        /*else if(bLastRunEmpty)
         {
             emptyRun = this.Content[len-1];
 
             this.Apply_TextPrForRunEmpty(emptyRun, this.Content[len - 2]);
-        }
+        }*/
     }
 
 };
@@ -1238,17 +1235,25 @@ CMathContent.prototype.Correct_Content = function(bInnerCorrection)
         this.Add_ToContent(0, NewMathRun);
     }
 
-    for (var nPos = 0, nCount = this.Content.length; nPos < nCount; nPos++)
-    {
-        if(para_Math_Run === this.Content[nPos].Type)
-            this.Content[nPos].Math_Correct_Content();
-    }
+    // не корректируем, если в контенте только один плейсхолдер
+
+    var bOnlyPlh = this.Content.length == 1 && this.Content[0].OnlyOnePlaceholder();
 
-    if (this.Content.length == 1)
+    if(bOnlyPlh == false)
     {
-        if(this.Content[0].Is_Empty())
-            this.Content[0].fillPlaceholders();
+        for (var nPos = 0, nCount = this.Content.length; nPos < nCount; nPos++)
+        {
+            if(para_Math_Run === this.Content[nPos].Type)
+                this.Content[nPos].Math_Correct_Content();
+        }
+
+        if (this.Content.length == 1)
+        {
+            if(this.Content[0].Is_Empty())
+                this.Content[0].fillPlaceholders();
+        }
     }
+
 };
 
 CMathContent.prototype.Correct_ContentPos = function(nDirection)
@@ -3957,6 +3962,9 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
         }
         else // контент может занимать несколько строк
         {
+            var FirstItemOnLine = PRS.FirstItemOnLine,
+                Word            = PRS.Word;
+
             Item.Recalculate_Range(PRS, ParaPr, Depth + 1);
 
             if(Type == para_Math_Composition)
@@ -3964,10 +3972,14 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                 // перед мат объектом идет break_operator и он не является первым элементом в строке
                 if(Item.kind == MATH_BOX)
                 {
-                    var BoxLen = Item.size.width;
+                    var BoxLen      = Item.size.width,
+                        BoxGapLeft  = Item.GapLeft,
+                        BoxGapRight = Item.GapRight;
 
                     if(Brk_Before == true) // break_operator должен идти в начале слова
                     {
+                        PRS.X += PRS.SpaceLen + PRS.WordLen;
+
                         if(PRS.Word == true)
                         {
                             // обновим : начало нового слова - конец предыдущего Run
@@ -3976,10 +3988,10 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
                             PRS.Update_CurPos(PRS.PosEndRun.Get(_Depth-1), _Depth-1);
                             PRS.Set_LineBreakPos(PRS.PosEndRun.Get(_Depth));
+
+                            PRS.SpaceLen = BoxLen;
                         }
 
-                        PRS.X += PRS.SpaceLen + PRS.WordLen;
-                        PRS.SpaceLen = BoxLen;
                         PRS.WordLen = 0;
 
                         if(PRS.Word)
@@ -3989,11 +4001,13 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                     }
                     else
                     {
-                        PRS.SpaceLen += BoxLen;
+                        var bOverXEnd = PRS.X + PRS.SpaceLen + PRS.WordLen + BoxLen - BoxGapRight > PRS.XEnd;
+
+                        PRS.OperGapRight = BoxGapRight;
 
                         // Слово не убирается в отрезке. Переносим слово в следующий отрезок
                         // FirstItemOnLine == false - слово оказалось не единственным элементом в промежутке, делаем перенос
-                        if (PRS.FirstItemOnLine == false && PRS.X + PRS.SpaceLen + PRS.WordLen > PRS.XEnd)
+                        if (PRS.FirstItemOnLine == false && bOverXEnd)
                         {
                             PRS.MoveToLBP = true;
                             PRS.NewRange = true;
@@ -4001,7 +4015,7 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                             this.ParaMath.UpdateWidthLine(PRS, PRS.X - PRS.XRange);
                         }
 
-                        PRS.X += PRS.SpaceLen + PRS.WordLen;
+                        PRS.X += PRS.SpaceLen + PRS.WordLen + BoxLen;
                         PRS.SpaceLen = 0;
                         PRS.WordLen = 0;
 
@@ -4022,7 +4036,9 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                         this.ParaMath.UpdateWidthLine(PRS, PRS.X - PRS.XRange);
                     }
 
-                    if(Brk_Before == false && PRS.Word == false)
+                    var bInsideOperator = Item.bOneLine == false && PRS.bInsideOper == true;
+
+                    if(Brk_Before == false && Word == false && bInsideOperator == false)
                     {
                         // обновим : начало нового слова - конец предыдущего Run
                         var _Depth = PRS.PosEndRun.Depth;
@@ -4106,8 +4122,15 @@ CMathContent.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRa
 {
     var RangeW = PRSC.Range.W;
     var CurLine = _CurLine - this.StartLine;
+    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );
 
-    CMathContent.superclass.Recalculate_Range_Width.call(this, PRSC, _CurLine, _CurRange);
+    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
+    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);
+
+    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
+    {
+        this.Content[CurPos].Recalculate_Range_Width( PRSC, _CurLine, _CurRange );
+    }
 
     this.Bounds.SetWidth(CurLine, PRSC.Range.W - RangeW);
 };
@@ -4136,6 +4159,36 @@ CMathContent.prototype.Recalculate_LineMetrics = function(PRS, ParaPr, _CurLine,
 
     ContentMetrics.UpdateMetrics(NewContentMetrics);
 };
+CMathContent.prototype.UpdateOperators = function(_CurLine, _CurRange)
+{
+    var CurLine  = _CurLine - this.StartLine;
+    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );
+
+    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
+    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);
+
+    var result = false;
+
+    if(this.ParaMath.Is_BrkBinBefore() == true)
+    {
+        while(StartPos <= EndPos && result == false)
+        {
+            result = this.Content[StartPos].UpdateOperators(_CurLine, _CurRange);
+            StartPos++;
+        }
+    }
+    else
+    {
+        while(StartPos <= EndPos && result == false)
+        {
+            result = this.Content[EndPos].UpdateOperators(_CurLine, _CurRange);
+            EndPos--;
+        }
+    }
+
+    return result;
+
+};
 CMathContent.prototype.Get_Bounds = function()
 {
     return this.Bounds.Get_Bounds();
@@ -4267,6 +4320,13 @@ CMathContent.prototype.IsFirstLine = function(Line)
     var CurLine  = Line - this.StartLine;
     return CurLine == 0;
 };
+CMathContent.prototype.IsFirstRange = function(Line, Range)
+{
+    var CurLine  = Line - this.StartLine,
+        CurRange = Range - this.StartRange;
+
+    return CurLine == 0 && CurRange == 0;
+};
 CMathContent.prototype.IsEndLine = function(Line)
 {
     var CurLine  = Line - this.StartLine;

Word/Math/mathText.js

@@ -66,8 +66,8 @@ function CMathText(bJDraw)
 
     this.rasterOffsetX = 0;
     this.rasterOffsetY = 0;
-    this.GapLeft = 0;
-    this.GapRight = 0;
+    this.GapLeft       = 0;
+    this.GapRight      = 0;
 
     this.FontSlot  = fontslot_ASCII;
 
@@ -638,8 +638,7 @@ CMathText.prototype =
                 width = metricsTxt.Width;
         }
 
-
-        this.size.width  = this.GapLeft + this.GapRight + width;
+        this.size.width  = width;
         this.size.height = height;
         this.size.ascent = ascent;
 
@@ -654,9 +653,31 @@ CMathText.prototype =
         else
             this.Parent = null;
     },
+    Get_Width: function() // работаем через функцию, т.к. поля  GapLeft и GapRight могут измениться из-за изменения переноса, а пересчет (Measure) в этом случае не прийдет
+    {
+        return this.size.width + this.GapLeft + this.GapRight;
+    },
+    Get_Width2: function() // работаем через функцию, т.к. поля  GapLeft и GapRight могут измениться из-за изменения переноса, а пересчет (Measure) в этом случае не прийдет
+    {
+        return ( (this.size.width + this.GapLeft + this.GapRight)* TEXTWIDTH_DIVIDER ) | 0;
+    },
     Get_WidthVisible: function()
     {
-        return this.size.width;
+        return this.size.width + this.GapLeft + this.GapRight;
+    },
+    Update_GapLeft: function(Gap)
+    {
+        this.GapLeft = Gap;
+        //this.size.width = this.MeasureWidth + this.GapRight + this.GapLeft;
+
+        //this.Width = (this.size.width * TEXTWIDTH_DIVIDER) | 0;
+    },
+    Update_GapRight: function(Gap)
+    {
+        this.GapRight = Gap;
+        //this.size.width = this.MeasureWidth + this.GapRight + this.GapLeft;
+
+        //this.Width = (this.size.width * TEXTWIDTH_DIVIDER) | 0;
     },
     Draw_Elements: function(PDSE)
     {
@@ -920,7 +941,7 @@ CMathAmp.prototype =
         {
             this.size =
             {
-                width:          this.AmpText.size.width + this.GapLeft + this.GapRight,
+                width:          this.AmpText.size.width/* + this.GapLeft + this.GapRight*/,
                 height:         this.AmpText.size.height,
                 ascent:         this.AmpText.size.ascent
             };
@@ -947,9 +968,15 @@ CMathAmp.prototype =
     {
         return !this.bEqArray;
     },
+    // special for Run
     Get_WidthVisible: function()
     {
-        return this.size.width;
+        return this.size.width + this.GapLeft + this.GapRight;
+    },
+    // работаем через функцию, т.к. поля  GapLeft и GapRight могут измениться из-за изменения переноса, а пересчет (Measure) в этом случае не прийдет
+    Get_Width: function()
+    {
+        return this.size.width + this.GapLeft + this.GapRight;
     },
     setPosition: function(pos)
     {
@@ -965,7 +992,7 @@ CMathAmp.prototype =
             this.AmpText.Draw(x + this.GapLeft, y, pGraphics, InfoTextPr);
         else if(editor.ShowParaMarks) // показать метки выравнивания, если включена отметка о знаках параграфа
         {
-            var X  = x + this.pos.x + this.size.width,
+            var X  = x + this.pos.x + this.Get_Width(),
                 Y  = y + this.pos.y,
                 Y2 = y + this.pos.y - this.AmpText.size.height;
 

Word/Math/nary.js

@@ -461,6 +461,8 @@ CNary.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 {
     this.bOneLine = PRS.bMath_OneLine;
 
+    PRS.bInsideOper   = false;
+
     if(this.bOneLine === true)
     {
         CNary.superclass.Recalculate_Range.call(this, PRS, ParaPr, Depth);
@@ -565,6 +567,28 @@ CNary.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
         this.Bounds.SetWidth(CurLine, PRSC.Range.W - RangeW);
     }
 };
+CNary.prototype.UpdateOperators = function(_CurLine, _CurRange)
+{
+    /*var CurLine  = _CurLine - this.StartLine;
+    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );
+
+    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
+    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);*/
+
+    var result = true;
+
+    if(this.ParaMath.Is_BrkBinBefore() == true)
+    {
+        result = this.Arg.UpdateOperators(_CurLine, _CurRange);
+    }
+    else
+    {
+        result = this.Arg.UpdateOperators(_CurLine, _CurRange);
+
+    }
+
+    return result;
+};
 CNary.prototype.Draw_Elements = function(PDSE)
 {
     var CurLine  = PDSE.Line - this.StartLine;

Word/Math/operators.js

@@ -3440,6 +3440,8 @@ CDelimiter.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 {
     this.bOneLine = PRS.bMath_OneLine == true || this.Content.length > 1; // this.Content.length > 1 - несколько контентов, разделенные сепараторами
 
+    PRS.bInsideOper   = false;
+
     if(this.bOneLine == false)
     {
         var CurLine  = PRS.Line - this.StartLine;