Реализовала в Recalculate_Range пересчет формулы, в случае если картинка...

Реализовала в Recalculate_Range пересчет формулы, в случае если картинка привязана к предыдущему параграфу. Формула может располагаться слева, справа и снизу от картинки в данной ситуации. При этом формула рассчитывается как неинлайновая, с учетом всех выравниваний.

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

Word/Editor/Math.js

@@ -747,8 +747,13 @@ ParaMath.prototype.Get_AlignToLine = function(_CurLine, _CurRange, _Page, _X, _X
 
     var wrapIndent = MathSettings.Get_WrapIndent(WrapState);
 
-    _X      +=  MathSettings.Get_LeftMargin(WrapState);
-    _XLimit -=  MathSettings.Get_RightMargin(WrapState);
+    var XStart, XEnd;
+
+    XStart = this.ParaMathRPI.Wrap == WRAP_MATH_RIGHT ? this.ParaMathRPI.RangesX1 : _X;
+    XEnd   = this.ParaMathRPI.Wrap == WRAP_MATH_LEFT ? this.ParaMathRPI.RangesX0 : _XLimit;
+
+    XStart +=  MathSettings.Get_LeftMargin(WrapState);
+    XEnd   -=  MathSettings.Get_RightMargin(WrapState);
 
     var Jc = this.Get_Align();
 
@@ -777,12 +782,12 @@ ParaMath.prototype.Get_AlignToLine = function(_CurLine, _CurRange, _Page, _X, _X
     {
         switch(Jc)
         {
-            case align_Left:    X = _X; break;
-            case align_Right:   X = Math.max(_XLimit - StartLineWidth, _X); break;
-            case align_Center:  X = Math.max(_X + (_XLimit - _X - StartLineWidth)/2, _X); break;
+            case align_Left:    X = XStart; break;
+            case align_Right:   X = Math.max(XEnd - StartLineWidth, XStart); break;
+            case align_Center:  X = Math.max(XStart + (XEnd - XStart - StartLineWidth)/2, XStart); break;
             case align_Justify:
             {
-                X = Math.max(_X + (_XLimit - _X - W)/2, _X);
+                X = Math.max(XStart + (XEnd - XStart - W)/2, XStart);
                 break;
             }
         }
@@ -791,11 +796,11 @@ ParaMath.prototype.Get_AlignToLine = function(_CurLine, _CurRange, _Page, _X, _X
     {
         if(Jc == align_Justify)
         {
-            X = _XLimit - _X > W ? _X + (_XLimit - _X - W)/2 + wrapIndent : _X;
+            X = XEnd - XStart > W ? XStart + (XEnd - XStart - W)/2 + wrapIndent : XStart;
         }
         else
         {
-            X = _XLimit - _X > W ? _X + wrapIndent : _X;
+            X = XEnd - XStart > W ? XStart + wrapIndent : XStart;
         }
     }
 
@@ -1117,6 +1122,7 @@ ParaMath.prototype.Add_ToContent = function(Pos, Item, UpdatePosition)
 //-----------------------------------------------------------------------------------
 // Функции пересчета
 //-----------------------------------------------------------------------------------
+
 ParaMath.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 {
     // Paragraph_Recalculate.js
@@ -1148,25 +1154,105 @@ ParaMath.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     var PrevLineObject = PRS.RestartPageRecalcInfo.Object;
     var bFirstRange = this.Root.IsFirstRange(ParaLine, ParaRange);
 
-    var MathSettings = Get_WordDocumentDefaultMathSettings();
+    var bUpdateWrapMath = PRS.Ranges.length > 0 && this.ParaMathRPI.bInline == false;
 
+    if(PrevLineObject == null && true == bFirstRange && PRS.bFastRecalculate == false)
+    {
+        // первый пересчет
+        if(PRS.RecalcResult == recalcresult_NextLine)
+        {
             // информация о пересчете
             var RPI = new CRPI();
             RPI.MergeMathInfo(this.ParaMathRPI);
             var ArgSize = new CMathArgSize();
 
-    var bUpdateWrapMath = PRS.Ranges.length > 0 && this.ParaMathRPI.bInline == false;
-
-    // первый пересчет
-    if(PrevLineObject == null && true == bFirstRange && PRS.bFastRecalculate == false)
-    {
             this.PageInfo.Reset();
             this.PageInfo.SetStartPos(Page, ParaLine);
 
             this.Root.PreRecalc(null, this, ArgSize, RPI);
             this.ParaMathRPI.ResetInfoRanges();
+        }
 
-        if(bUpdateWrapMath == true)
+        if(bUpdateWrapMath == true && this.ParaMathRPI.bInternalRanges == false)
+        {
+            this.ParaMathRPI.bStartRanges = true;
+            this.private_InitWrapSettings(PRS);
+        }
+    }
+
+    if(bUpdateWrapMath == true && this.ParaMathRPI.bInternalRanges == false)
+    {
+        this.ParaMathRPI.bInternalRanges = true;
+
+        if(bFirstRange) // т.к. если просто выйдем, то прийдет пересчет для следующего Range 0-ой строки, а не для стартового Range 0-ой строки
+        {
+            this.ParaMathRPI.bStartRanges = true;
+            this.private_InitWrapSettings(PRS);
+        }
+        else
+        {
+            this.UpdateInfoForBreak(PRS, ParaLine);
+            PRS.RestartPageRecalcInfo.Object = null;
+            return;
+        }
+    }
+
+    this.Root.Set_Paragraph(Para);
+    this.Root.Set_ParaMath(this, null);
+
+    ////////////////////////////////////////////////////////////
+
+    this.PageInfo.UpdateCurrentPage(Page, ParaLine);
+
+    var MathSettings = Get_WordDocumentDefaultMathSettings();
+
+    var DispDef = MathSettings.Get_DispDef(),
+        bInline = this.Is_Inline(); // учитываем, если формула внутристроковая или же разбивается плавающим объектом (в этом случае тоже нужно рассчитывать как инлайновую)
+
+    //здесь обновляем WrapState, исходя из этого параметра будем считать WrapIndent
+    this.PageInfo.UpdateCurrentWrap(DispDef, bInline);
+
+    if(bInline == false)
+        this.private_UpdateXLimits(PRS, true);
+
+    PRS.XRange = PRS.X;
+
+    if(this.ParaMathRPI.Wrap !== WRAP_MATH_EMPTY && this.ParaMathRPI.bStartRanges == true)
+    {
+        this.private_RecalculateRangeWrap(PRS, ParaPr, Depth);
+    }
+    else
+    {
+        if(PrevLineObject == null ||  PrevLineObject == this)
+        {
+            PRS.RecalcResult = recalcresult_NextLine;
+            PRS.Reset_RestartPageRecalcInfo();
+        }
+
+        this.private_RecalculateRoot(PRS, ParaPr, Depth);
+
+        var WrapState = this.PageInfo.GetCurrentWrapState();
+        var bWordLarge =  PRS.bMathWordLarge == true && WrapState == ALIGN_EMPTY;
+        this.PageInfo.SetStateWordLarge(PRS.Line, bWordLarge);
+
+        if(PRS.bMathWordLarge == true && WrapState !== ALIGN_EMPTY)
+        {
+            this.UpdateInfoForBreak(PRS, ParaLine);
+            this.PageInfo.SetNextWrapState();
+        }
+    }
+
+    this.ParaMathRPI.ClearRecalculate();
+};
+ParaMath.prototype.private_InitWrapSettings = function(PRS)
+{
+    var ParaLine  = PRS.Line;
+    var ParaRange = PRS.Range;
+
+    var bFirstRange = this.Root.IsFirstRange(ParaLine, ParaRange);
+    var PrevLineObject = PRS.RestartPageRecalcInfo.Object;
+
+    if(PrevLineObject == null && true == bFirstRange && PRS.bFastRecalculate == false && this.ParaMathRPI.bInternalRanges == false)
     {
         this.ParaMathRPI.bStartRanges = true;
 
@@ -1190,88 +1276,94 @@ ParaMath.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
             this.ParaMathRPI.RangesX1 = PRS.Ranges[0].X1;
         }
     }
-    }
+};
+ParaMath.prototype.private_RecalculateRangeWrap = function(PRS, ParaPr, Depth)
+{
+    var bNextLine = (PRS.Range > 0 && this.ParaMathRPI.Wrap ==  WRAP_MATH_LEFT) || (PRS.Range == 0 && this.ParaMathRPI.Wrap == WRAP_MATH_RIGHT);
 
-    if(bUpdateWrapMath == true && this.ParaMathRPI.bInternalRanges == false)
+    if(PRS.Ranges.length == 0 && true == this.Root.IsStartRange())
     {
-        this.ParaMathRPI.bInternalRanges = true;
-        this.UpdateInfoForBreak(PRS, ParaLine);
-        return;
+        PRS.NewRange = true;
     }
+    else if(PRS.Ranges.length > 0 && bNextLine)
+    {
+        /*PRS.Update_CurPos(0, Depth);
+         PRS.Update_CurPos(0, Depth+1); // нулевой элемент всегда Run
 
-    // пока будем каждый раз обновлять информацию (т.к. когда не inline формула становиться inline может получиться так, что пересчет для первой строки не придет)
-    // когда пересчет всегда будет приходить для первой строки, эта часть будет выполняться только при первом пересчете первой строки
+         PRS.Set_LineBreakPos(0);*/
 
-    // если Wrap не равен Empty, значит формула точно не инлайновая
-    // то есть изменения X/XEnd повлияют только на рассчет формулы
-    if(this.ParaMathRPI.Wrap == WRAP_MATH_LEFT)
-    {
-        PRS.XEnd = this.ParaMathRPI.RangesX0;
+        this.Root.Math_Set_EmptyRange(PRS);
+
+        PRS.RecalcResult = recalcresult_NextLine;
+        PRS.RestartPageRecalcInfo.Object = this;
+        PRS.NewRange = true;
     }
-    else if(this.ParaMathRPI.Wrap == WRAP_MATH_RIGHT)
+    else
     {
-        PRS.X = this.ParaMathRPI.RangesX1;
+        if(PRS.Ranges.length > 0 && this.ParaMathRPI.Wrap == WRAP_MATH_RIGHT)
+        {
+            var _Range = PRS.Range;
+            PRS.Range = 0;
+            this.Root.Math_Set_EmptyRange(PRS);
+            PRS.Range = _Range;
         }
-    else if(this.ParaMathRPI.Wrap ==  WRAP_MATH_TOPBOTTOM)
+
+        var ParaLine  = PRS.Line;
+
+        if(this.ParaMathRPI.Wrap ==  WRAP_MATH_TOPBOTTOM)
         {
             // перенос на следующий строку, если есть разбивка формулы
 
             if(PRS.Ranges.length > 0)
             {
-            PRS.Update_CurPos(0, Depth);
-            PRS.Update_CurPos(0, Depth+1); // нулевой элемент всегда Run
-
-            PRS.Set_LineBreakPos(0);
+                this.Root.Math_Set_EmptyRange(PRS);
 
+                PRS.RecalcResult = recalcresult_NextLine;
                 PRS.NewRange = true;
                 return;
             }
         }
 
-    this.Root.Set_Paragraph(Para);
-    this.Root.Set_ParaMath(this, null);
-
-    ////////////////////////////////////////////////////////////
-
-    this.PageInfo.UpdateCurrentPage(Page, ParaLine);
-
-    var DispDef = MathSettings.Get_DispDef();
+        this.private_RecalculateRoot(PRS, ParaPr, Depth);
 
-    var bInline = RPI.bInline; // учитываем, если формула внутристроковая или же разбивается плавающим объектом (в этом случае тоже нужно рассчитывать как инлайновую)
 
-    //здесь обновляем WrapState, исходя из этого параметра будем считать WrapIndent
-    this.PageInfo.UpdateCurrentWrap(DispDef, bInline);
-
-    if(bInline == false)
+        if(PRS.bMathWordLarge == true)
+        {
+            if(this.ParaMathRPI.Wrap == WRAP_MATH_LEFT || this.ParaMathRPI.Wrap == WRAP_MATH_RIGHT)
+            {
+                this.ParaMathRPI.Wrap = WRAP_MATH_TOPBOTTOM;
+                this.UpdateInfoForBreak(PRS, ParaLine);
+            }
+            else if(this.ParaMathRPI.Wrap == WRAP_MATH_TOPBOTTOM)
             {
                 var WrapState = this.PageInfo.GetCurrentWrapState();
+                var bWordLarge =  PRS.bMathWordLarge == true && WrapState == ALIGN_EMPTY;
+                this.PageInfo.SetStateWordLarge(PRS.Line, bWordLarge);
 
-        PRS.X    += MathSettings.Get_LeftMargin(WrapState);
-        PRS.XEnd -= MathSettings.Get_RightMargin(WrapState);
-
-        var WrapIndent = MathSettings.Get_WrapIndent(WrapState);
-
-        PRS.WrapIndent = WrapIndent;
-
-        if(this.Root.IsStartLine() == false)
+                if(WrapState !== ALIGN_EMPTY)
                 {
-            PRS.X += WrapIndent;
-            PRS.bCompareWrapIndent = false;
+                    this.UpdateInfoForBreak(PRS, ParaLine);
+                    this.PageInfo.SetNextWrapState();
                 }
                 else
                 {
-            PRS.bCompareWrapIndent = true;
+                    this.ParaMathRPI.Wrap = WRAP_MATH_EMPTY;
+                    this.ParaMathRPI.bStartRanges = false;
+                    this.UpdateInfoForBreak(PRS, ParaLine);
+                }
             }
         }
 
-    PRS.XRange = PRS.X;
-
-    if(PrevLineObject == null ||  PrevLineObject == this)
-    {
-        PRS.RecalcResult = recalcresult_NextLine;
-        PRS.Reset_RestartPageRecalcInfo();
+        PRS.RestartPageRecalcInfo.Object = this;
     }
 
+};
+ParaMath.prototype.private_RecalculateRoot = function(PRS, ParaPr, Depth)
+{
+    var Para      = PRS.Paragraph;
+    var ParaLine  = PRS.Line;
+    var ParaRange = PRS.Range;
+
     // заглушка для пересчета Gaps элементов в текущей строке
     // если быстрый пересчет проверим нужно ли пересчитывать gaps у элементов текущей строки
     if(PRS.bFastRecalculate == true)
@@ -1295,35 +1387,43 @@ ParaMath.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
         }
 
         this.UpdateWidthLine(PRS, WidthLine);
-    }
 
-    var bWordLarge =  PRS.bMathWordLarge == true && WrapState == ALIGN_EMPTY;
-    this.PageInfo.SetStateWordLarge(PRS.Line, bWordLarge);
+    }
+};
+ParaMath.prototype.private_UpdateXLimits = function(PRS, bRecalculate)
+{
+    var MathSettings = Get_WordDocumentDefaultMathSettings();
 
-    if(PRS.bMathWordLarge == true)
+    if(this.ParaMathRPI.Wrap == WRAP_MATH_LEFT)
     {
-        if(WrapState !== ALIGN_EMPTY)
+        PRS.XEnd = this.ParaMathRPI.RangesX0;
+    }
+    else if(this.ParaMathRPI.Wrap == WRAP_MATH_RIGHT)
     {
-            this.UpdateInfoForBreak(PRS, ParaLine);
-            this.PageInfo.SetNextWrapState();
+        PRS.X = this.ParaMathRPI.RangesX1;
     }
-        else if(this.ParaMathRPI.bStartRanges == true)
+
+    var WrapState = this.PageInfo.GetCurrentWrapState();
+
+    PRS.X    += MathSettings.Get_LeftMargin(WrapState);
+    PRS.XEnd -= MathSettings.Get_RightMargin(WrapState);
+
+    if(bRecalculate == true)
     {
-            if(this.ParaMathRPI.Wrap == WRAP_MATH_LEFT || this.ParaMathRPI.Wrap == WRAP_MATH_RIGHT)
+        var WrapIndent = MathSettings.Get_WrapIndent(WrapState);
+
+        PRS.WrapIndent = WrapIndent;
+
+        if(this.Root.IsStartLine() == false)
         {
-                this.ParaMathRPI.Wrap = WRAP_MATH_TOPBOTTOM;
-                this.UpdateInfoForBreak(PRS, ParaLine);
+            PRS.X += WrapIndent;
+            PRS.bCompareWrapIndent = false;
         }
-            else if(this.ParaMathRPI.Wrap == WRAP_MATH_TOPBOTTOM)
+        else
         {
-                this.ParaMathRPI.Wrap = WRAP_MATH_EMPTY;
-                this.ParaMathRPI.bStartRanges = false;
-                this.UpdateInfoForBreak(PRS, ParaLine);
-            }
+            PRS.bCompareWrapIndent = true;
         }
     }
-
-    this.ParaMathRPI.ClearRecalculate();
 };
 ParaMath.prototype.UpdateInfoForBreakByPRS = function(PRS)
 {
@@ -1411,7 +1511,7 @@ ParaMath.prototype.UpdateWidthLine = function(PRS, Width)
         var W = Width - PRS.OperGapRight - PRS.OperGapLeft;
         var bChangeMaxW = this.PageInfo.UpdateCurrentWidth(PRS.Line, W);
 
-        if(bChangeMaxW == true && this.ParaMathRPI.bInline == false && align_Justify == this.Get_Align())
+        if(bChangeMaxW == true && this.Is_Inline() == false && align_Justify == this.Get_Align())
             this.UpdateInfoForBreakByPRS(PRS);
     }
 };
