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();
 
+    // в случае если нужно сделать для пересчета каждой строки этот блоки, необходимо переделать 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/Editor/Run.js

@@ -2042,6 +2042,8 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     var ParaLine        = PRS.Line;
     var ParaRange       = PRS.Range;
     var bMathWordLarge  = PRS.bMathWordLarge;
+    var OperGapRight    = PRS.OperGapRight;
+    var OperGapLeft     = PRS.OperGapLeft;
 
     var Pos = RangeStartPos;
 
@@ -2068,9 +2070,6 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
             {
                 case para_Sym:
                 case para_Text:
-                case para_Math_Text:
-                case para_Math_Ampersand:
-                case para_Math_Placeholder:
                 {
                     // Отмечаем, что началось слово
                     StartWord = true;
@@ -2095,13 +2094,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                             }
                         }
 
-                        if(this.Type == para_Math_Run && true !== NewRange)
-                        {
-                            PRS.Set_LineBreakPos(Pos);
-                            WordLen += LetterLen;
-                            Word = true;
-                        }
-                        else if (true !== NewRange)
+                        if (true !== NewRange)
                         {
                             // Отмечаем начало нового слова
                             PRS.Set_LineBreakPos(Pos);
@@ -2119,7 +2112,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                                 // Слово оказалось единственным элементом в промежутке, и, все равно,
                                 // не умещается целиком. Делаем следующее:
                                 //
-                                // 0) Для Формулы слово не разбиваем, перенос не делаем, пишем в одну строку (слово выйдет за границу как в Ворде)
+                                //
                                 // 1) Если у нас строка без вырезов, тогда ставим перенос строки на
                                 //    текущей позиции.
                                 // 2) Если у нас строка с вырезом, и данный вырез не последний, тогда
@@ -2127,13 +2120,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                                 // 3) Если у нас строка с вырезом и вырез последний, тогда ставим перенос
                                 //    строки в начале слова.
 
-                                if(this.Type == para_Math_Run)
-                                {
-                                    //
-                                    bMathWordLarge = true;
-
-                                }
-                                else if (false === Para.Internal_Check_Ranges(ParaLine, ParaRange))
+                                if (false === Para.Internal_Check_Ranges(ParaLine, ParaRange))
                                 {
                                     // Слово не убирается в отрезке. Переносим слово в следующий отрезок
                                     MoveToLBP = true;
@@ -2180,6 +2167,73 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
                     break;
                 }
+                case para_Math_Text:
+                case para_Math_Ampersand:
+                case para_Math_Placeholder:
+                {
+                    // Отмечаем, что началось слово
+                    StartWord = true;
+
+                    // При проверке, убирается ли слово, мы должны учитывать ширину предшествующих пробелов.
+                    var LetterLen = Item.Get_Width2() / TEXTWIDTH_DIVIDER;//var LetterLen = Item.Get_Width();
+
+
+                    if (true !== Word)
+                    {
+                        // Слово только началось. Делаем следующее:
+                        // 1) Если до него на строке ничего не было и данная строка не
+                        //    имеет разрывов, тогда не надо проверять убирается ли слово в строке.
+                        // 2) В противном случае, проверяем убирается ли слово в промежутке.
+
+                        // Если слово только началось, и до него на строке ничего не было, и в строке нет разрывов, тогда не надо проверять убирается ли оно на строке.
+                        if (true !== FirstItemOnLine || false === Para.Internal_Check_Ranges(ParaLine, ParaRange))
+                        {
+                            if (X + SpaceLen + LetterLen > XEnd)
+                            {
+                                NewRange = true;
+                                RangeEndPos = Pos;
+                            }
+                        }
+
+                        if(true !== NewRange)
+                        {
+                            PRS.Set_LineBreakPos(Pos);
+                            WordLen += LetterLen;
+                            Word = true;
+                        }
+
+                    }
+                    else
+                    {
+                        if(X + SpaceLen + WordLen + LetterLen > XEnd)
+                        {
+                            if(true === FirstItemOnLine)
+                            {
+                                // Слово оказалось единственным элементом в промежутке, и, все равно,
+                                // не умещается целиком. Делаем следующее:
+                                //
+                                // Для Формулы слово не разбиваем, перенос не делаем, пишем в одну строку (слово выйдет за границу как в Ворде)
+
+                                bMathWordLarge = true;
+
+                            }
+                            else
+                            {
+                                // Слово не убирается в отрезке. Переносим слово в следующий отрезок
+                                MoveToLBP = true;
+                                NewRange = true;
+                            }
+                        }
+
+                        if (true !== NewRange)
+                        {
+                            // Мы убираемся в пределах данной строки. Прибавляем ширину буквы к ширине слова
+                            WordLen += LetterLen;
+                        }
+                    }
+
+                    break;
+                }
                 case para_Space:
                 {
                     FirstItemOnLine = false;
@@ -2204,7 +2258,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                 }
                 case para_Math_BreakOperator:
                 {
-                    var BrkLen = Item.Width/TEXTWIDTH_DIVIDER;
+                    var BrkLen = Item.Get_Width2()/TEXTWIDTH_DIVIDER;
 
                     var bCompareOper = Item.Is_CompareOperator();
 
@@ -2233,23 +2287,36 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                     }
                     else
                     {
+
+                        PRS.bInsideOper = true;
+
                         var bOperBefore = this.ParaMath.Is_BrkBinBefore() == true;
                         var WorLenCompareOper = WordLen + X - XRange + (bOperBefore  ? SpaceLen : BrkLen);
 
+                        var bOverXEnd;
 
                         if(bCompareOper && PRS.bFirstCompareOper == true && WorLenCompareOper > PRS.WrapIndent && !(Word == false && FirstItemOnLine == true)) // (Word == true && FirstItemOnLine == true) - не первый элемент в строке
                             PRS.bFirstCompareOper = false;
 
                         if(bOperBefore)  // оператор "до"
                         {
-                            if(X + WordLen + SpaceLen > XEnd && FirstItemOnLine == false) // Слово не убирается в отрезке. Переносим слово в следующий отрезок
+                            bOverXEnd = X + WordLen + SpaceLen > XEnd;
+
+                            if(Word == false) // слово только началось
+                            {
+                                OperGapLeft = Item.GapLeft;
+                            }
+
+                            if(bOverXEnd && FirstItemOnLine == false) // Слово не убирается в отрезке. Переносим слово в следующий отрезок
                             {
                                 MoveToLBP = true;
                                 NewRange = true;
                             }
-                            else if(Word == true)
+                            else
+                            {
+                                if(Word == true)
                                 {
-                                if(X + WordLen + SpaceLen > XEnd) // FirstItemOnLine == true
+                                    if(bOverXEnd) // FirstItemOnLine == true
                                         bMathWordLarge = true;
 
                                     X += SpaceLen + WordLen;
@@ -2259,7 +2326,6 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                                     SpaceLen = 0;
 
                                     FirstItemOnLine = false;
-
                                 }
                                 else
                                 {
@@ -2268,12 +2334,19 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
                                     if(FirstItemOnLine == false)
                                         PRS.Set_LineBreakPos(Pos);
-                                SpaceLen += BrkLen;
+
+                                    // FirstItemOnLine == true && Word == false
+                                    // первое слово в строке
+                                    if(FirstItemOnLine == true)
+                                        SpaceLen += BrkLen - OperGapLeft;
+                                }
                             }
                         }
                         else   // оператор "после"
                         {
-                            if(X + WordLen + BrkLen > XEnd && FirstItemOnLine == false) // Слово не убирается в отрезке. Переносим слово в следующий отрезок
+                            bOverXEnd = X + WordLen + BrkLen - Item.GapRight > XEnd;
+
+                            if(bOverXEnd && FirstItemOnLine == false) // Слово не убирается в отрезке. Переносим слово в следующий отрезок
                             {
                                 MoveToLBP = true;
                                 NewRange = true;
@@ -2283,8 +2356,13 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                             }
                             else
                             {
-                                if(X + WordLen + BrkLen > XEnd) // FirstItemOnLine == true
+                                // осуществляем здесь, чтобы не изменить GapRight в случае, когда новое слово не убирается на break_Operator
+                                OperGapRight = Item.GapRight;
+
+                                if(bOverXEnd) // FirstItemOnLine == true
+                                {
                                     bMathWordLarge = true;
+                                }
 
                                 X += BrkLen + WordLen;
 
@@ -2651,6 +2729,8 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     PRS.SpaceLen        = SpaceLen;
     PRS.WordLen         = WordLen;
     PRS.bMathWordLarge  = bMathWordLarge;
+    PRS.OperGapRight    = OperGapRight;
+    PRS.OperGapLeft     = OperGapLeft;
 
     PRS.X               = X;
     PRS.XEnd            = XEnd;
@@ -2802,9 +2882,6 @@ ParaRun.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
         {
             case para_Sym:
             case para_Text:
-            case para_Math_Text:
-            case para_Math_Placeholder:
-            case para_Math_Ampersand:
             {
                 PRSC.Letters++;
 
@@ -2833,14 +2910,14 @@ ParaRun.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
 
                 break;
             }
+            case para_Math_Text:
+            case para_Math_Placeholder:
+            case para_Math_Ampersand:
             case para_Math_BreakOperator:
             {
-                if ( true === PRSC.Word )
-                {
-                    PRSC.Word        = false;
-                }
+                PRSC.Letters++;
 
-                PRSC.Range.W += Item.Width / TEXTWIDTH_DIVIDER;
+                PRSC.Range.W += Item.Get_Width2() / TEXTWIDTH_DIVIDER;
                 break;
             }
             case para_Space:
@@ -2955,10 +3032,6 @@ ParaRun.prototype.Recalculate_Range_Spaces = function(PRSA, _CurLine, _CurRange,
         {
             case para_Sym:
             case para_Text:
-            case para_Math_Text:
-            case para_Math_Placeholder:
-            case para_Math_BreakOperator:
-            case para_Math_Ampersand:
             {
                 var WidthVisible = 0;
 
@@ -2977,6 +3050,19 @@ ParaRun.prototype.Recalculate_Range_Spaces = function(PRSA, _CurLine, _CurRange,
 
                 break;
             }
+            case para_Math_Text:
+            case para_Math_Placeholder:
+            case para_Math_BreakOperator:
+            case para_Math_Ampersand:
+            {
+                var WidthVisible = Item.Get_Width2() / TEXTWIDTH_DIVIDER;
+                Item.WidthVisible = (WidthVisible * TEXTWIDTH_DIVIDER)| 0;//Item.Set_WidthVisible(WidthVisible);
+
+                PRSA.X    += WidthVisible;
+                PRSA.LastW = WidthVisible;
+
+                break;
+            }
             case para_Space:
             {
                 var WidthVisible = Item.Width / TEXTWIDTH_DIVIDER;//WidthVisible = Item.Get_Width();
@@ -8513,118 +8599,9 @@ ParaRun.prototype.Math_SetPosition = function(pos, PRSA, Line, Range, Page)
     for(var i = StartPos; i < EndPos; i++)
     {
         this.Content[i].setPosition(pos);
-        pos.x += this.Content[i].size.width;
+        pos.x += this.Content[i].Get_Width();
     }
 };
-ParaRun.prototype.Math_Draw = function(x, y, pGraphics)
-{
-    var X = x;
-    var Y = y + this.size.ascent;
-
-    var oWPrp = this.Get_CompiledPr(false);
-
-    var Font =
-    {
-        Bold       : oWPrp.Bold,
-        Italic     : oWPrp.Italic,
-        FontFamily : {Name : oWPrp.FontFamily.Name, Index : oWPrp.FontFamily.Index},
-        FontSize   : MathApplyArgSize(oWPrp.FontSize, this.Parent.Compiled_ArgSz.value)
-    };
-
-    if(this.IsMathematicalText()) // выставляем false, чтобы не применился наклон к спец символам
-    {
-        Font.Italic = false;
-        Font.Bold   = false;
-    }
-
-    pGraphics.SetFont(Font);
-    pGraphics.b_color1(0,0,0,255);
-
-    for(var i=0; i < this.Content.length;i++)
-        this.Content[i].draw(X, Y, pGraphics);
-};
-ParaRun.prototype.old_Math_Recalculate = function(oMeasure, RPI, WidthPoints)
-{
-    // ParaText (ParagraphContent.js)
-    // для настройки TextPr
-    // Measure
-
-    // FontClassification.js
-    // Get_FontClass
-
-    var RangeStartPos = 0;
-    var RangeEndPos = this.Content.length;
-
-
-    // обновляем позиции start и end для Range
-    //this.Lines[0].Add_Range(0, RangeStartPos, RangeEndPos);
-    this.protected_AddRange(0, 0);
-    this.protected_FillRange(0, 0, RangeStartPos, RangeEndPos);
-
-
-    if(RPI.NeedResize)
-    {
-        var oWPrp = this.Get_CompiledPr(false);
-        var Theme = this.Paragraph.Get_Theme();
-
-        var ArgSize     = this.Parent.Compiled_ArgSz.value,
-            bNormalText = this.IsNormalText();
-
-        // argSize
-        g_oTextMeasurer.SetTextPr(oWPrp,Theme);
-
-        var InfoMathText = new CMathInfoTextPr_2(oWPrp, ArgSize, bNormalText);
-
-        this.bEqArray = RPI.bEqArray;
-
-        this.size.SetZero();
-
-        var ascent = 0, descent = 0;
-
-        var Lng = this.Content.length;
-
-        for (var i = 0 ; i < Lng; i++)
-        {
-            this.Content[i].Resize(oMeasure, RPI, InfoMathText);
-
-            var oSize = this.Content[i].size;
-
-            this.size.width += oSize.width;
-
-            var oDescent = oSize.height - oSize.ascent;
-
-            ascent = ascent > oSize.ascent ? ascent : oSize.ascent;
-            descent = descent < oDescent ? oDescent : descent;
-
-            if(RPI.bEqArray)
-            {
-                if(this.Content[i].Type !== para_Math_Ampersand)
-                    WidthPoints.UpdatePoint(oSize.width);
-                else
-                    WidthPoints.AddNewAlignRange();
-            }
-        }
-
-        this.size.ascent = ascent;
-        this.size.height = ascent + descent;
-
-        // Запрашиваем текущие метрики шрифта, под TextAscent мы будем понимать ascent + linegap(которые записаны в шрифте)
-        this.TextHeight  = g_oTextMeasurer.GetHeight();
-        this.TextDescent = Math.abs( g_oTextMeasurer.GetDescender() );
-        this.TextAscent  = this.TextHeight - this.TextDescent;
-        this.TextAscent2 = g_oTextMeasurer.GetAscender();
-    }
-
-    // Пересчитаем метрику строки относительно размера данного текста
-    if (RPI.PRS.LineTextAscent < this.TextAscent)
-        RPI.PRS.LineTextAscent = this.TextAscent;
-
-    if (RPI.PRS.LineTextAscent2 < this.TextAscent2)
-        RPI.PRS.LineTextAscent2 = this.TextAscent2;
-
-    if (RPI.PRS.LineTextDescent < this.TextDescent)
-        RPI.PRS.LineTextDescent = this.TextDescent;
-};
 ParaRun.prototype.Math_GetWidth = function(_CurLine, _CurRange)
 {
     var CurLine  = _CurLine - this.StartLine;
@@ -8636,7 +8613,7 @@ ParaRun.prototype.Math_GetWidth = function(_CurLine, _CurRange)
     var W = 0;
     for(var i = StartPos; i < EndPos; i++)
     {
-        W += this.Content[i].size.width;
+        W += this.Content[i].Get_Width();
     }
 
     return W;
@@ -8739,7 +8716,9 @@ ParaRun.prototype.Recalculate_Range_OneLine = function(PRS, ParaPr, Depth)
         var size = this.Content[i].size,
             Type = this.Content[i].Type;
 
-        width += size.width;
+        var WidthItem = this.Content[i].Get_Width();
+
+        width += WidthItem;
 
         if(ascent < size.ascent)
             ascent = size.ascent;
@@ -8751,7 +8730,7 @@ ParaRun.prototype.Recalculate_Range_OneLine = function(PRS, ParaPr, Depth)
         if(this.bEqArray)
         {
             if(Type !== para_Math_Ampersand)
-                WidthPoints.UpdatePoint(size.width);
+                WidthPoints.UpdatePoint(WidthItem);
             else
                 WidthPoints.AddNewAlignRange();
         }
@@ -8762,26 +8741,34 @@ ParaRun.prototype.Recalculate_Range_OneLine = function(PRS, ParaPr, Depth)
     this.size.height = ascent + descent;
 
     this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
+};
+ParaRun.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);
 
-    // данная функция используется только для мат объектов, которые на строки не разбиваются
-    // поэтому далее можно убрать
-
-    // Запрашиваем текущие метрики шрифта, под TextAscent мы будем понимать ascent + linegap(которые записаны в шрифте)
-    /*this.TextHeight  = g_oTextMeasurer.GetHeight();
-    this.TextDescent = Math.abs( g_oTextMeasurer.GetDescender() );
-    this.TextAscent  = this.TextHeight - this.TextDescent;
-    this.TextAscent2 = g_oTextMeasurer.GetAscender();
+    var result = true;
 
-    // Пересчитаем метрику строки относительно размера данного текста
-    if (PRS.LineTextAscent < this.TextAscent)
-        PRS.LineTextAscent = this.TextAscent;
-
-    if (PRS.LineTextAscent2 < this.TextAscent2)
-        PRS.LineTextAscent2 = this.TextAscent2;
+    if(StartPos == EndPos)
+    {
+        result = false;
+    }
+    else
+    {
+        if(this.ParaMath.Is_BrkBinBefore() == true)
+        {
+            this.Content[StartPos].Update_GapLeft(0);
+        }
+        else
+        {
+            this.Content[EndPos-1].Update_GapRight(0);
+        }
+    }
 
-    if (PRS.LineTextDescent < this.TextDescent)
-        PRS.LineTextDescent = this.TextDescent;*/
+    return result;
 };
 ParaRun.prototype.Math_Apply_Style = function(Value)
 {
@@ -8851,48 +8838,10 @@ ParaRun.prototype.Math_Correct_Content = function()
             this.Remove_FromContent(i, 1, true);
     }
 };
-ParaRun.prototype.Get_ParaContentPosByXY_2 = function(SearchPos, Depth, _CurLine, _CurRange, StepEnd)
+ParaRun.prototype.OnlyOnePlaceholder = function()
 {
-    var Result = false;
+    return this.Content.length == 1 && this.Content[0].Type == para_Math_Placeholder;
 
-    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 CurPos = StartPos;
-    var Dx = 0;
-
-    for (; CurPos < EndPos; CurPos++ )
-    {
-        var Item = this.Content[CurPos];
-        var CurX = Item.pos.x;
-        Dx = Item.Get_WidthVisible();
-
-        // Проверяем, попали ли мы в данный элемент
-        var Diff = SearchPos.X - CurX;
-
-        if ((Math.abs( Diff ) < SearchPos.DiffX + 0.001 && (SearchPos.CenterMode || SearchPos.X > SearchPos.CurX)))
-        {
-            SearchPos.DiffX = Math.abs( Diff );
-            SearchPos.Pos.Update( CurPos, Depth );
-            Result = true;
-
-            if (Diff >= - 0.001 && Diff <= Dx + 0.001)
-            {
-                SearchPos.InTextPos.Update( CurPos, Depth );
-                SearchPos.InText = true;
-            }
-        }
-    }
-
-    if ((Math.abs(Diff -  Dx) < SearchPos.DiffX + 0.001 && (SearchPos.CenterMode || SearchPos.X > SearchPos.CurX)) )
-    {
-        SearchPos.Pos.Update( EndPos, Depth );
-        Result = true;
-
-    }
 };
 ParaRun.prototype.Set_MathPr = function(MPrp)
 {
@@ -8960,7 +8909,7 @@ ParaRun.prototype.ApplyPoints = function(PointsInfo)
                 this.Content[Pos].size.width = PointsInfo.GetAlign();
             }
 
-            this.size.width += this.Content[Pos].size.width;
+            this.size.width += this.Content[Pos].Get_Width();
         }
     }
 };

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,6 +1235,12 @@ CMathContent.prototype.Correct_Content = function(bInnerCorrection)
         this.Add_ToContent(0, NewMathRun);
     }
 
+    // не корректируем, если в контенте только один плейсхолдер
+
+    var bOnlyPlh = this.Content.length == 1 && this.Content[0].OnlyOnePlaceholder();
+
+    if(bOnlyPlh == false)
+    {
         for (var nPos = 0, nCount = this.Content.length; nPos < nCount; nPos++)
         {
             if(para_Math_Run === this.Content[nPos].Type)
@@ -1249,6 +1252,8 @@ CMathContent.prototype.Correct_Content = function(bInnerCorrection)
             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.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 );
+
+    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
+    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);
 
-    CMathContent.superclass.Recalculate_Range_Width.call(this, PRSC, _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

@@ -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;