1. Поправила баги на открытие, происходили Recalculate_MinMaxContentWidth при...

1. Поправила баги на открытие, происходили Recalculate_MinMaxContentWidth при открытии большихь документов. Выставляем Set_paragraph и Set_ParaMath для всех элементов формулы.
2. Поправила баг связанный с принудительны переносом. Приоритет у принудительного переноса выше, чем приоритет вложенности операторов. (Принудитльный перенос делаем всегда, если контент разбивается на строки.)
3. Поправила баг : если оператор должен находится в начале строки и он не умещается в текущей строке, то в любом случае делаем перенос, независимо от того находятся после него еще элементы или нет.
4. Поправила баг : если оператор находится в начале строки и он идет первым, то не деалем отметку, что о InsideOper для внут контентов мат объектов
5. Поправила функцию Get_WrapToLine, неправильно вычислялись CurRange и CurLine


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

Word/Editor/Math.js

@@ -600,6 +600,8 @@ ParaMath.prototype.Copy = function(Selected)
 ParaMath.prototype.Set_Paragraph = function(Paragraph)
 {
     this.Paragraph = Paragraph;
+    this.Root.Set_Paragraph(Paragraph);
+    this.Root.Set_ParaMath(this, null);
 };
 
 ParaMath.prototype.Get_Text = function(Text)

Word/Editor/Paragraph_Recalculate.js

@@ -2198,8 +2198,9 @@ function CParagraphRecalculateStateWrap(Para)
     // у "крайних" в строке операторов/мат объектов сооответствующий Gap равен нулю
     this.OperGapRight        = 0;
     this.OperGapLeft         = 0;
-    this.bNoOneBreakOperator = true; // прежде чем обновлять позицию в контент Run, учтем были ли до этого операторы (проверки на Word == false не достаточно, т.к. формула мб инлайновая и тогда не нужно обновлять позицию)
+    this.bNoOneBreakOperator = true;  // прежде чем обновлять позицию в контент Run, учтем были ли до этого операторы (проверки на Word == false не достаточно, т.к. формула мб инлайновая и тогда не нужно обновлять позицию)
     this.bInsideOper         = false; // учитываем есть ли разбивка внутри мат объекта, чтобы случайно не вставить в конец пред оператора (при Brk_Before == false)
+    this.bOnlyForcedBreak    = false; // учитывается, если возможна разбивка только по операторам выше уровням => в этом случае можно сделать принуительный разрыв во внутреннем контенте
     this.bFastRecalculate    = false;
     this.bBoxOperator        = false;
 }
@@ -2236,6 +2237,7 @@ CParagraphRecalculateStateWrap.prototype =
         this.MathFirstItem       = true;
         this.bFirstCompareOper   = true;
         this.bInsideOper         = false;
+        this.bOnlyForcedBreak    = false;
         this.bNoOneBreakOperator = true;
         this.bFastRecalculate    = false;
         this.bBoxOperator        = false;
@@ -2271,9 +2273,10 @@ CParagraphRecalculateStateWrap.prototype =
         this.WrapIndent         = 0;
         this.bFirstCompareOper  = true;
         this.bInsideOper        = false;
+        this.bOnlyForcedBreak   = false;
         this.bNoOneBreakOperator = true;
         this.bFastRecalculate   = false;
-        this.bBoxOperator        = false;
+        this.bBoxOperator       = false;
     },
 
     Reset_RestartPageRecalcInfo : function()

Word/Editor/Run.js

@@ -2280,7 +2280,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
                     var bCompareOper = Item.Is_CompareOperator();
 
-                    var bOperInEndContent = bEndRunToContent == true && Pos == ContentLen - 1 && Word == true, // необходимо для того, чтобы у контентов мат объектов (к-ые могут разбиваться на строки) не было отметки Set_LineBreakPos, иначе скобка (или GapLeft), перед которой стоит break_Operator, перенесется на следующую строку (без текста !)
+                    var bOperInEndContent = bOperBefore === false && bEndRunToContent === true && Pos == ContentLen - 1 && Word == true, // необходимо для того, чтобы у контентов мат объектов (к-ые могут разбиваться на строки) не было отметки Set_LineBreakPos, иначе скобка (или GapLeft), перед которой стоит break_Operator, перенесется на следующую строку (без текста !)
                         bLowPriority      = bCompareOper == false  && bFirstCompareOper == false;
 
                     bNoOneBreakOperator = false;
