Сделано ускорение пересчета формул, если она не разбирается на 2 страницы....

Сделано ускорение пересчета формул, если она не разбирается на 2 страницы. Сделано, чтобы когда в формуле идет пустая строка не рисовался формульный трек вокруг нее.

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

Word/Drawing/DrawingDocument.js

@@ -4657,28 +4657,57 @@ function CDrawingDocument()
             if (arrBounds.length <= 0)
                 return;
 
-            var oPrevBounds = arrBounds[0];
-            var arrGroups = [{Count : 1, Page : oPrevBounds.Page}];
-            for (var nIndex = 1, nCount = arrBounds.length, nGroupIndex = 0; nIndex < nCount; nIndex++)
+            var nStartIndex = 0;
+            while (nStartIndex < arrBounds.length)
             {
-                var oBounds = arrBounds[nIndex];
+                if (arrBounds[nStartIndex].W < 0.001)
+                    nStartIndex++;
+                else
+                    break;
+            }
+
+            if (nStartIndex >= arrBounds.length)
+                return;
+
+            var nPrevIndex = nStartIndex;
+            var oPrevBounds = arrBounds[nStartIndex];
+            var arrGroups = [{Count : 1, Page : oPrevBounds.Page, StartIndex : nStartIndex}];
+            for (var nIndex = nStartIndex + 1, nCount = arrBounds.length, nGroupIndex = 0; nIndex < nCount; nIndex++)
+            {
+                var nCurIndex = nIndex;
+                while (nCurIndex < nCount)
+                {
+                    if (arrBounds[nCurIndex].W < 0.001)
+                        nCurIndex++;
+                    else
+                        break;
+                }
+
+                if (nCurIndex >= nCount)
+                    break;
+
+                nIndex = nCurIndex;
 
-                if (oPrevBounds.Page !== oBounds.Page || oBounds.X + oBounds.W < oPrevBounds.X || oPrevBounds.X + oPrevBounds.W < oBounds.X)
+                var oBounds = arrBounds[nIndex];
+                if (oPrevBounds.Page !== oBounds.Page || oBounds.X + oBounds.W < oPrevBounds.X || oPrevBounds.X + oPrevBounds.W < oBounds.X || nIndex != nPrevIndex + 1)
                 {
                     nGroupIndex++;
-                    arrGroups[nGroupIndex] = {Count : 1, Page : oBounds.Page};
+                    arrGroups[nGroupIndex] = {Count : 1, Page : oBounds.Page, StartIndex : nIndex};
                 }
                 else
                     arrGroups[nGroupIndex].Count++;
 
+                nPrevIndex = nIndex;
+
                 oPrevBounds = oBounds;
             }
 
             // Объединим группы в полигоны
-            for (var nGroupIndex = 0, nCount = arrGroups.length, nStartRect = 0; nGroupIndex < nCount; nGroupIndex++)
+            for (var nGroupIndex = 0, nCount = arrGroups.length; nGroupIndex < nCount; nGroupIndex++)
             {
                 var oPolygon = [];
                 var nRectsCount = arrGroups[nGroupIndex].Count;
+                var nStartRect  = arrGroups[nGroupIndex].StartIndex;
                 for (var nRectIndex = 0; nRectIndex < nRectsCount; nRectIndex++)
                 {
                     var nBIndex = nRectIndex + nStartRect;
@@ -4709,27 +4738,11 @@ function CDrawingDocument()
                 }
 
                 arrPolygons.push({Polygon : oPolygon, Page : arrGroups[nGroupIndex].Page, HalfCount : nRectsCount * 2});
-                nStartRect += nRectsCount;
             }
 
             this.MathRect.Bounds = arrPolygons;
-
-//            this.MathRect.Bounds = [];
-//            for (var nIndex = 0, nCount = arrBounds.length; nIndex < nCount; nIndex++)
-//            {
-//                var oBounds = arrBounds[nIndex];
-//
-//                this.MathRect.Bounds[nIndex] =
-//                {
-//                    X    : oBounds.X - PixelError,
-//                    Y    : oBounds.Y - PixelError,
-//                    R    : oBounds.X + oBounds.W + PixelError,
-//                    B    : oBounds.Y + oBounds.H + PixelError,
-//                    Page : oBounds.Page
-//                };
-//            }
         }