@@ -1570,7 +1670,8 @@ ParaMath.prototype.Get_Inline = function()
 };
 ParaMath.prototype.Is_Inline = function()
 {
-    return this.ParaMathRPI.bInline;
+    //return this.ParaMathRPI.bInline;
+    return this.ParaMathRPI.bInline == true || (this.ParaMathRPI.bInternalRanges == true && this.ParaMathRPI.bStartRanges == false);
 };
 ParaMath.prototype.Get_Align = function()
 {

Word/Editor/Run.js

@@ -2073,8 +2073,6 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     var ContentLen = this.Content.length;
     var XRange    = PRS.XRange;
 
-    var bAbsent_Internal_Ranges;
-
     if (false === StartWord && true === FirstItemOnLine && XEnd - X < 0.001 && RangesCount > 0)
     {
         NewRange = true;
@@ -8873,6 +8871,7 @@ function CRunCollaborativeRange(PosS, PosE, Color)
     this.PosE  = PosE;
     this.Color = Color;
 }
+
 ParaRun.prototype.Math_SetPosition = function(pos, PRSA, Line, Range, Page)
 {
     var CurLine  = Line - this.StartLine;
@@ -8961,7 +8960,6 @@ ParaRun.prototype.Math_Is_End = function(_CurLine, _CurRange)
 
     return EndPos == this.Content.length;
 };
-
 ParaRun.prototype.IsEmptyLine = function(_CurLine, _CurRange)
 {
     var CurLine  = _CurLine - this.StartLine;
@@ -9035,6 +9033,16 @@ ParaRun.prototype.Recalculate_Range_OneLine = function(PRS, ParaPr, Depth)
 
     this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
 };
+ParaRun.prototype.Math_Set_EmptyRange = function(PRS)
+{
+    var CurLine  = PRS.Line - this.StartLine;
+    var CurRange = ( 0 === CurLine ? PRS.Range - this.StartRange : PRS.Range );
+
+    var RangeStartPos = this.protected_AddRange(CurLine, CurRange);
+    var RangeEndPos   = RangeStartPos;
+
+    this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
+};
 // в этой функции проставляем состояние Gaps (крайние или нет) для всех операторов, к-ые участвуют в разбиении, чтобы не получилось случайно, что при изменении разбивки формулы на строки произошло, что у оператора не будет проставлен Gap
 ParaRun.prototype.UpdateOperators = function(_CurLine, _CurRange, bEmptyGapLeft, bEmptyGapRight)
 {

Word/Math/base.js

@@ -1156,10 +1156,8 @@ CMathBase.prototype.Load_RecalculateObject = function(RecalcObj)
         CMathBase.superclass.Load_RecalculateObject.call(this, RecalcObj);
 
 };
-CMathBase.prototype.Set_Paragraph           = CParagraphContentWithParagraphLikeContent.prototype.Set_Paragraph;
-CMathBase.prototype.Get_ElementByPos        = CParagraphContentWithParagraphLikeContent.prototype.Get_ElementByPos;
-CMathBase.prototype.Get_ParaPosByContentPos = CParagraphContentWithParagraphLikeContent.prototype.Get_ParaPosByContentPos;
 
+CMathBase.prototype.Math_Set_EmptyRange = CMathContent.prototype.Math_Set_EmptyRange;
 CMathBase.prototype.Set_ParaMath        = CMathContent.prototype.Set_ParaMath;
 CMathBase.prototype.Recalculate_Reset   = CMathContent.prototype.Recalculate_Reset;
 CMathBase.prototype.Fill_LogicalContent = function(nCount)

Word/Math/mathContent.js

@@ -4069,6 +4069,18 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
 
 };
+CMathContent.prototype.Math_Set_EmptyRange = function(PRS)
+{
+    var CurLine  = PRS.Line - this.StartLine;
+    var CurRange = ( 0 === CurLine ? PRS.Range - this.StartRange : PRS.Range );
+
+    var RangeStartPos = this.protected_AddRange(CurLine, CurRange);
+    var RangeEndPos   = RangeStartPos;
+
+    this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
+
+    this.Content[RangeStartPos].Math_Set_EmptyRange(PRS);
+};
 CMathContent.prototype.Recalculate_Reset = function(StartRange, StartLine, PRS)
 {
     var bNotUpdate = PRS !== null && PRS!== undefined && PRS.bFastRecalculate == true;