@@ -2319,7 +2319,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                         if(PRS.bPriorityOper == true && bCompareOper == true && bFirstCompareOper == true && bCompareWrapIndent == true && !(Word == false && bFirstItem == true)) // (Word == true && FirstItemOnLine == true) - не первый элемент в строке
                             bFirstCompareOper = false;
 
-                        if(bOperBefore)  // оператор "до"
+                        if(bOperBefore)  // оператор "до" => оператор находится в начале строки
                         {
                             bOverXEnd = X + WordLen + SpaceLen > XEnd;
 
@@ -2331,7 +2331,8 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                             }
                             else
                             {
-                                bInsideOper = true;
+                                if(bFirstItem == false)
+                                    bInsideOper = true;
 
                                 if(Word == true)
                                 {
@@ -2363,7 +2364,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                                 }
                             }
                         }
-                        else   // оператор "после"
+                        else   // оператор "после" => оператор находится в конце строки
                         {
                             bOverXEnd = X + WordLen + BrkLen - Item.GapRight > XEnd;
 
@@ -2760,7 +2761,7 @@ ParaRun.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
             }
 
             // запоминаем конец Run
-            PRS.PosEndRun = PRS.CurPos.Copy();
+            PRS.PosEndRun.Set(PRS.CurPos);
             PRS.PosEndRun.Update2(this.Content.length, Depth);
 
         }
@@ -9118,8 +9119,6 @@ ParaRun.prototype.Recalculate_Range_OneLine = function(PRS, ParaPr, Depth)
     var RangeStartPos = this.protected_AddRange(CurLine, CurRange);
     var RangeEndPos = Lng;
 
-    this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
-
     this.Math_RecalculateContent(PRS);
 
     this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);

Word/Math/borderBox.js

@@ -414,7 +414,7 @@ CMathBoxPr.prototype.Set_FromObject = function(Obj)
     else
         this.noBreak = false;
 
-    if(true === Obj.opEmu || 1 === Obj.opEmu || Obj.opEmu == null) // null - val attribute is absent
+    if(true === Obj.opEmu || 1 === Obj.opEmu || Obj.opEmu === null) // null - val attribute is absent
         this.opEmu = true;
     else
         this.opEmu = false;

Word/Math/mathContent.js