-    }
+    };
 
     this.Update_FieldTrack = function(IsActive, aRects)
     {

Word/Editor/Document.js

@@ -1209,23 +1209,21 @@ CDocument.prototype =
 
             // TODO: Тут надо вставить заглушку, что если у нас в долгом пересчете находится страница <= PageIndex + 1,
             //       по отношению к данной, тогда не надо делать быстрый пересчет.
-            if (SimpleChanges.length >= 1)
+            var SimplePara = History.Is_ParagraphSimpleChanges();
+            if (null !== SimplePara)
             {
-                var Run  = SimpleChanges[0].Class;
-                var Para = Run.Paragraph;
-
-                var FastPages = Para.Recalculate_FastWholeParagraph();
+                var FastPages = SimplePara.Recalculate_FastWholeParagraph();
                 var FastPagesCount = FastPages.length;
 
                 if (FastPagesCount > 0)
                 {
                     // Если изменения произошли на последней странице параграфа, и за данным параграфом следовал
                     // пустой параграф с новой секцией, тогда его тоже надо пересчитать.
-                    var NextElement = Para.Get_DocumentNext();
+                    var NextElement = SimplePara.Get_DocumentNext();
                     var LastFastPage = FastPages[FastPagesCount - 1];
                     if (null !== NextElement && true === this.Pages[LastFastPage].Check_EndSectionPara(NextElement))
                     {
-                        var LastVisibleBounds = Para.Get_LastRangeVisibleBounds();
+                        var LastVisibleBounds = SimplePara.Get_LastRangeVisibleBounds();
 
                         var ___X = LastVisibleBounds.X + LastVisibleBounds.W;
                         var ___Y = LastVisibleBounds.Y;

Word/Editor/History.js

@@ -627,6 +627,79 @@ CHistory.prototype =
         return [];
     },
 
+    Is_ParagraphSimpleChanges : function()
+    {
+        var Count, Items;
+        if (this.Index - this.RecIndex !== 1 && this.RecIndex >= -1)
+        {
+            Items = [];
+            Count = 0;
+            for (var PointIndex = this.RecIndex + 1; PointIndex <= this.Index; PointIndex++)
+            {
+                Items = Items.concat(this.Points[PointIndex].Items);
+                Count += this.Points[PointIndex].Items.length;
+            }
+        }
+        else if (this.Index >= 0)
+        {
+            // Считываем изменения, начиная с последней точки, и смотрим что надо пересчитать.
+            var Point = this.Points[this.Index];
+
+            Count = Point.Items.length;
+            Items = Point.Items;
+        }
+        else
+            return null;
+
+
+        if (Items.length > 0)
+        {
+            // Смотрим, чтобы параграф, в котором происходили все изменения был один и тот же. Если есть изменение,
+            // которое не возвращает параграф, значит возвращаем null.
+
+            var Para = null;
+            var Class = Items[0].Class;
+            if (Class instanceof Paragraph)
+                Para = Class;
+            else if (Class.Get_Paragraph)
+                Para = Class.Get_Paragraph();
+            else
+                return null;
+
+            for (var Index = 1; Index < Count; Index++)
+            {
+                Class = Items[Index].Class;
+
+                if (Class instanceof Paragraph)
+                {
+                    if (Para != Class)
+                        return null;
+                }
+                else if (Class.Get_Paragraph)
+                {
+                    if (Para != Class.Get_Paragraph())
+                        return null;
+                }
+                else
+                    return null;
+            }
+
+            // Все изменения сделаны в одном параграфе, нам осталось проверить, что каждое из этих изменений
+            // влияет только на данный параграф.
+            for (var Index = 0; Index < Count; Index++)
+            {
+                var Item = Items[Index];
+                var Class = Item.Class;
+                if (!Class.Is_SimpleChanges || !Class.Is_ParagraphSimpleChanges(Item))
+                    return null;
+            }
+
+            return Para;
+        }
+
+        return null;
+    },
+
     Set_Additional_ExtendDocumentToPos : function()
     {
         if ( this.Index >= 0 )

Word/Editor/Run.js

@@ -1256,9 +1256,6 @@ ParaRun.prototype.Recalculate_CurPos = function(X, Y, CurrentRun, _CurRange, _Cu
 // Проверяем, произошло ли простейшее изменение (набор или удаление текста)
 ParaRun.prototype.Is_SimpleChanges = function(Changes)
 {
-    if ( para_Math_Run === this.Type )
-        return false;
-
     var ParaPos = null;
 
     var Count = Changes.length;
@@ -1299,6 +1296,36 @@ ParaRun.prototype.Is_SimpleChanges = function(Changes)
     return true;
 };
 
+/*
+    Проверяем произошло ли простое изменение параграфа, сейчас главное, чтобы это было не добавление или удаление картинки.
+    На вход приходит либо массив изменений, либо одно изменение (можно не в массиве).
+ */
+ParaRun.prototype.Is_ParagraphSimpleChanges = function(_Changes)
+{
+    var Changes = _Changes;
+    if (!_Changes.length)
+        Changes = [_Changes];
+
+    var ChangesCount = Changes.length;
+    for (var ChangesIndex = 0; ChangesIndex < ChangesCount; ChangesIndex++)
+    {
+        var Data = Changes[ChangesIndex].Data;
+        var ChangeType = Data.Type;
+
+        if (historyitem_ParaRun_AddItem === ChangeType || historyitem_ParaRun_RemoveItem === ChangeType)
+        {
+            for (var ItemIndex = 0, ItemsCount = Data.Items.length; ItemIndex < ItemsCount; ItemIndex++)
+            {
+                var Item = Data.Items[ItemIndex];
+                if (para_Drawing === Item.Type)
+                    return false;
+            }
+        }
+    }
+
+    return true;
+};
+
 // Возвращаем строку и отрезок, в котором произошли простейшие изменения
 ParaRun.prototype.Get_SimpleChanges_ParaPos = function(Changes)
 {