Yajbir Singh
674 lines
18 KiB
JavaScript
674 lines
18 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2024
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
// Функция копирует объект или массив. (Обычное равенство в javascript приравнивает указатели)
|
|
function Common_CopyObj(Obj)
|
|
{
|
|
if( !Obj || !('object' == typeof(Obj) || 'array' == typeof(Obj)) )
|
|
{
|
|
return Obj;
|
|
}
|
|
|
|
var c = 'function' === typeof Obj.pop ? [] : {};
|
|
var p, v;
|
|
for(p in Obj)
|
|
{
|
|
if(Obj.hasOwnProperty(p))
|
|
{
|
|
v = Obj[p];
|
|
if(v && 'object' === typeof v )
|
|
{
|
|
c[p] = Common_CopyObj(v);
|
|
}
|
|
else
|
|
{
|
|
c[p] = v;
|
|
}
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* Класс для обркботки конвертации текста в таблицу
|
|
* @constructor
|
|
*/
|
|
function CTextToTableEngine()
|
|
{
|
|
this.SeparatorType = Asc.c_oAscTextToTableSeparator.Paragraph;
|
|
this.Separator = 0;
|
|
this.MaxCols = 0;
|
|
|
|
this.Mode = 0; // Режим работы
|
|
// 0 - вычисляем размер
|
|
// 1 - проверяем типы разделителей
|
|
// 2 - набиваем элементы
|
|
|
|
this.Cols = 0;
|
|
this.Rows = 0;
|
|
this.CurCols = 0;
|
|
|
|
this.Tab = true;
|
|
this.Semicolon = true;
|
|
this.ParaTab = false;
|
|
this.ParaSemicolon = false;
|
|
|
|
this.ParaPositions = [];
|
|
this.Rows = [];
|
|
this.ItemsBuffer = [];
|
|
this.CurCol = 0;
|
|
this.CurRow = 0;
|
|
this.CC = null;
|
|
}
|
|
CTextToTableEngine.prototype.Reset = function()
|
|
{
|
|
this.Cols = 0;
|
|
this.Rows = 0;
|
|
this.CurCols = 0;
|
|
|
|
this.Tab = true;
|
|
this.Semicolon = true;
|
|
this.ParaTab = false;
|
|
this.ParaSemicolon = false;
|
|
};
|
|
CTextToTableEngine.prototype.GetSeparatorType = function()
|
|
{
|
|
return this.Type;
|
|
};
|
|
CTextToTableEngine.prototype.GetSeparator = function()
|
|
{
|
|
return this.Separator;
|
|
};
|
|
CTextToTableEngine.prototype.AddItem = function()
|
|
{
|
|
if (this.IsParagraphSeparator())
|
|
return;
|
|
|
|
if (0 === this.CurCols)
|
|
this.Rows++;
|
|
|
|
if (this.MaxCols)
|
|
{
|
|
if (this.CurCols < this.MaxCols)
|
|
{
|
|
this.CurCols++;
|
|
}
|
|
else
|
|
{
|
|
if (this.Cols < this.CurCols)
|
|
this.Cols = this.CurCols;
|
|
|
|
this.Rows++;
|
|
this.CurCols = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.CurCols++;
|
|
}
|
|
};
|
|
CTextToTableEngine.prototype.OnStartParagraph = function()
|
|
{
|
|
if (this.IsCalculateTableSizeMode())
|
|
{
|
|
this.AddItem();
|
|
}
|
|
else if (this.IsCheckSeparatorMode())
|
|
{
|
|
this.ParaTab = false;
|
|
this.ParaSemicolon = false;
|
|
}
|
|
else if (this.IsConvertMode())
|
|
{
|
|
this.ParaPositions = [];
|
|
}
|
|
};
|
|
CTextToTableEngine.prototype.OnEndParagraph = function(oParagraph)
|
|
{
|
|
if (this.IsCalculateTableSizeMode())
|
|
{
|
|
if (this.IsParagraphSeparator())
|
|
{
|
|
if (this.MaxCols)
|
|
{
|
|
if (0 === this.CurCols)
|
|
this.Rows++;
|
|
|
|
if (this.CurCols < this.MaxCols)
|
|
{
|
|
this.CurCols++;
|
|
}
|
|
else
|
|
{
|
|
if (this.Cols < this.CurCols)
|
|
this.Cols = this.CurCols;
|
|
|
|
this.Rows++;
|
|
this.CurCols = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.Rows++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.CurCols)
|
|
{
|
|
if (this.Cols < this.CurCols)
|
|
this.Cols = this.CurCols;
|
|
|
|
this.CurCols = 0;
|
|
}
|
|
}
|
|
}
|
|
else if (this.IsCheckSeparatorMode())
|
|
{
|
|
this.Tab = this.Tab && this.ParaTab;
|
|
this.Semicolon = this.Semicolon && this.ParaSemicolon;
|
|
}
|
|
else if (this.IsConvertMode())
|
|
{
|
|
// Если у нас данный параграф не делится на несколько частей и находится в контроле и он единственный
|
|
// элемент в этом контроле, то его надо оставить в том контроле
|
|
// За исключением самого первого контрола, который лежит в верху, его мы используем для обертки
|
|
var oElement = oParagraph;
|
|
var oParent = oParagraph.GetParent();
|
|
if (this.ItemsBuffer.length <= 0 && oParent
|
|
&& oParent.IsBlockLevelSdtContent()
|
|
&& 1 === oParent.GetElementsCount()
|
|
&& (this.IsParagraphSeparator() || !this.ParaPositions.length)
|
|
&& oParent.Parent !== this.CC)
|
|
{
|
|
oElement = oParent.Parent;
|
|
}
|
|
|
|
if (this.IsParagraphSeparator())
|
|
{
|
|
this.CheckBuffer();
|
|
this.Rows[this.CurRow][this.CurCol].push(oElement.Copy());
|
|
|
|
this.CurCol++;
|
|
|
|
if (this.CurCol >= this.MaxCols)
|
|
{
|
|
this.CurCol = 0;
|
|
this.CurRow++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var arrParagraphs = [];
|
|
for (var nIndex = this.ParaPositions.length - 1; nIndex >= 0; --nIndex)
|
|
{
|
|
var oTempParagraph = oParagraph.SplitNoDuplicate(this.ParaPositions[nIndex]);
|
|
|
|
var oRunElements = new CParagraphRunElements(oTempParagraph.GetStartPos(), 1, null);
|
|
oRunElements.SetSaveContentPositions(true);
|
|
oRunElements.SetSkipMath(false);
|
|
oTempParagraph.GetNextRunElements(oRunElements);
|
|
|
|
if (1 === oRunElements.Elements.length
|
|
&& this.CheckSeparator(oRunElements.Elements[0]))
|
|
{
|
|
var oTempRunPos = oRunElements.GetContentPositions()[0];
|
|
var nInRunPos = oTempRunPos.Get(oTempRunPos.GetDepth());
|
|
oTempRunPos.DecreaseDepth(1);
|
|
var oTempRun = oTempParagraph.GetClassByPos(oTempRunPos);
|
|
if (oTempRun)
|
|
oTempRun.RemoveFromContent(nInRunPos, 1);
|
|
}
|
|
|
|
arrParagraphs.push(oTempParagraph);
|
|
}
|
|
|
|
this.CurCol = 0;
|
|
|
|
this.CheckBuffer();
|
|
this.Rows[this.CurRow][this.CurCol].push(oElement.Copy());
|
|
this.CurCol++;
|
|
|
|
if (this.CurCol >= this.MaxCols)
|
|
{
|
|
this.CurCol = 0;
|
|
if (arrParagraphs.length > 0)
|
|
this.CurRow++;
|
|
}
|
|
|
|
for (var nIndex = arrParagraphs.length - 1; nIndex >= 0; --nIndex)
|
|
{
|
|
if (0 === this.CurCol)
|
|
this.Rows[this.CurRow] = [];
|
|
|
|
if (!this.Rows[this.CurRow][this.CurCol])
|
|
this.Rows[this.CurRow][this.CurCol] = [];
|
|
|
|
this.Rows[this.CurRow][this.CurCol].push(arrParagraphs[nIndex]);
|
|
this.CurCol++;
|
|
|
|
if (this.CurCol >= this.MaxCols)
|
|
{
|
|
this.CurCol = 0;
|
|
if (nIndex > 0)
|
|
this.CurRow++;
|
|
}
|
|
}
|
|
|
|
this.CurRow++;
|
|
}
|
|
}
|
|
};
|
|
CTextToTableEngine.prototype.OnTable = function(oTable)
|
|
{
|
|
if (this.IsConvertMode())
|
|
{
|
|
this.ItemsBuffer.push(oTable);
|
|
}
|
|
};
|
|
CTextToTableEngine.prototype.FinalizeConvert = function()
|
|
{
|
|
if (this.IsConvertMode() && this.ItemsBuffer.length > 0)
|
|
{
|
|
// Случай, когда последним элементом идет таблица
|
|
this.CheckBuffer();
|
|
}
|
|
};
|
|
CTextToTableEngine.prototype.CheckBuffer = function()
|
|
{
|
|
if (0 === this.CurCol)
|
|
this.Rows[this.CurRow] = [];
|
|
|
|
this.Rows[this.CurRow][this.CurCol] = [];
|
|
if (this.ItemsBuffer.length > 0)
|
|
{
|
|
for (var nIndex = 0, nCount = this.ItemsBuffer.length; nIndex < nCount; ++nIndex)
|
|
{
|
|
this.Rows[this.CurRow][this.CurCol].push(this.ItemsBuffer[nIndex].Copy());
|
|
}
|
|
|
|
this.ItemsBuffer = [];
|
|
}
|
|
};
|
|
CTextToTableEngine.prototype.IsParagraphSeparator = function()
|
|
{
|
|
return this.SeparatorType === Asc.c_oAscTextToTableSeparator.Paragraph;
|
|
};
|
|
CTextToTableEngine.prototype.IsSymbolSeparator = function(nCharCode)
|
|
{
|
|
return (this.SeparatorType === Asc.c_oAscTextToTableSeparator.Symbol && this.Separator === nCharCode);
|
|
};
|
|
CTextToTableEngine.prototype.IsTabSeparator = function()
|
|
{
|
|
return this.SeparatorType === Asc.c_oAscTextToTableSeparator.Tab;
|
|
};
|
|
CTextToTableEngine.prototype.CheckSeparator = function(oRunItem)
|
|
{
|
|
var nItemType = oRunItem.Type;
|
|
|
|
return ((para_Tab === nItemType && this.IsTabSeparator())
|
|
|| (para_Text === nItemType && this.IsSymbolSeparator(oRunItem.Value))
|
|
|| (para_Space === nItemType && this.IsSymbolSeparator(oRunItem.Value))
|
|
|| (para_Math_Text === nItemType && this.IsSymbolSeparator(oRunItem.value)));
|
|
};
|
|
CTextToTableEngine.prototype.SetCalculateTableSizeMode = function(nSeparatorType, nSeparator, nMaxCols)
|
|
{
|
|
this.Mode = 0;
|
|
|
|
this.SeparatorType = undefined !== nSeparatorType ? nSeparatorType : Asc.c_oAscTextToTableSeparator.Paragraph;
|
|
this.Separator = undefined !== nSeparator ? nSeparator : 0;
|
|
this.MaxCols = undefined !== nMaxCols ? nMaxCols : 0;
|
|
};
|
|
CTextToTableEngine.prototype.SetCheckSeparatorMode = function()
|
|
{
|
|
this.Mode = 1;
|
|
};
|
|
CTextToTableEngine.prototype.SetConvertMode = function(nSeparatorType, nSeparator, nMaxCols)
|
|
{
|
|
this.Mode = 2;
|
|
|
|
this.SeparatorType = undefined !== nSeparatorType ? nSeparatorType : Asc.c_oAscTextToTableSeparator.Paragraph;
|
|
this.Separator = undefined !== nSeparator ? nSeparator : 0;
|
|
this.MaxCols = undefined !== nMaxCols ? nMaxCols : 1;
|
|
};
|
|
CTextToTableEngine.prototype.IsCalculateTableSizeMode = function()
|
|
{
|
|
return (0 === this.Mode);
|
|
};
|
|
CTextToTableEngine.prototype.IsCheckSeparatorMode = function()
|
|
{
|
|
return (1 === this.Mode);
|
|
};
|
|
CTextToTableEngine.prototype.IsConvertMode = function()
|
|
{
|
|
return (2 === this.Mode);
|
|
};
|
|
CTextToTableEngine.prototype.AddTab = function()
|
|
{
|
|
this.ParaTab = true;
|
|
};
|
|
CTextToTableEngine.prototype.AddSemicolon = function()
|
|
{
|
|
this.ParaSemicolon = true;
|
|
};
|
|
CTextToTableEngine.prototype.HaveTab = function()
|
|
{
|
|
return this.Tab;
|
|
};
|
|
CTextToTableEngine.prototype.HaveSemicolon = function()
|
|
{
|
|
return this.Semicolon;
|
|
};
|
|
CTextToTableEngine.prototype.AddParaPosition = function(oParaContentPos)
|
|
{
|
|
this.ParaPositions.push(oParaContentPos);
|
|
};
|
|
CTextToTableEngine.prototype.GetRows = function()
|
|
{
|
|
return this.Rows;
|
|
};
|
|
CTextToTableEngine.prototype.SetContentControl = function(oCC)
|
|
{
|
|
this.CC = oCC;
|
|
};
|
|
CTextToTableEngine.prototype.GetContentControl = function()
|
|
{
|
|
return this.CC;
|
|
};
|
|
|
|
//--------------------------------------------------------export--------------------------------------------------------
|
|
window['AscCommonWord'] = window['AscCommonWord'] || {};
|
|
window['AscCommonWord'].CTextToTableEngine = CTextToTableEngine;
|
|
|
|
(function(window)
|
|
{
|
|
let Direction = {
|
|
FORWARD : 1,
|
|
NONE : 0,
|
|
BACKWARD : -1
|
|
};
|
|
|
|
function private_CheckDrawingDocumentPosition(oDocPos)
|
|
{
|
|
var oShape = null;
|
|
if (oDocPos[0].Class instanceof AscCommonWord.CDocumentContent && (oShape = oDocPos[0].Class.Is_DrawingShape(true)) && oShape.parent instanceof AscCommonWord.ParaDrawing)
|
|
{
|
|
var oDrawingDocPos = oShape.parent.GetDocumentPositionFromObject();
|
|
if (!oDrawingDocPos || !oDrawingDocPos.length)
|
|
return oDocPos;
|
|
|
|
return oDrawingDocPos.concat(oDocPos);
|
|
}
|
|
|
|
return oDocPos;
|
|
}
|
|
function private_GetTopDocumentPosition(oDocPos)
|
|
{
|
|
var oClass = oDocPos[0].Class;
|
|
if (oClass instanceof AscCommonWord.CDocument)
|
|
return 0;
|
|
else if (!(oClass instanceof AscCommonWord.CDocumentContent))
|
|
return 0xFF;
|
|
if (oClass.IsFootnote() && oClass.GetParent() instanceof CFootnotesController)
|
|
return 1;
|
|
else if (oClass.IsFootnote() && oClass.GetParent() instanceof CEndnotesController)
|
|
return 2;
|
|
else if (oClass.IsHdrFtr())
|
|
return 3;
|
|
|
|
return 0xFF;
|
|
}
|
|
function private_CompareDocumentPositions(oDocPos1, oDocPos2)
|
|
{
|
|
for (var nIndex = 0, nCount = oDocPos1.length; nIndex < nCount; ++nIndex)
|
|
{
|
|
if (oDocPos2.length <= nIndex)
|
|
return 1;
|
|
|
|
if (oDocPos1[nIndex].Position < oDocPos2[nIndex].Position)
|
|
return -1;
|
|
else if (oDocPos1[nIndex].Position > oDocPos2[nIndex].Position)
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
function private_GetNoteReferencePosition(oDocPos)
|
|
{
|
|
var oClass = oDocPos[0].Class;
|
|
if (!(oClass instanceof CFootEndnote))
|
|
return oDocPos;
|
|
|
|
var oRef = oClass.GetRef();
|
|
if (!oRef)
|
|
return oDocPos;
|
|
|
|
var oRun = oRef.GetRun();
|
|
if (!oRun)
|
|
return oDocPos;
|
|
|
|
var oRunDocPos = oRun.GetDocumentPositionFromObject();
|
|
var nInRunPos = oRun.GetElementPosition(oRef);
|
|
if (!oRunDocPos || -1 === nInRunPos)
|
|
return oDocPos;
|
|
|
|
oRunDocPos.push({Class : oRun, Position : nInRunPos});
|
|
return oRunDocPos;
|
|
}
|
|
function private_GetSectionHeaderIndex(oHeader)
|
|
{
|
|
var oSection = oHeader.GetSectionPr();
|
|
if (!oSection)
|
|
return -1;
|
|
|
|
if (oHeader === oSection.Get_Header_First())
|
|
return 0;
|
|
else if (oHeader === oSection.Get_Footer_First())
|
|
return 1;
|
|
else if (oHeader === oSection.Get_Header_Default())
|
|
return 2;
|
|
else if (oHeader === oSection.Get_Footer_Default())
|
|
return 3;
|
|
else if (oHeader === oSection.Get_Header_Even())
|
|
return 4;
|
|
else if (oHeader === oSection.Get_Footer_Even())
|
|
return 5;
|
|
|
|
return -1;
|
|
}
|
|
function private_CompareHdrFtrPosition(oDocPos1, oDocPos2)
|
|
{
|
|
var oHeader1 = oDocPos1[0].Class.IsHdrFtr(true);
|
|
var oHeader2 = oDocPos2[0].Class.IsHdrFtr(true);
|
|
|
|
if (!oHeader1 || !oHeader2 || oHeader1 === oHeader2)
|
|
return 0;
|
|
|
|
var nSectionIndex1 = oHeader1.GetSectionIndex();
|
|
var nSectionIndex2 = oHeader2.GetSectionIndex();
|
|
|
|
if (nSectionIndex1 < nSectionIndex2)
|
|
return -1;
|
|
else if (nSectionIndex1 > nSectionIndex2)
|
|
return 1;
|
|
|
|
return (private_GetSectionHeaderIndex(oHeader1) < private_GetSectionHeaderIndex(oHeader2) ? -1 : 1);
|
|
}
|
|
function CompareDocumentPositions(oDocPos1, oDocPos2)
|
|
{
|
|
if (!oDocPos1 || !oDocPos2 || !oDocPos1.length || !oDocPos2.length)
|
|
return 0;
|
|
|
|
oDocPos1 = private_CheckDrawingDocumentPosition(oDocPos1);
|
|
oDocPos2 = private_CheckDrawingDocumentPosition(oDocPos2);
|
|
|
|
var nTopPos1 = private_GetTopDocumentPosition(oDocPos1);
|
|
var nTopPos2 = private_GetTopDocumentPosition(oDocPos2);
|
|
|
|
if (nTopPos1 !== nTopPos2)
|
|
return (nTopPos1 < nTopPos2 ? -1 : 1);
|
|
|
|
if (oDocPos1[0].Class !== oDocPos2[0].Class)
|
|
{
|
|
if (1 === nTopPos1 || 2 === nTopPos2)
|
|
{
|
|
oDocPos1 = private_GetNoteReferencePosition(oDocPos1);
|
|
oDocPos2 = private_GetNoteReferencePosition(oDocPos2);
|
|
}
|
|
else if (3 === nTopPos1)
|
|
{
|
|
return private_CompareHdrFtrPosition(oDocPos1, oDocPos2);
|
|
}
|
|
}
|
|
|
|
if (oDocPos1[0].Class !== oDocPos2[0].Class)
|
|
return 0;
|
|
|
|
return private_CompareDocumentPositions(oDocPos1, oDocPos2);
|
|
}
|
|
function isInSameTopDocContent(docPos1, docPos2)
|
|
{
|
|
if (!docPos1 || !docPos2 || !docPos1.length || !docPos2.length)
|
|
return false;
|
|
|
|
return (docPos1[0].Class === docPos2[0].Class);
|
|
}
|
|
function AlignFontSize(nFontSize, nCoef)
|
|
{
|
|
if (1 === nCoef)
|
|
return nFontSize;
|
|
|
|
return (((nFontSize * nCoef * 2 + 0.5) | 0) / 2);
|
|
}
|
|
function TextToRunElements(sText, fHandle)
|
|
{
|
|
let arrElements = fHandle ? null : [];
|
|
for (var oIterator = sText.getUnicodeIterator(); oIterator.check(); oIterator.next())
|
|
{
|
|
let oElement = codePointToRunElement(oIterator.value(), false);
|
|
|
|
if (fHandle)
|
|
fHandle(oElement);
|
|
else
|
|
arrElements.push(oElement);
|
|
}
|
|
return fHandle ? null : arrElements;
|
|
}
|
|
function TextToMathRunElements(sText, fHandle)
|
|
{
|
|
let arrElements = fHandle ? null : [];
|
|
for (var oIterator = sText.getUnicodeIterator(); oIterator.check(); oIterator.next())
|
|
{
|
|
let oElement = codePointToRunElement(oIterator.value(), true);
|
|
|
|
if (fHandle)
|
|
fHandle(oElement);
|
|
else
|
|
arrElements.push(oElement);
|
|
}
|
|
return fHandle ? null : arrElements;
|
|
}
|
|
function codePointToRunElement(codePoint, isMath)
|
|
{
|
|
let element = null;
|
|
if (isMath)
|
|
{
|
|
if (0x0026 === codePoint)
|
|
{
|
|
element = new AscWord.CMathAmp();
|
|
}
|
|
else
|
|
{
|
|
element = new AscWord.CMathText(false);
|
|
element.add(codePoint);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (9 === codePoint)
|
|
element = new AscWord.CRunTab();
|
|
else if (10 === codePoint)
|
|
element = new AscWord.CRunBreak(AscWord.break_Line);
|
|
else if (13 === codePoint)
|
|
element = null;
|
|
else if (AscCommon.IsSpace(codePoint))
|
|
element = new AscWord.CRunSpace(codePoint);
|
|
else
|
|
element = new AscWord.CRunText(codePoint);
|
|
}
|
|
return element;
|
|
}
|
|
function sortByDocumentPosition(elements)
|
|
{
|
|
let docPos = {};
|
|
elements.forEach(function(element)
|
|
{
|
|
docPos[element.GetId()] = element.GetDocumentPositionFromObject();
|
|
});
|
|
|
|
elements.sort(function(l, r)
|
|
{
|
|
return CompareDocumentPositions(docPos[l.GetId()], docPos[r.GetId()]);
|
|
});
|
|
}
|
|
function checkAsYouTypeEnterText(run, inRunPos, codePoint)
|
|
{
|
|
let localHistory = AscCommon.History;
|
|
if (!localHistory.checkAsYouTypeEnterText)
|
|
return false;
|
|
|
|
if (!localHistory.isEmpty())
|
|
return localHistory.checkAsYouTypeEnterText(run, inRunPos, codePoint);
|
|
else if (AscCommon.CollaborativeEditing.Is_Fast() && !AscCommon.CollaborativeEditing.Is_SingleUser())
|
|
return AscCommon.CollaborativeEditing.getCoHistory().checkAsYouTypeEnterText(run, inRunPos, codePoint);
|
|
|
|
return false;
|
|
}
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
window['AscWord'] = window['AscWord'] || {};
|
|
window['AscWord'].CompareDocumentPositions = CompareDocumentPositions;
|
|
window['AscWord'].AlignFontSize = AlignFontSize;
|
|
window['AscWord'].TextToRunElements = TextToRunElements;
|
|
window['AscWord'].TextToMathRunElements = TextToMathRunElements;
|
|
window['AscWord'].codePointToRunElement = codePointToRunElement;
|
|
window['AscWord'].sortByDocumentPosition = sortByDocumentPosition;
|
|
window['AscWord'].checkAsYouTypeEnterText = checkAsYouTypeEnterText;
|
|
window['AscWord'].isInSameTopDocContent = isInSameTopDocContent;
|
|
|
|
window['AscWord'].EPSILON = 0.001;
|
|
window['AscWord'].MAX_MM_VALUE = 558.7;
|
|
window['AscWord'].Direction = Direction;
|
|
|
|
})(window);
|