@@ -419,7 +419,7 @@ CMathGapsInfo.prototype =
             {
                 leftCoeff = this.getGapsMComp(this.Current, -1);
 
-                if(this.Left != null)
+                if(this.Left !== null)
                 {
                     if(this.Left.Type == para_Math_Composition)
                     {
@@ -450,7 +450,7 @@ CMathGapsInfo.prototype =
             var LGapSign = 0.1513*this.CurrentFontSize;
             this.Current.GapLeft = (leftCoeff*LGapSign*100 | 0)/100; // если ни один случай не выполнился, выставляем "нулевые" gaps (default): необходимо, если что-то удалили и объект стал первый или последним в контенте
 
-            if(this.Left != null)
+            if(this.Left !== null)
             {
                 var RGapSign = 0.1513*this.LeftFontSize;
                 this.Left.GapRight = (rightCoeff*RGapSign*100 | 0)/100;
@@ -835,7 +835,6 @@ CMathContent.prototype.GetWidthLine = function(_CurLine, _CurRange)
 
     return W;
 };
-
 CMathContent.prototype.ShiftPage = function(Dx)
 {
     this.Bounds.ShiftPage(Dx);
@@ -3827,19 +3826,25 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 {
     this.bOneLine = PRS.bMath_OneLine;
 
+    // для неинлайн формул :
+    // у операторов, находяхщихся на этом уровне (в Run) приоритет выше, чем у внутренних операторов (внутри мат объектов)
+    // возможен только принудительный разрыв
+    var bOnlyForcedBreak = PRS.bOnlyForcedBreak;
+    var bNoOneBreakOperator = PRS.bNoOneBreakOperator;
+
     var CurLine  = PRS.Line - this.StartLine;
     var CurRange = ( 0 === CurLine ? PRS.Range - this.StartRange : PRS.Range );
 
     var ContentLen = this.Content.length;
 
     var RangeStartPos = this.protected_AddRange(CurLine, CurRange);
-    var RangeEndPos   = 0;
+    var RangeEndPos   = ContentLen - 1;
 
-    if(this.bOneLine)
+    /*if(this.bOneLine)
     {
         RangeStartPos = 0;
         RangeEndPos   = ContentLen - 1;
-    }
+    }*/
 
     if(this.RecalcInfo.bEqArray)
         this.InfoPoints.SetDefault();
@@ -3874,9 +3879,7 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     var bInternalOper    = false,
         bCurInsideOper   = false;
 
-    // для неинлайн формул :
-    // у операторов, находяхщихся на этом уровне (в Run) приоритет выше, чем у внутренних операторов (внутри мат объектов)
-    var bNoBreakMObj = false;
+    var BoxLen, BoxGapLeft, BoxGapRight;
 
     for(var Pos = RangeStartPos; Pos < ContentLen; Pos++)
     {
@@ -3891,7 +3894,7 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
         PRS.Update_CurPos( Pos, Depth );
 
-        if(this.bOneLine) // контент занимает всегда(!) одну строку
+        if(this.bOneLine == true) // контент занимает всегда(!) одну строку
         {
             Item.Recalculate_Range_OneLine(PRS, ParaPr, Depth + 1);
 
@@ -3909,12 +3912,46 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
             this.size.ascent = ascent;
             this.size.height = ascent + descent;
         }
-        else // контент может занимать несколько строк
+        else if(bOnlyForcedBreak == true)
         {
-            var bNoOneBreakOperator = PRS.bNoOneBreakOperator;
+            if(Type == para_Math_Run)
+            {
+                Item.Recalculate_Range_OneLine(PRS, ParaPr, Depth + 1);
+                PRS.WordLen += Item.size.width;
+            }
+            else
+            {
+                BoxLen      = Item.size.width;
+                BoxGapRight = Item.GapRight;
+
+                var WWordLen = Brk_Before == true ?  PRS.X + PRS.WordLen + PRS.SpaceLen : PRS.X + PRS.SpaceLen + PRS.WordLen + BoxLen - BoxGapRight;
 
+                if(WWordLen > PRS.XEnd)
+                {
+                    PRS.NewRange = true;
+                    PRS.MoveToLBP = true;
+                }
+                else if(Item.kind == MATH_BOX)
+                {
+                    if(true == Item.IsBreak())
+                    {
+                        this.private_ForceBreakBox(PRS, Item.size.width);
+                    }
+                    else
+                    {
+                        PRS.WordLen += BoxLen;
+                    }
+                }
+                else
+                {
+                    Item.Recalculate_Range(PRS, ParaPr, Depth + 1);
+                }
+            }
+        }
+        else // контент может занимать несколько строк
+        {
             // запомним позицию конца Run перед тем как зайдем во внутр мат объект (конечная позиция Run может измениться при пересчете внутр мат объекта)
-            var _Depth = PRS.PosEndRun.Depth;
+            var _Depth      = PRS.PosEndRun.Depth;
             var PrevLastPos = PRS.PosEndRun.Get(_Depth-1),
                 LastPos     = PRS.PosEndRun.Get(_Depth);
 
@@ -3922,7 +3959,7 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
             PRS.bInsideOper = false;
 
-            PRS.bMath_OneLine = Type == para_Math_Composition && bNoBreakMObj == true;
+            //PRS.bMath_OneLine = Type == para_Math_Composition && bOnlyForcedBreak == true;
 
             Item.Recalculate_Range(PRS, ParaPr, Depth + 1);
 
@@ -3933,13 +3970,15 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                 // перед мат объектом идет box break_operator и он не является первым элементом в строке
                 if(Item.kind == MATH_BOX)
                 {
-                    var BoxLen      = Item.size.width,
-                        BoxGapLeft  = Item.GapLeft,
-                        BoxGapRight = Item.GapRight;
+                    BoxLen      = Item.size.width;
+                    BoxGapLeft  = Item.GapLeft;
+                    BoxGapRight = Item.GapRight;
 
                     if(true == Item.IsBreak())
                     {
-                        if(true == PRS.MathFirstItem)
+                        this.private_ForceBreakBox(PRS, BoxLen);
+
+                        /*if(true == PRS.MathFirstItem)
                         {
                             PRS.WordLen += BoxLen;
                         }
@@ -3954,7 +3993,7 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 
                             PRS.MoveToLBP = true;
                             PRS.NewRange = true;
-                        }
+                        }*/
                     }
                     else if(true == Item.IsOperatorEmulator())
                     {
@@ -4076,10 +4115,11 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
                 {
                     PRS.MathFirstItem = false;
                 }
+                var CheckWrapIndent = PRS.bFirstLine == true ? PRS.X - PRS.XRange > PRS.WrapIndent : true;
 
-                if(PRS.bPriorityOper == true && PRS.bInsideOper == true && PRS.X - PRS.XRange > PRS.WrapIndent)
+                if(PRS.bPriorityOper == true && PRS.bInsideOper == true && CheckWrapIndent == true)
                 {
-                    bNoBreakMObj = true;
+                    PRS.bOnlyForcedBreak = true;
                 }
             }
 
@@ -4095,6 +4135,7 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
     }
 
     PRS.bInsideOper = PRS.bInsideOper || bCurInsideOper;
+    PRS.bOnlyForcedBreak = bOnlyForcedBreak;
 
     if ( Pos >= ContentLen )
     {
@@ -4106,7 +4147,10 @@ CMathContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
 };
 CMathContent.prototype.Get_WrapToLine = function(_CurLine, _CurRange, WrapIndent)
 {
-    var Pos = this.protected_GetPrevRangeEndPos(_CurLine, _CurRange);
+    var CurLine  = _CurLine - this.StartLine;
+    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );
+
+    var Pos = this.protected_GetPrevRangeEndPos(CurLine, CurRange);
     var ContentLen = this.Content.length;
     var Wrap = 0;
 
@@ -4143,6 +4187,29 @@ CMathContent.prototype.Get_WrapToLine = function(_CurLine, _CurRange, WrapIndent
 
     return Wrap;
 };
+CMathContent.prototype.private_ForceBreakBox = function(PRS, BoxLen)
+{
+    var _Depth      = PRS.PosEndRun.Depth;
+    var PrevLastPos = PRS.PosEndRun.Get(_Depth-1),
+        LastPos     = PRS.PosEndRun.Get(_Depth);
+
+    if(true == PRS.MathFirstItem)
+    {
+        PRS.WordLen += BoxLen;
+    }
+    else
+    {
+        //PRS.bInsideOper = true;
+        PRS.X += PRS.SpaceLen + PRS.WordLen;
+        PRS.Update_CurPos(PrevLastPos, _Depth-1);
+        PRS.Set_LineBreakPos(LastPos);
+
+        this.ParaMath.UpdateWidthLine(PRS, PRS.X - PRS.XRange);
+
+        PRS.MoveToLBP = true;
+        PRS.NewRange = true;
+    }
+};
 CMathContent.prototype.Math_Set_EmptyRange = function(PRS)
 {
     var CurLine  = PRS.Line - this.StartLine;

Word/Math/matrix.js

@@ -442,7 +442,7 @@ function CMathMatrix(props)
 
     this.setDefaultSpace();
 
-    if(props !== null && typeof(props) !== "undefined")
+    if(props !== null && props !== undefined)
         this.init(props);
 
 	g_oTableId.Add( this, this.Id );
@@ -532,7 +532,7 @@ CMathMatrix.prototype.setColumnGapRule = function(rule, gap, minGap)
 {
     this.spaceColumn.rule = rule;
     this.spaceColumn.gap = gap;
-    if(minGap !== null && typeof(minGap) !== "undefined")
+    if(minGap !== null && minGap !== undefined)
         this.spaceColumn.minGap = minGap;
 };
 CMathMatrix.prototype.getContentElement = function(nRowIndex, nColIndex)
@@ -678,7 +678,7 @@ function CEqArray(props)
     this.MaxDimWidths = [];
     //
 
-    if(props !== null && typeof(props) !== "undefined")
+    if(props !== null && props !== undefined)
         this.init(props);
 
 	g_oTableId.Add( this, this.Id );

Word/Math/nary.js

@@ -138,7 +138,7 @@ function CNary(props)
     this.UpperIterator = null;
     this.Arg           = null;
 
-    if(props !== null && typeof(props) !== "undefined")
+    if(props !== null && props !== undefined)
         this.init(props);
 
 	g_oTableId.Add( this, this.Id );
@@ -257,7 +257,7 @@ CNary.prototype.ApplyProperties = function(RPI)
             this.Sign.add(oSign.chrCode);
         }
 
-        if(limLoc == null || typeof(limLoc) == "undefined")
+        if(limLoc === null || limLoc === undefined)
         {
             var bIntegral = oSign.chrCode > 0x222A && oSign.chrCode < 0x2231;
 

Word/Math/operators.js

@@ -2782,8 +2782,8 @@ COperator.prototype.getProps = function(props, defaultProps)
     this.defaultType = defaultProps.type;
 
     var bDelimiter = this.type == OPER_DELIMITER || this.type == OPER_SEPARATOR,
-        bNotType   = typeof(props.type) == "undefined" ||  props.type == null,
-        bUnicodeChr    = props.chr !== null && props.chr+0 == props.chr;
+        bNotType   = props.type === undefined ||  props.type === null,
+        bUnicodeChr    = props.chr !== null && props.chr+0 === props.chr;
 
 
     if(bDelimiter && props.chr == -1) // empty operator
@@ -2795,8 +2795,8 @@ COperator.prototype.getProps = function(props, defaultProps)
         type = defaultProps.type;
     }
 
-    var bLoc        = props.loc !== null && typeof(props.loc)!== "undefined";
-    var bDefaultLoc = defaultProps.loc !== null && typeof(defaultProps.loc)!== "undefined";
+    var bLoc        = props.loc !== null && props.loc !== undefined;
+    var bDefaultLoc = defaultProps.loc !== null && defaultProps.loc !==  undefined;
 
 
     if(!bLoc && bDefaultLoc)
@@ -3010,7 +3010,7 @@ COperator.prototype.getChr = function()
     var chr = null; //если operator не определен, то this.code = null
 
     if(this.code !== null)
-        chr = this.typeOper == this.defaultType ? null : String.fromCharCode(this.code);
+        chr = this.typeOper === this.defaultType ? null : String.fromCharCode(this.code);
 	if (this.operator == OPERATOR_EMPTY)
 		chr = "";
 
@@ -3211,7 +3211,7 @@ function CDelimiter(props)
     this.Pr = new CMathDelimiterPr();
     this.TextInContent = true;
 
-    if(props !== null && typeof(props) !== "undefined")
+    if(props !== null && props !== undefined)
         this.init(props);
 
 	g_oTableId.Add( this, this.Id );
@@ -3941,7 +3941,7 @@ function CGroupCharacter(props)
 
     this.Pr = new CMathGroupChrPr();
 
-    if(props !== null && typeof(props)!== "undefined")
+    if(props !== null && props !== undefined)
         this.init(props);
 
     /// вызов этой функции обязательно в конце

Word/Math/radical.js

@@ -406,7 +406,7 @@ function CRadical(props)
     this.gapDegree = 0;
     this.gapWidth = 0; //  в случае со степенью, если ширина степени не нулевая, добавляется расстояние для ширины
 
-    if(props !== null && typeof(props)!== "undefined")
+    if(props !== null && props !== undefined)
         this.init(props);
 
 	g_oTableId.Add( this, this.Id );