1401 lines
40 KiB
JavaScript
1401 lines
40 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";
|
||
|
||
(function(window)
|
||
{
|
||
let elementToCheck = {};
|
||
function checkElementInRevision(element)
|
||
{
|
||
if (!element)
|
||
return;
|
||
|
||
let logicDocument = element.GetLogicDocument();
|
||
if (!element.GetLogicDocument())
|
||
{
|
||
elementToCheck[element.GetId()] = element;
|
||
return;
|
||
}
|
||
|
||
if (!logicDocument || !logicDocument.IsDocumentEditor())
|
||
return;
|
||
|
||
logicDocument.GetTrackRevisionsManager().CheckElement(element);
|
||
}
|
||
function haveElementToCheck()
|
||
{
|
||
for (let id in elementToCheck)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
function flushElementToCheck()
|
||
{
|
||
for (let id in elementToCheck)
|
||
{
|
||
let element = elementToCheck[id];
|
||
let logicDocument = element.GetLogicDocument();
|
||
if (!logicDocument || !logicDocument.IsDocumentEditor())
|
||
continue;
|
||
|
||
logicDocument.GetTrackRevisionsManager().CheckElement(elementToCheck[id]);
|
||
}
|
||
|
||
elementToCheck = {};
|
||
}
|
||
|
||
// ВАЖНО: CheckArray - специальный массив-дублер для мапа CheckMap, для более быстрого выполнения функции
|
||
// ContinueTrackRevisions. Заметим, что на функции CompleteTrackChangesForElements мы не выкидываем
|
||
// элемент из CheckArray, но выкидываем из CheckMap. Это не страшно, т.к. при последующей проверке по
|
||
// массиву CheckArray элемент в CheckMap просто не найдется, а из CheckArray мы его выкинем, и, тем самым,
|
||
// CheckArray и CheckMap синхронизуются.
|
||
|
||
/**
|
||
* Класс для отслеживания изменений в режиме рецензирования
|
||
* @param {AscWord.CDocument} oLogicDocument
|
||
* @constructor
|
||
*/
|
||
function CTrackRevisionsManager(oLogicDocument)
|
||
{
|
||
this.LogicDocument = oLogicDocument;
|
||
|
||
this.CheckMap = {}; // Элементы, которые нужно проверить
|
||
this.CheckArray = []; // Дублирующий массив элементов, которые мы проверяем в ContinueTrackRevisions
|
||
|
||
this.Changes = {}; // Объект с ключом - Id параграфа, в котором лежит массив изменений
|
||
this.ChangesOutline = []; // Упорядоченный массив с объектами, в которых есть изменения в рецензировании
|
||
this.CurChange = null; // Текущее изменение
|
||
this.CurElement = null; // Элемент с текущим изменением
|
||
|
||
this.SelectedChanges = []; // Список изменений, попавших в выделение
|
||
this.PrevSelectedChanges = [];
|
||
this.PrevShowChanges = true;
|
||
|
||
this.MoveId = 1;
|
||
this.MoveMarks = {};
|
||
this.ProcessMove = null;
|
||
|
||
this.SkipPreDeleteMoveMarks = false;
|
||
}
|
||
|
||
/**
|
||
* Отправляем элемент на проверку на наличие рецензирования
|
||
* @param oElement {AscWord.Paragraph | AscWord.CTable}
|
||
*/
|
||
CTrackRevisionsManager.prototype.CheckElement = function(oElement)
|
||
{
|
||
if (!(oElement instanceof AscWord.Paragraph) && !(oElement instanceof AscWord.CTable))
|
||
return;
|
||
|
||
let Id = oElement.GetId();
|
||
if (!this.CheckMap[Id])
|
||
{
|
||
this.CheckMap[Id] = oElement;
|
||
this.CheckArray.push(oElement);
|
||
}
|
||
};
|
||
/**
|
||
* Добавляем изменение в рецензировании по Id элемента
|
||
* @param sId {string}
|
||
* @param oChange {CRevisionsChange}
|
||
*/
|
||
CTrackRevisionsManager.prototype.AddChange = function(sId, oChange)
|
||
{
|
||
if (this.private_CheckChangeObject(sId))
|
||
this.Changes[sId].push(oChange);
|
||
};
|
||
/**
|
||
* Получаем массив изменений заданного элемента
|
||
* @param sElementId
|
||
* @returns {CRevisionsChange[]}
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetElementChanges = function(sElementId)
|
||
{
|
||
if (this.Changes[sElementId])
|
||
return this.Changes[sElementId];
|
||
|
||
return [];
|
||
};
|
||
CTrackRevisionsManager.prototype.ContinueTrackRevisions = function(isComplete)
|
||
{
|
||
if (this.IsAllChecked())
|
||
return;
|
||
|
||
flushElementToCheck();
|
||
|
||
var nStartTime = performance.now();
|
||
|
||
// За раз обрабатываем не больше 500 параграфов либо не больше 4мс по времени,
|
||
// чтобы не подвешивать клиент на открытии файлов
|
||
const nMaxCounter = 500;
|
||
let nCounter = 0;
|
||
|
||
var bNeedUpdate = false;
|
||
|
||
let nIndex = this.CheckArray.length - 1;
|
||
for (; nIndex >= 0; --nIndex)
|
||
{
|
||
if (this.private_TrackChangesForSingleElement(this.CheckArray[nIndex].GetId()))
|
||
bNeedUpdate = true;
|
||
|
||
if (true !== isComplete)
|
||
{
|
||
++nCounter;
|
||
if (nCounter >= nMaxCounter || (performance.now() - nStartTime) > 4)
|
||
break;
|
||
}
|
||
}
|
||
|
||
this.CheckArray.length = nIndex < 0 ? 0 : nIndex;
|
||
|
||
// TODO: Сделать нормальную проверку, что текущий параграф или текущее выделение попала в проверенные элементы
|
||
//if (bNeedUpdate)
|
||
this.LogicDocument.UpdateInterface();
|
||
};
|
||
/**
|
||
* Ищем следующее изменение
|
||
* @returns {?CRevisionsChange}
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetNextChange = function()
|
||
{
|
||
if (this.CurChange && this.CurChange.IsComplexChange())
|
||
{
|
||
var arrChanges = this.CurChange.GetSimpleChanges();
|
||
|
||
this.CurChange = null;
|
||
this.CurElement = null;
|
||
|
||
if (arrChanges.length > 0)
|
||
{
|
||
this.CurChange = arrChanges[arrChanges.length - 1];
|
||
this.CurElement = this.CurChange.GetElement();
|
||
|
||
if (!this.CurElement || !this.Changes[this.CurElement.GetId()])
|
||
{
|
||
this.CurChange = null;
|
||
this.CurElement = null;
|
||
}
|
||
}
|
||
}
|
||
|
||
var oChange = this.private_GetNextChange();
|
||
if (oChange && oChange.IsMove() && !oChange.IsComplexChange())
|
||
{
|
||
oChange = this.CollectMoveChange(oChange);
|
||
this.CurChange = oChange;
|
||
}
|
||
|
||
return oChange;
|
||
};
|
||
CTrackRevisionsManager.prototype.private_GetNextChange = function()
|
||
{
|
||
var oInitialCurChange = this.CurChange;
|
||
var oInitialCurElement = this.CurElement;
|
||
|
||
var oNextElement = null;
|
||
if (null !== this.CurChange && null !== this.CurElement && this.Changes[this.CurElement.GetId()])
|
||
{
|
||
var arrChangesArray = this.Changes[this.CurElement.GetId()];
|
||
|
||
var nChangeIndex = -1;
|
||
for (var nIndex = 0, nCount = arrChangesArray.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (this.CurChange === arrChangesArray[nIndex])
|
||
{
|
||
nChangeIndex = nIndex;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (-1 !== nChangeIndex && nChangeIndex < arrChangesArray.length - 1)
|
||
{
|
||
this.CurChange = arrChangesArray[nChangeIndex + 1];
|
||
return this.CurChange;
|
||
}
|
||
|
||
oNextElement = this.LogicDocument.GetRevisionsChangeElement(1, this.CurElement);
|
||
}
|
||
else
|
||
{
|
||
var oSearchEngine = this.LogicDocument.private_GetRevisionsChangeElement(1, null);
|
||
oNextElement = oSearchEngine.GetFoundedElement();
|
||
if (null !== oNextElement && oNextElement === oSearchEngine.GetCurrentElement())
|
||
{
|
||
var arrNextChangesArray = this.Changes[oNextElement.GetId()];
|
||
if (arrNextChangesArray && arrNextChangesArray.length > 0)
|
||
{
|
||
if (oNextElement instanceof Paragraph)
|
||
{
|
||
var ParaContentPos = oNextElement.Get_ParaContentPos(oNextElement.IsSelectionUse(), true);
|
||
for (var nChangeIndex = 0, nCount = arrNextChangesArray.length; nChangeIndex < nCount; ++nChangeIndex)
|
||
{
|
||
var ChangeEndPos = arrNextChangesArray[nChangeIndex].get_EndPos();
|
||
if (ParaContentPos.Compare(ChangeEndPos) <= 0)
|
||
{
|
||
this.CurChange = arrNextChangesArray[nChangeIndex];
|
||
this.CurElement = oNextElement;
|
||
return this.CurChange;
|
||
}
|
||
}
|
||
}
|
||
else if (oNextElement instanceof CTable && oNextElement.IsCellSelection())
|
||
{
|
||
var arrSelectedCells = oNextElement.GetSelectionArray();
|
||
if (arrSelectedCells.length > 0)
|
||
{
|
||
var nTableRow = arrSelectedCells[0].Row;
|
||
for (var nChangeIndex = 0, nCount = arrNextChangesArray.length; nChangeIndex < nCount; ++nChangeIndex)
|
||
{
|
||
var nStartRow = arrNextChangesArray[nChangeIndex].get_StartPos();
|
||
if (nTableRow <= nStartRow)
|
||
{
|
||
this.CurChange = arrNextChangesArray[nChangeIndex];
|
||
this.CurElement = oNextElement;
|
||
return this.CurChange;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
oNextElement = this.LogicDocument.GetRevisionsChangeElement(1, oNextElement);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (null !== oNextElement)
|
||
{
|
||
var arrNextChangesArray = this.Changes[oNextElement.GetId()];
|
||
if (arrNextChangesArray && arrNextChangesArray.length > 0)
|
||
{
|
||
this.CurChange = arrNextChangesArray[0];
|
||
this.CurElement = oNextElement;
|
||
return this.CurChange;
|
||
}
|
||
}
|
||
|
||
if (null !== oInitialCurChange && null !== oInitialCurElement)
|
||
{
|
||
this.CurChange = oInitialCurChange;
|
||
this.CurElement = oInitialCurElement;
|
||
return oInitialCurChange;
|
||
}
|
||
|
||
this.CurChange = null;
|
||
this.CurElement = null;
|
||
return null;
|
||
};
|
||
/**
|
||
* Ищем следующее изменение
|
||
* @returns {?CRevisionsChange}
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetPrevChange = function()
|
||
{
|
||
if (this.CurChange && this.CurChange.IsComplexChange())
|
||
{
|
||
var arrChanges = this.CurChange.GetSimpleChanges();
|
||
|
||
this.CurChange = null;
|
||
this.CurElement = null;
|
||
|
||
if (arrChanges.length > 0)
|
||
{
|
||
this.CurChange = arrChanges[0];
|
||
this.CurElement = this.CurChange.GetElement();
|
||
|
||
if (!this.CurElement || !this.Changes[this.CurElement.GetId()])
|
||
{
|
||
this.CurChange = null;
|
||
this.CurElement = null;
|
||
}
|
||
}
|
||
}
|
||
|
||
var oChange = this.private_GetPrevChange();
|
||
if (oChange && oChange.IsMove() && !oChange.IsComplexChange())
|
||
{
|
||
oChange = this.CollectMoveChange(oChange);
|
||
this.CurChange = oChange;
|
||
}
|
||
|
||
return oChange;
|
||
};
|
||
CTrackRevisionsManager.prototype.private_GetPrevChange = function()
|
||
{
|
||
var oInitialCurChange = this.CurChange;
|
||
var oInitialCurElement = this.CurElement;
|
||
|
||
var oPrevElement = null;
|
||
if (null !== this.CurChange && null !== this.CurElement)
|
||
{
|
||
var arrChangesArray = this.Changes[this.CurElement.GetId()];
|
||
var nChangeIndex = -1;
|
||
for (var nIndex = 0, nCount = arrChangesArray.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (this.CurChange === arrChangesArray[nIndex])
|
||
{
|
||
nChangeIndex = nIndex;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (-1 !== nChangeIndex && nChangeIndex > 0)
|
||
{
|
||
this.CurChange = arrChangesArray[nChangeIndex - 1];
|
||
return this.CurChange;
|
||
}
|
||
|
||
oPrevElement = this.LogicDocument.GetRevisionsChangeElement(-1, this.CurElement);
|
||
}
|
||
else
|
||
{
|
||
var SearchEngine = this.LogicDocument.private_GetRevisionsChangeElement(-1, null);
|
||
oPrevElement = SearchEngine.GetFoundedElement();
|
||
if (null !== oPrevElement && oPrevElement === SearchEngine.GetCurrentElement())
|
||
{
|
||
var arrPrevChangesArray = this.Changes[oPrevElement.GetId()];
|
||
if (undefined !== arrPrevChangesArray && arrPrevChangesArray.length > 0)
|
||
{
|
||
if (oPrevElement instanceof Paragraph)
|
||
{
|
||
var ParaContentPos = oPrevElement.Get_ParaContentPos(oPrevElement.IsSelectionUse(), true);
|
||
for (var ChangeIndex = arrPrevChangesArray.length - 1; ChangeIndex >= 0; ChangeIndex--)
|
||
{
|
||
var ChangeStartPos = arrPrevChangesArray[ChangeIndex].get_StartPos();
|
||
if (ParaContentPos.Compare(ChangeStartPos) >= 0)
|
||
{
|
||
this.CurChange = arrPrevChangesArray[ChangeIndex];
|
||
this.CurElement = oPrevElement;
|
||
return this.CurChange;
|
||
}
|
||
}
|
||
}
|
||
else if (oPrevElement instanceof CTable && oPrevElement.IsCellSelection())
|
||
{
|
||
var arrSelectedCells = oPrevElement.GetSelectionArray();
|
||
if (arrSelectedCells.length > 0)
|
||
{
|
||
var nTableRow = arrSelectedCells[0].Row;
|
||
for (var nChangeIndex = arrPrevChangesArray.length - 1; nChangeIndex >= 0; --nChangeIndex)
|
||
{
|
||
var nStartRow = arrPrevChangesArray[nChangeIndex].get_StartPos();
|
||
if (nTableRow >= nStartRow)
|
||
{
|
||
this.CurChange = arrPrevChangesArray[nChangeIndex];
|
||
this.CurElement = oPrevElement;
|
||
return this.CurChange;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
oPrevElement = this.LogicDocument.GetRevisionsChangeElement(-1, oPrevElement);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (null !== oPrevElement)
|
||
{
|
||
var arrPrevChangesArray = this.Changes[oPrevElement.GetId()];
|
||
if (undefined !== arrPrevChangesArray && arrPrevChangesArray.length > 0)
|
||
{
|
||
this.CurChange = arrPrevChangesArray[arrPrevChangesArray.length - 1];
|
||
this.CurElement = oPrevElement;
|
||
return this.CurChange;
|
||
}
|
||
}
|
||
|
||
if (null !== oInitialCurChange && null !== oInitialCurElement)
|
||
{
|
||
this.CurChange = oInitialCurChange;
|
||
this.CurElement = oInitialCurElement;
|
||
return oInitialCurChange;
|
||
}
|
||
|
||
this.CurChange = null;
|
||
this.CurElement = null;
|
||
return null;
|
||
};
|
||
/**
|
||
* Проверяем есть ли непримененные изменения в документе
|
||
* @returns {boolean}
|
||
*/
|
||
CTrackRevisionsManager.prototype.Have_Changes = function()
|
||
{
|
||
var oTableId = this.LogicDocument ? this.LogicDocument.GetTableId() : null;
|
||
|
||
for (var sElementId in this.Changes)
|
||
{
|
||
var oElement = oTableId ? oTableId.Get_ById(sElementId) : null;
|
||
|
||
if (!oElement || !oElement.IsUseInDocument || !oElement.IsUseInDocument())
|
||
continue;
|
||
|
||
if (this.Changes[sElementId].length > 0)
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
};
|
||
/**
|
||
* Проверяем есть ли изменения, сделанные другими пользователями
|
||
* @returns {boolean}
|
||
*/
|
||
CTrackRevisionsManager.prototype.HaveOtherUsersChanges = function()
|
||
{
|
||
var sUserId = this.LogicDocument.GetUserId(false);
|
||
for (var sParaId in this.Changes)
|
||
{
|
||
var oParagraph = AscCommon.g_oTableId.Get_ById(sParaId);
|
||
if (!oParagraph || !oParagraph.IsUseInDocument())
|
||
continue;
|
||
|
||
for (var nIndex = 0, nCount = this.Changes[sParaId].length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oChange = this.Changes[sParaId][nIndex];
|
||
if (oChange.get_UserId() !== sUserId)
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
};
|
||
CTrackRevisionsManager.prototype.ClearCurrentChange = function()
|
||
{
|
||
this.CurChange = null;
|
||
this.CurElement = null;
|
||
};
|
||
CTrackRevisionsManager.prototype.SetCurrentChange = function(oCurChange)
|
||
{
|
||
if (oCurChange)
|
||
{
|
||
this.CurChange = oCurChange;
|
||
this.CurElement = oCurChange.GetElement();
|
||
}
|
||
};
|
||
CTrackRevisionsManager.prototype.GetCurrentChangeElement = function()
|
||
{
|
||
return this.CurElement;
|
||
};
|
||
CTrackRevisionsManager.prototype.GetCurrentChange = function()
|
||
{
|
||
return this.CurChange;
|
||
};
|
||
CTrackRevisionsManager.prototype.InitSelectedChanges = function()
|
||
{
|
||
var oEditorApi = this.LogicDocument.GetApi();
|
||
if (!oEditorApi)
|
||
return;
|
||
|
||
oEditorApi.sync_BeginCatchRevisionsChanges();
|
||
oEditorApi.sync_EndCatchRevisionsChanges();
|
||
};
|
||
CTrackRevisionsManager.prototype.ClearSelectedChanges = function()
|
||
{
|
||
if (this.SelectedChanges.length > 0)
|
||
{
|
||
var oEditorApi = this.LogicDocument.GetApi();
|
||
if (!oEditorApi)
|
||
return;
|
||
|
||
oEditorApi.sync_BeginCatchRevisionsChanges();
|
||
oEditorApi.sync_EndCatchRevisionsChanges();
|
||
}
|
||
|
||
this.SelectedChanges = [];
|
||
};
|
||
/**
|
||
* Добавляем изменение, видимое в текущей позиции
|
||
* @param oChange
|
||
*/
|
||
CTrackRevisionsManager.prototype.AddSelectedChange = function(oChange)
|
||
{
|
||
if (this.CurChange)
|
||
return;
|
||
|
||
if (oChange && c_oAscRevisionsChangeType.MoveMark === oChange.get_Type())
|
||
return;
|
||
|
||
if (oChange.IsMove() && !oChange.IsComplexChange())
|
||
oChange = this.CollectMoveChange(oChange);
|
||
|
||
for (var nIndex = 0, nCount = this.SelectedChanges.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oVisChange = this.SelectedChanges[nIndex];
|
||
if (oVisChange.IsComplexChange() && !oChange.IsComplexChange())
|
||
{
|
||
var arrSimpleChanges = oVisChange.GetSimpleChanges();
|
||
for (var nSimpleIndex = 0, nSimpleCount = arrSimpleChanges.length; nSimpleIndex < nSimpleCount; ++nSimpleIndex)
|
||
{
|
||
if (arrSimpleChanges[nSimpleIndex] === oChange)
|
||
return;
|
||
}
|
||
}
|
||
else if (!oVisChange.IsComplexChange() && oChange.IsComplexChange())
|
||
{
|
||
var arrSimpleChanges = oChange.GetSimpleChanges();
|
||
for (var nSimpleIndex = 0, nSimpleCount = arrSimpleChanges.length; nSimpleIndex < nSimpleCount; ++nSimpleIndex)
|
||
{
|
||
if (arrSimpleChanges[nSimpleIndex] === oVisChange)
|
||
{
|
||
this.SelectedChanges.splice(nIndex, 1);
|
||
nCount--;
|
||
nIndex--;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if (oVisChange.IsComplexChange() && oChange.IsComplexChange())
|
||
{
|
||
var arrVisSC = oVisChange.GetSimpleChanges();
|
||
var arrChangeSC = oChange.GetSimpleChanges();
|
||
|
||
var isEqual = false;
|
||
if (arrVisSC.length === arrChangeSC.length)
|
||
{
|
||
isEqual = true;
|
||
for (var nSimpleIndex = 0, nSimplesCount = arrVisSC.length; nSimpleIndex < nSimplesCount; ++nSimpleIndex)
|
||
{
|
||
if (arrVisSC[nSimpleIndex] !== arrChangeSC[nSimpleIndex])
|
||
{
|
||
isEqual = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (isEqual)
|
||
return;
|
||
}
|
||
else if (oChange === oVisChange)
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
this.SelectedChanges.push(oChange);
|
||
};
|
||
CTrackRevisionsManager.prototype.GetSelectedChanges = function()
|
||
{
|
||
return this.SelectedChanges;
|
||
};
|
||
CTrackRevisionsManager.prototype.BeginCollectChanges = function(bSaveCurrentChange)
|
||
{
|
||
if (!this.IsAllChecked())
|
||
return;
|
||
|
||
this.PrevSelectedChanges = this.SelectedChanges;
|
||
this.SelectedChanges = [];
|
||
|
||
if (true !== bSaveCurrentChange)
|
||
{
|
||
this.ClearCurrentChange();
|
||
}
|
||
else if (this.CurElement && this.CurChange)
|
||
{
|
||
var oSelectionBounds = this.CurElement.GetSelectionBounds();
|
||
|
||
var oBounds = oSelectionBounds.Direction > 0 ? oSelectionBounds.Start : oSelectionBounds.End;
|
||
|
||
if (oBounds)
|
||
{
|
||
var X = this.LogicDocument.Get_PageLimits(oBounds.Page).XLimit;
|
||
this.CurChange.put_InternalPos(X, oBounds.Y, oBounds.Page);
|
||
this.SelectedChanges.push(this.CurChange);
|
||
}
|
||
}
|
||
};
|
||
CTrackRevisionsManager.prototype.EndCollectChanges = function()
|
||
{
|
||
if (!this.IsAllChecked())
|
||
return;
|
||
|
||
var oEditor = this.LogicDocument.GetApi();
|
||
if (this.CurChange)
|
||
this.SelectedChanges = [this.CurChange];
|
||
|
||
var isPositionChanged = false;
|
||
var isArrayChanged = false;
|
||
var isShowChanges = this.CurChange || !this.LogicDocument.IsTextSelectionUse();
|
||
|
||
var nChangesCount = this.SelectedChanges.length;
|
||
if (this.PrevSelectedChanges.length !== nChangesCount || this.PrevShowChanges !== isShowChanges)
|
||
{
|
||
isArrayChanged = true;
|
||
}
|
||
else if (0 !== nChangesCount)
|
||
{
|
||
for (var nChangeIndex = 0; nChangeIndex < nChangesCount; ++nChangeIndex)
|
||
{
|
||
if (this.SelectedChanges[nChangeIndex] !== this.PrevSelectedChanges[nChangeIndex])
|
||
{
|
||
isArrayChanged = true;
|
||
break;
|
||
}
|
||
else if (this.SelectedChanges[nChangeIndex].IsPositionChanged())
|
||
{
|
||
isPositionChanged = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (isArrayChanged)
|
||
{
|
||
oEditor.sync_BeginCatchRevisionsChanges();
|
||
|
||
if (nChangesCount > 0)
|
||
{
|
||
var oPos = this.private_GetSelectedChangesXY();
|
||
for (var ChangeIndex = 0; ChangeIndex < nChangesCount; ChangeIndex++)
|
||
{
|
||
var Change = this.SelectedChanges[ChangeIndex];
|
||
Change.put_XY(oPos.X, oPos.Y);
|
||
oEditor.sync_AddRevisionsChange(Change);
|
||
}
|
||
}
|
||
oEditor.sync_EndCatchRevisionsChanges(isShowChanges);
|
||
}
|
||
else if (isPositionChanged)
|
||
{
|
||
this.UpdateSelectedChangesPosition(oEditor);
|
||
}
|
||
|
||
this.PrevShowChanges = isShowChanges;
|
||
};
|
||
CTrackRevisionsManager.prototype.UpdateSelectedChangesPosition = function(oEditor)
|
||
{
|
||
if (this.SelectedChanges.length > 0)
|
||
{
|
||
var oPos = this.private_GetSelectedChangesXY();
|
||
oEditor.sync_UpdateRevisionsChangesPosition(oPos.X, oPos.Y);
|
||
}
|
||
};
|
||
CTrackRevisionsManager.prototype.private_GetSelectedChangesXY = function()
|
||
{
|
||
if (!this.SelectedChanges.length)
|
||
return {X : 0, Y : 0};
|
||
|
||
let change = this.SelectedChanges[0];
|
||
|
||
let element = change.GetElement();
|
||
if (!element)
|
||
return {X : 0, Y : 0};
|
||
|
||
let x = change.GetInternalPosX();
|
||
let y = change.GetInternalPosY();
|
||
let page = change.GetInternalPosPageNum();
|
||
|
||
let transform = element.Get_ParentTextTransform();
|
||
if (transform)
|
||
y = transform.TransformPointY(x, y);
|
||
|
||
let drawingCoords = this.LogicDocument.getDrawingDocument().ConvertCoordsToCursorWR(x, y, page);
|
||
return {X : drawingCoords.X, Y : drawingCoords.Y};
|
||
};
|
||
CTrackRevisionsManager.prototype.Get_AllChangesLogicDocuments = function()
|
||
{
|
||
this.CompleteTrackChanges();
|
||
var LogicDocuments = {};
|
||
|
||
for (var ParaId in this.Changes)
|
||
{
|
||
var Para = AscCommon.g_oTableId.Get_ById(ParaId);
|
||
if (Para && Para.Get_Parent())
|
||
{
|
||
LogicDocuments[Para.Get_Parent().Get_Id()] = true;
|
||
}
|
||
}
|
||
|
||
return LogicDocuments;
|
||
};
|
||
CTrackRevisionsManager.prototype.GetChangeRelatedParagraphs = function(oChange, bAccept)
|
||
{
|
||
var oRelatedParas = {};
|
||
|
||
if (oChange.IsComplexChange())
|
||
{
|
||
var arrSimpleChanges = oChange.GetSimpleChanges();
|
||
for (var nIndex = 0, nCount = arrSimpleChanges.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
this.private_GetChangeRelatedParagraphs(arrSimpleChanges[nIndex], bAccept, oRelatedParas);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
this.private_GetChangeRelatedParagraphs(oChange, bAccept, oRelatedParas);
|
||
}
|
||
|
||
return this.private_ConvertParagraphsObjectToArray(oRelatedParas);
|
||
};
|
||
CTrackRevisionsManager.prototype.private_GetChangeRelatedParagraphs = function(oChange, bAccept, oRelatedParas)
|
||
{
|
||
if (oChange)
|
||
{
|
||
var nType = oChange.GetType();
|
||
var oElement = oChange.GetElement();
|
||
if (oElement && oElement.IsUseInDocument())
|
||
{
|
||
oRelatedParas[oElement.GetId()] = true;
|
||
if ((c_oAscRevisionsChangeType.ParaAdd === nType && true !== bAccept) || (c_oAscRevisionsChangeType.ParaRem === nType && true === bAccept))
|
||
{
|
||
var oLogicDocument = oElement.GetParent();
|
||
var nParaIndex = oElement.GetIndex();
|
||
|
||
if (oLogicDocument && -1 !== nParaIndex)
|
||
{
|
||
if (nParaIndex < oLogicDocument.GetElementsCount() - 1)
|
||
{
|
||
var oNextElement = oLogicDocument.GetElement(nParaIndex + 1);
|
||
if (oNextElement && oNextElement.IsParagraph())
|
||
oRelatedParas[oNextElement.GetId()] = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CTrackRevisionsManager.prototype.private_ConvertParagraphsObjectToArray = function(ParagraphsObject)
|
||
{
|
||
var ParagraphsArray = [];
|
||
for (var ParaId in ParagraphsObject)
|
||
{
|
||
var Para = AscCommon.g_oTableId.Get_ById(ParaId);
|
||
if (null !== Para)
|
||
{
|
||
ParagraphsArray.push(Para);
|
||
}
|
||
}
|
||
return ParagraphsArray;
|
||
};
|
||
CTrackRevisionsManager.prototype.Get_AllChangesRelatedParagraphs = function(bAccept)
|
||
{
|
||
var RelatedParas = {};
|
||
for (var ParaId in this.Changes)
|
||
{
|
||
for (var ChangeIndex = 0, ChangesCount = this.Changes[ParaId].length; ChangeIndex < ChangesCount; ++ChangeIndex)
|
||
{
|
||
var Change = this.Changes[ParaId][ChangeIndex];
|
||
this.private_GetChangeRelatedParagraphs(Change, bAccept, RelatedParas);
|
||
}
|
||
}
|
||
return this.private_ConvertParagraphsObjectToArray(RelatedParas);
|
||
};
|
||
CTrackRevisionsManager.prototype.Get_AllChangesRelatedParagraphsBySelectedParagraphs = function(SelectedParagraphs, bAccept)
|
||
{
|
||
var RelatedParas = {};
|
||
for (var ParaIndex = 0, ParasCount = SelectedParagraphs.length; ParaIndex < ParasCount; ++ParaIndex)
|
||
{
|
||
var Para = SelectedParagraphs[ParaIndex];
|
||
var ParaId = Para.Get_Id();
|
||
if (this.Changes[ParaId] && this.Changes[ParaId].length > 0)
|
||
{
|
||
RelatedParas[ParaId] = true;
|
||
if (true === Para.Selection_CheckParaEnd())
|
||
{
|
||
var CheckNext = false;
|
||
for (var ChangeIndex = 0, ChangesCount = this.Changes[ParaId].length; ChangeIndex < ChangesCount; ++ChangeIndex)
|
||
{
|
||
var ChangeType = this.Changes[ParaId][ChangeIndex].get_Type();
|
||
if ((c_oAscRevisionsChangeType.ParaAdd === ChangeType && true !== bAccept) || (c_oAscRevisionsChangeType.ParaRem === ChangeType && true === bAccept))
|
||
{
|
||
CheckNext = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (true === CheckNext)
|
||
{
|
||
var NextElement = Para.Get_DocumentNext();
|
||
if (null !== NextElement && type_Paragraph === NextElement.Get_Type())
|
||
{
|
||
RelatedParas[NextElement.Get_Id()] = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return this.private_ConvertParagraphsObjectToArray(RelatedParas);
|
||
};
|
||
CTrackRevisionsManager.prototype.Get_AllChanges = function()
|
||
{
|
||
this.CompleteTrackChanges();
|
||
return this.Changes;
|
||
};
|
||
CTrackRevisionsManager.prototype.IsAllChecked = function()
|
||
{
|
||
return (!this.CheckArray.length && !haveElementToCheck());
|
||
};
|
||
/**
|
||
* Завершаем проверку всех элементов на наличие рецензирования
|
||
*/
|
||
CTrackRevisionsManager.prototype.CompleteTrackChanges = function()
|
||
{
|
||
while (!this.IsAllChecked())
|
||
this.ContinueTrackRevisions();
|
||
};
|
||
/**
|
||
* Завершаем проверку рецензирования для заданных элементов
|
||
* @param arrElements
|
||
* @returns {boolean}
|
||
*/
|
||
CTrackRevisionsManager.prototype.CompleteTrackChangesForElements = function(arrElements)
|
||
{
|
||
var isChecked = false;
|
||
for (var nIndex = 0, nCount = arrElements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (this.private_TrackChangesForSingleElement(arrElements[nIndex].GetId()))
|
||
isChecked = true;
|
||
}
|
||
|
||
return isChecked;
|
||
};
|
||
CTrackRevisionsManager.prototype.private_TrackChangesForSingleElement = function(Id)
|
||
{
|
||
if (!this.CheckMap[Id])
|
||
return false;
|
||
|
||
let oElement = this.CheckMap[Id];
|
||
|
||
delete this.CheckMap[Id];
|
||
|
||
if (!oElement.IsUseInDocument())
|
||
return false;
|
||
|
||
let isHaveChanges = !!this.Changes[Id];
|
||
|
||
this.private_RemoveChangeObject(Id);
|
||
oElement.CheckRevisionsChanges(this);
|
||
|
||
return !(!isHaveChanges && !this.Changes[Id]);
|
||
};
|
||
/**
|
||
* При чтении файла обновляем Id перетаскиваний в рецензировании
|
||
* @param sMoveId
|
||
*/
|
||
CTrackRevisionsManager.prototype.UpdateMoveId = function(sMoveId)
|
||
{
|
||
if (0 === sMoveId.indexOf("move"))
|
||
{
|
||
var nId = parseInt(sMoveId.substring(4));
|
||
if (!isNaN(nId))
|
||
this.MoveId = Math.max(this.MoveId, nId);
|
||
}
|
||
};
|
||
/**
|
||
* Возвращаем новый идентификатор перемещений
|
||
* @returns {string}
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetNewMoveId = function()
|
||
{
|
||
this.MoveId++;
|
||
return "move" + this.MoveId;
|
||
};
|
||
CTrackRevisionsManager.prototype.RegisterMoveMark = function(oMark)
|
||
{
|
||
if (this.LogicDocument && this.LogicDocument.PrintSelection)
|
||
return;
|
||
|
||
if (!oMark)
|
||
return;
|
||
|
||
var sMarkId = oMark.GetMarkId();
|
||
var isFrom = oMark.IsFrom();
|
||
var isStart = oMark.IsStart();
|
||
|
||
this.UpdateMoveId(sMarkId);
|
||
|
||
if (!this.MoveMarks[sMarkId])
|
||
{
|
||
this.MoveMarks[sMarkId] = {
|
||
|
||
From : {
|
||
Start : null,
|
||
End : null
|
||
},
|
||
|
||
To : {
|
||
Start : null,
|
||
End : null
|
||
}
|
||
};
|
||
}
|
||
|
||
if (isFrom)
|
||
{
|
||
if (isStart)
|
||
this.MoveMarks[sMarkId].From.Start = oMark;
|
||
else
|
||
this.MoveMarks[sMarkId].From.End = oMark;
|
||
}
|
||
else
|
||
{
|
||
if (isStart)
|
||
this.MoveMarks[sMarkId].To.Start = oMark;
|
||
else
|
||
this.MoveMarks[sMarkId].To.End = oMark;
|
||
}
|
||
};
|
||
CTrackRevisionsManager.prototype.UnregisterMoveMark = function(oMark)
|
||
{
|
||
if (this.LogicDocument && this.LogicDocument.PrintSelection)
|
||
return;
|
||
|
||
if (!oMark)
|
||
return;
|
||
|
||
var sMarkId = oMark.GetMarkId();
|
||
delete this.MoveMarks[sMarkId];
|
||
|
||
// TODO: Возможно тут нужно проделать дополнительные действия
|
||
};
|
||
CTrackRevisionsManager.prototype.private_CheckChangeObject = function(sId)
|
||
{
|
||
var oElement = AscCommon.g_oTableId.Get_ById(sId);
|
||
if (!oElement)
|
||
return false;
|
||
|
||
if (!this.Changes[sId])
|
||
this.Changes[sId] = [];
|
||
|
||
var nDeletePosition = -1;
|
||
for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (this.ChangesOutline[nIndex].GetId() === sId)
|
||
{
|
||
nDeletePosition = nIndex;
|
||
break;
|
||
}
|
||
}
|
||
|
||
var oDocPos = oElement.GetDocumentPositionFromObject();
|
||
if (!oDocPos)
|
||
return;
|
||
|
||
var nAddPosition = -1;
|
||
for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oTempDocPos = this.ChangesOutline[nIndex].GetDocumentPositionFromObject();
|
||
|
||
if (this.private_CompareDocumentPositions(oDocPos, oTempDocPos) < 0)
|
||
{
|
||
nAddPosition = nIndex;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (-1 === nAddPosition)
|
||
nAddPosition = this.ChangesOutline.length;
|
||
|
||
if (nAddPosition === nDeletePosition || (-1 !== nAddPosition && -1 !== nDeletePosition && nDeletePosition === nAddPosition - 1))
|
||
return true;
|
||
|
||
if (-1 !== nDeletePosition)
|
||
{
|
||
this.ChangesOutline.splice(nDeletePosition, 1);
|
||
|
||
if (nAddPosition > nDeletePosition)
|
||
nAddPosition--;
|
||
}
|
||
|
||
this.ChangesOutline.splice(nAddPosition, 0, oElement);
|
||
|
||
return true;
|
||
};
|
||
CTrackRevisionsManager.prototype.private_CompareDocumentPositions = function(oDocPos1, oDocPos2)
|
||
{
|
||
if (oDocPos1.Class !== oDocPos2.Class)
|
||
{
|
||
// TODO: Здесь нужно доработать сравнение позиций, когда они из разных частей документа
|
||
if (oDocPos1.Class instanceof CDocument)
|
||
return -1;
|
||
else if (oDocPos1.Class instanceof CDocument)
|
||
return 1;
|
||
else
|
||
return 1;
|
||
}
|
||
|
||
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;
|
||
};
|
||
CTrackRevisionsManager.prototype.private_RemoveChangeObject = function(sId)
|
||
{
|
||
if (this.Changes[sId])
|
||
delete this.Changes[sId];
|
||
|
||
for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (this.ChangesOutline[nIndex].GetId() === sId)
|
||
{
|
||
this.ChangesOutline.splice(nIndex, 1);
|
||
return;
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Собираем изменение связанное с переносом
|
||
* @param {CRevisionsChange} oChange
|
||
* @returns {CRevisionsChange}
|
||
*/
|
||
CTrackRevisionsManager.prototype.CollectMoveChange = function(oChange)
|
||
{
|
||
var isFrom = c_oAscRevisionsChangeType.TextRem === oChange.GetType() || c_oAscRevisionsChangeType.ParaRem === oChange.GetType() || (c_oAscRevisionsChangeType.MoveMark === oChange.GetType() && oChange.GetValue().IsFrom());
|
||
|
||
var nStartIndex = -1;
|
||
var oStartChange = null;
|
||
|
||
var oElement = oChange.GetElement();
|
||
if (!oElement)
|
||
return oChange;
|
||
|
||
var nDeep = 0;
|
||
var nSearchIndex = -1;
|
||
for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (this.ChangesOutline[nIndex] === oElement)
|
||
{
|
||
nSearchIndex = nIndex;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (-1 === nSearchIndex)
|
||
return oChange;
|
||
|
||
var isStart = false;
|
||
|
||
for (var nIndex = nSearchIndex; nIndex >= 0; --nIndex)
|
||
{
|
||
var arrCurChanges = this.Changes[this.ChangesOutline[nIndex].GetId()];
|
||
|
||
if (!arrCurChanges)
|
||
{
|
||
isStart = true;
|
||
continue;
|
||
}
|
||
|
||
for (var nChangeIndex = arrCurChanges.length - 1; nChangeIndex >= 0; --nChangeIndex)
|
||
{
|
||
var oCurChange = arrCurChanges[nChangeIndex];
|
||
if (!isStart)
|
||
{
|
||
if (oCurChange === oChange)
|
||
isStart = true;
|
||
}
|
||
|
||
if (isStart)
|
||
{
|
||
var nCurChangeType = oCurChange.GetType();
|
||
if (nCurChangeType === c_oAscRevisionsChangeType.MoveMark)
|
||
{
|
||
var oMoveMark = oCurChange.GetValue();
|
||
if ((isFrom && oMoveMark.IsFrom()) || (!isFrom && !oMoveMark.IsFrom()))
|
||
{
|
||
if (oMoveMark.IsStart())
|
||
{
|
||
if (nDeep > 0)
|
||
{
|
||
nDeep--;
|
||
}
|
||
else if (nDeep === 0)
|
||
{
|
||
nStartIndex = nIndex;
|
||
oStartChange = oCurChange;
|
||
break;
|
||
}
|
||
}
|
||
else if (oCurChange !== oChange)
|
||
{
|
||
nDeep++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (oStartChange)
|
||
break;
|
||
|
||
isStart = true;
|
||
}
|
||
|
||
if (!oStartChange || -1 === nStartIndex)
|
||
return oChange;
|
||
|
||
var sValue = "";
|
||
var arrChanges = [oStartChange];
|
||
|
||
isStart = false;
|
||
nDeep = 0;
|
||
var isEnd = false;
|
||
for (var nIndex = nStartIndex, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var arrCurChanges = this.Changes[this.ChangesOutline[nIndex].GetId()];
|
||
for (var nChangeIndex = 0, nChangesCount = arrCurChanges.length; nChangeIndex < nChangesCount; ++nChangeIndex)
|
||
{
|
||
var oCurChange = arrCurChanges[nChangeIndex];
|
||
if (!isStart)
|
||
{
|
||
if (oCurChange === oStartChange)
|
||
isStart = true;
|
||
}
|
||
else
|
||
{
|
||
var nCurChangeType = oCurChange.GetType();
|
||
if (isFrom)
|
||
{
|
||
if (c_oAscRevisionsChangeType.TextRem === nCurChangeType || c_oAscRevisionsChangeType.ParaRem === nCurChangeType)
|
||
{
|
||
if (0 === nDeep)
|
||
{
|
||
sValue += c_oAscRevisionsChangeType.TextRem === nCurChangeType ? oCurChange.GetValue() : "\n";
|
||
arrChanges.push(oCurChange);
|
||
}
|
||
}
|
||
else if (c_oAscRevisionsChangeType.MoveMark === nCurChangeType && oCurChange.GetValue().IsFrom())
|
||
{
|
||
if (oCurChange.GetValue().IsStart())
|
||
{
|
||
nDeep++;
|
||
}
|
||
else if (nDeep > 0)
|
||
{
|
||
nDeep--;
|
||
}
|
||
else
|
||
{
|
||
arrChanges.push(oCurChange);
|
||
isEnd = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (c_oAscRevisionsChangeType.TextAdd === nCurChangeType || c_oAscRevisionsChangeType.ParaAdd === nCurChangeType)
|
||
{
|
||
if (0 === nDeep)
|
||
{
|
||
sValue += c_oAscRevisionsChangeType.TextAdd === nCurChangeType ? oCurChange.GetValue() : "\n";
|
||
arrChanges.push(oCurChange);
|
||
}
|
||
}
|
||
else if (c_oAscRevisionsChangeType.MoveMark === nCurChangeType && !oCurChange.GetValue().IsFrom())
|
||
{
|
||
if (oCurChange.GetValue().IsStart())
|
||
{
|
||
nDeep++;
|
||
}
|
||
else if (nDeep > 0)
|
||
{
|
||
nDeep--;
|
||
}
|
||
else
|
||
{
|
||
arrChanges.push(oCurChange);
|
||
isEnd = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!isStart)
|
||
return oChange;
|
||
|
||
if (isEnd)
|
||
break;
|
||
}
|
||
|
||
var sMoveId = oStartChange.GetValue().GetMarkId();
|
||
var isDown = null;
|
||
|
||
for (var nIndex = 0, nCount = this.ChangesOutline.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var arrCurChanges = this.Changes[this.ChangesOutline[nIndex].GetId()];
|
||
if (!arrCurChanges)
|
||
continue;
|
||
|
||
for (var nChangeIndex = 0, nChangesCount = arrCurChanges.length; nChangeIndex < nChangesCount; ++nChangeIndex)
|
||
{
|
||
var oCurChange = arrCurChanges[nChangeIndex];
|
||
if (c_oAscRevisionsChangeType.MoveMark === oCurChange.GetType())
|
||
{
|
||
var oMark = oCurChange.GetValue();
|
||
if (sMoveId === oMark.GetMarkId())
|
||
{
|
||
isDown = !!oMark.IsFrom();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (null !== isDown)
|
||
break;
|
||
}
|
||
|
||
if (!isEnd || null === isDown)
|
||
return oChange;
|
||
|
||
var oMoveChange = new CRevisionsChange();
|
||
oMoveChange.SetType(isFrom ? c_oAscRevisionsChangeType.TextRem : c_oAscRevisionsChangeType.TextAdd);
|
||
oMoveChange.SetValue(sValue);
|
||
oMoveChange.SetElement(oStartChange.GetElement());
|
||
oMoveChange.SetUserId(oStartChange.GetUserId());
|
||
oMoveChange.SetUserName(oStartChange.GetUserName());
|
||
oMoveChange.SetDateTime(oStartChange.GetDateTime());
|
||
oMoveChange.SetMoveType(isFrom ? Asc.c_oAscRevisionsMove.MoveFrom : Asc.c_oAscRevisionsMove.MoveTo);
|
||
oMoveChange.SetSimpleChanges(arrChanges);
|
||
oMoveChange.SetMoveId(sMoveId);
|
||
oMoveChange.SetMovedDown(isDown);
|
||
oMoveChange.SetXY(oChange.GetX(), oChange.GetY());
|
||
oMoveChange.SetInternalPos(oChange.GetInternalPosX(), oChange.GetInternalPosY(), oChange.GetInternalPosPageNum());
|
||
return oMoveChange;
|
||
};
|
||
/**
|
||
* Получаем массив всех изменений связанных с заданным переносом
|
||
* @param {string} sMoveId
|
||
* @returns {CRevisionsChange[]}
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetAllMoveChanges = function(sMoveId)
|
||
{
|
||
var oStartFromChange = null;
|
||
var oStartToChange = null;
|
||
|
||
for (var sElementId in this.Changes)
|
||
{
|
||
var arrElementChanges = this.Changes[sElementId];
|
||
for (var nChangeIndex = 0, nChangesCount = arrElementChanges.length; nChangeIndex < nChangesCount; ++nChangeIndex)
|
||
{
|
||
var oCurChange = arrElementChanges[nChangeIndex];
|
||
if (c_oAscRevisionsChangeType.MoveMark === oCurChange.GetType() && sMoveId === oCurChange.GetValue().GetMarkId() && oCurChange.GetValue().IsStart())
|
||
{
|
||
if (oCurChange.GetValue().IsFrom())
|
||
oStartFromChange = oCurChange;
|
||
else
|
||
oStartToChange = oCurChange;
|
||
}
|
||
}
|
||
|
||
if (oStartFromChange && oStartToChange)
|
||
break;
|
||
}
|
||
|
||
if (!oStartFromChange || !oStartToChange)
|
||
return {From : [], To : []};
|
||
|
||
return {
|
||
From : this.CollectMoveChange(oStartFromChange).GetSimpleChanges(),
|
||
To : this.CollectMoveChange(oStartToChange).GetSimpleChanges()
|
||
};
|
||
};
|
||
/**
|
||
* Начинаем процесс обработки(принятия или отклонения) перетаскивания текста
|
||
* @param sMoveId {string} идентификатор перетаскивания
|
||
* @param sUserId {string} идентификатор пользователя
|
||
* @returns {CTrackRevisionsMoveProcessEngine}
|
||
*/
|
||
CTrackRevisionsManager.prototype.StartProcessReviewMove = function(sMoveId, sUserId)
|
||
{
|
||
return (this.ProcessMove = new CTrackRevisionsMoveProcessEngine(sMoveId, sUserId));
|
||
};
|
||
/**
|
||
* Завершаем процесс обработки перетаскивания текста
|
||
*/
|
||
CTrackRevisionsManager.prototype.EndProcessReviewMove = function()
|
||
{
|
||
// TODO: Здесь нужно сделать обработку MovesToDelete
|
||
|
||
this.ProcessMove = null;
|
||
};
|
||
/**
|
||
* Проверям, запущен ли процесс обрабокти перетаскивания текста
|
||
* @returns {?CTrackRevisionsMoveProcessEngine}
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetProcessTrackMove = function()
|
||
{
|
||
return this.ProcessMove;
|
||
};
|
||
/**
|
||
* Получаем метки переноса
|
||
* @param sMarkId
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetMoveMarks = function(sMarkId)
|
||
{
|
||
return this.MoveMarks[sMarkId];
|
||
};
|
||
/**
|
||
* Получаем элементарное изменение связанное с заданным переносом, относящееся к метке переноса
|
||
* @param {string} sMoveId
|
||
* @param {boolean} isFrom
|
||
* @param {boolean} isStart
|
||
*/
|
||
CTrackRevisionsManager.prototype.GetMoveMarkChange = function(sMoveId, isFrom, isStart)
|
||
{
|
||
this.CompleteTrackChanges();
|
||
|
||
var oMoveChanges = this.GetAllMoveChanges(sMoveId);
|
||
var arrChanges = isFrom ? oMoveChanges.From : oMoveChanges.To;
|
||
|
||
for (var nIndex = 0, nCount = arrChanges.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oChange = arrChanges[nIndex];
|
||
if (Asc.c_oAscRevisionsChangeType.MoveMark === oChange.GetType())
|
||
{
|
||
var oMark = oChange.GetValue();
|
||
if (oMark.IsFrom() === isFrom && oMark.IsStart() === isStart)
|
||
{
|
||
return oChange;
|
||
}
|
||
}
|
||
}
|
||
|
||
return null;
|
||
};
|
||
//--------------------------------------------------------export----------------------------------------------------
|
||
window['AscWord'].CTrackRevisionsManager = CTrackRevisionsManager;
|
||
window['AscWord'].checkElementInRevision = checkElementInRevision;
|
||
|
||
})(window);
|