Yajbir Singh
555 lines
20 KiB
JavaScript
555 lines
20 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";
|
|
|
|
/**
|
|
*
|
|
* @constructor
|
|
* @extends {AscCommon.CCollaborativeEditingBase}
|
|
*/
|
|
function CWordCollaborativeEditing()
|
|
{
|
|
AscCommon.CCollaborativeEditingBase.call(this);
|
|
this.m_aSkipContentControlsOnCheckEditingLock = {};
|
|
}
|
|
|
|
CWordCollaborativeEditing.prototype = Object.create(AscCommon.CCollaborativeEditingBase.prototype);
|
|
CWordCollaborativeEditing.prototype.constructor = CWordCollaborativeEditing;
|
|
CWordCollaborativeEditing.prototype.GetEditorApi = function()
|
|
{
|
|
if(this.m_oLogicDocument)
|
|
{
|
|
return this.m_oLogicDocument.GetApi();
|
|
}
|
|
return null;
|
|
};
|
|
CWordCollaborativeEditing.prototype.GetDrawingDocument = function()
|
|
{
|
|
if(this.m_oLogicDocument)
|
|
{
|
|
return this.m_oLogicDocument.GetDrawingDocument();
|
|
}
|
|
return null;
|
|
};
|
|
CWordCollaborativeEditing.prototype.Clear = function()
|
|
{
|
|
AscCommon.CCollaborativeEditingBase.prototype.Clear.apply(this, arguments);
|
|
this.Remove_AllForeignCursors();
|
|
};
|
|
CWordCollaborativeEditing.prototype.Apply_OtherChanges = function()
|
|
{
|
|
AscCommon.executeNoRevisions(AscCommon.CCollaborativeEditingBase.prototype.Apply_OtherChanges, this.GetLogicDocument(), this, arguments);
|
|
};
|
|
CWordCollaborativeEditing.prototype.Send_Changes = function(IsUserSave, AdditionalInfo, IsUpdateInterface, isAfterAskSave)
|
|
{
|
|
if (!this.canSendChanges())
|
|
return;
|
|
|
|
// Пересчитываем позиции
|
|
this.Refresh_DCChanges();
|
|
|
|
// Генерируем свои изменения
|
|
var StartPoint = ( null === AscCommon.History.SavedIndex ? 0 : AscCommon.History.SavedIndex + 1 );
|
|
var LastPoint = -1;
|
|
|
|
if (this.m_nUseType <= 0)
|
|
{
|
|
// (ненужные точки предварительно удаляем)
|
|
AscCommon.History.Clear_Redo();
|
|
LastPoint = AscCommon.History.Points.length - 1;
|
|
}
|
|
else
|
|
{
|
|
LastPoint = AscCommon.History.Index;
|
|
}
|
|
|
|
// Просчитаем сколько изменений на сервер пересылать не надо
|
|
var SumIndex = 0;
|
|
var StartPoint2 = Math.min(StartPoint, LastPoint + 1);
|
|
for (var PointIndex = 0; PointIndex < StartPoint2; PointIndex++)
|
|
{
|
|
var Point = AscCommon.History.Points[PointIndex];
|
|
SumIndex += Point.Items.length;
|
|
}
|
|
var deleteIndex = ( null === AscCommon.History.SavedIndex ? null : SumIndex );
|
|
|
|
var aChanges = [], aChanges2 = [];
|
|
for (var PointIndex = StartPoint; PointIndex <= LastPoint; PointIndex++)
|
|
{
|
|
var Point = AscCommon.History.Points[PointIndex];
|
|
AscCommon.History.Update_PointInfoItem(PointIndex, StartPoint, LastPoint, SumIndex, deleteIndex);
|
|
|
|
for (var Index = 0; Index < Point.Items.length; Index++)
|
|
{
|
|
var Item = Point.Items[Index];
|
|
var oChanges = new AscCommon.CCollaborativeChanges();
|
|
oChanges.Set_FromUndoRedo(Item.Class, Item.Data, Item.Binary);
|
|
|
|
aChanges2.push(Item.Data);
|
|
|
|
aChanges.push(oChanges.m_pData);
|
|
}
|
|
}
|
|
|
|
var UnlockCount = 0;
|
|
|
|
// Пока пользователь сидит один, мы не чистим его локи до тех пор пока не зайдет второй
|
|
var bCollaborative = this.getCollaborativeEditing();
|
|
if (bCollaborative)
|
|
{
|
|
UnlockCount = this.m_aNeedUnlock.length;
|
|
this.Release_Locks();
|
|
|
|
var UnlockCount2 = this.m_aNeedUnlock2.length;
|
|
for (var Index = 0; Index < UnlockCount2; Index++)
|
|
{
|
|
var Class = this.m_aNeedUnlock2[Index];
|
|
Class.Lock.Set_Type(AscCommon.c_oAscLockTypes.kLockTypeNone, false);
|
|
editor.CoAuthoringApi.releaseLocks(Class.Get_Id());
|
|
}
|
|
|
|
this.m_aNeedUnlock.length = 0;
|
|
this.m_aNeedUnlock2.length = 0;
|
|
}
|
|
|
|
var deleteIndex = ( null === AscCommon.History.SavedIndex ? null : SumIndex );
|
|
if (0 < aChanges.length || null !== deleteIndex)
|
|
{
|
|
this.CoHistory.AddOwnChanges(aChanges2, deleteIndex);
|
|
editor.CoAuthoringApi.saveChanges(aChanges, deleteIndex, AdditionalInfo, editor.canUnlockDocument2, bCollaborative);
|
|
AscCommon.History.CanNotAddChanges = true;
|
|
}
|
|
else
|
|
{
|
|
editor.CoAuthoringApi.unLockDocument(!!isAfterAskSave, editor.canUnlockDocument2, null, bCollaborative);
|
|
}
|
|
editor.canUnlockDocument2 = false;
|
|
|
|
if (-1 === this.m_nUseType)
|
|
{
|
|
// Чистим Undo/Redo только во время совместного редактирования
|
|
AscCommon.History.Clear();
|
|
AscCommon.History.SavedIndex = null;
|
|
}
|
|
else if (0 === this.m_nUseType)
|
|
{
|
|
// Чистим Undo/Redo только во время совместного редактирования
|
|
AscCommon.History.Clear();
|
|
AscCommon.History.SavedIndex = null;
|
|
|
|
this.m_nUseType = 1;
|
|
}
|
|
else
|
|
{
|
|
// Обновляем точку последнего сохранения в истории
|
|
AscCommon.History.Reset_SavedIndex(IsUserSave);
|
|
}
|
|
|
|
if (false !== IsUpdateInterface)
|
|
editor.WordControl.m_oLogicDocument.UpdateInterface(undefined, true);
|
|
|
|
// TODO: Пока у нас обнуляется история на сохранении нужно обновлять Undo/Redo
|
|
editor.WordControl.m_oLogicDocument.Document_UpdateUndoRedoState();
|
|
|
|
// Свои локи не проверяем. Когда все пользователи выходят, происходит перерисовка и свои локи уже не рисуются.
|
|
if (0 !== UnlockCount || 1 !== this.m_nUseType)
|
|
{
|
|
// Перерисовываем документ (для обновления локов)
|
|
editor.WordControl.m_oLogicDocument.DrawingDocument.ClearCachePages();
|
|
editor.WordControl.m_oLogicDocument.DrawingDocument.FirePaint();
|
|
}
|
|
|
|
editor.WordControl.m_oLogicDocument.getCompositeInput().checkState();
|
|
};
|
|
CWordCollaborativeEditing.prototype.Release_Locks = function()
|
|
{
|
|
var UnlockCount = this.m_aNeedUnlock.length;
|
|
for (var Index = 0; Index < UnlockCount; Index++)
|
|
{
|
|
var CurLockType = this.m_aNeedUnlock[Index].Lock.Get_Type();
|
|
if (AscCommon.c_oAscLockTypes.kLockTypeOther3 != CurLockType && AscCommon.c_oAscLockTypes.kLockTypeOther != CurLockType)
|
|
{
|
|
this.m_aNeedUnlock[Index].Lock.Set_Type(AscCommon.c_oAscLockTypes.kLockTypeNone, false);
|
|
|
|
if (this.m_aNeedUnlock[Index] instanceof AscCommonWord.CHeaderFooterController)
|
|
editor.sync_UnLockHeaderFooters();
|
|
else if (this.m_aNeedUnlock[Index] instanceof AscCommonWord.CDocument)
|
|
editor.sync_UnLockDocumentProps();
|
|
else if (this.m_aNeedUnlock[Index] instanceof AscCommon.CComment)
|
|
editor.sync_UnLockComment(this.m_aNeedUnlock[Index].Get_Id());
|
|
else if (this.m_aNeedUnlock[Index] instanceof AscCommonWord.CGraphicObjects)
|
|
editor.sync_UnLockDocumentSchema();
|
|
else if (this.m_aNeedUnlock[Index] instanceof AscCommon.CCore)
|
|
editor.sendEvent("asc_onLockCore", false);
|
|
else if (this.m_aNeedUnlock[Index] instanceof AscCommonWord.CDocProtect)
|
|
editor.sendEvent("asc_onLockDocumentProtection", false);
|
|
}
|
|
else if (AscCommon.c_oAscLockTypes.kLockTypeOther3 === CurLockType)
|
|
{
|
|
this.m_aNeedUnlock[Index].Lock.Set_Type(AscCommon.c_oAscLockTypes.kLockTypeOther, false);
|
|
}
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype.OnEnd_Load_Objects = function()
|
|
{
|
|
// Данная функция вызывается, когда загрузились внешние объекты (картинки и шрифты)
|
|
|
|
// Снимаем лок
|
|
AscCommon.CollaborativeEditing.Set_GlobalLock(false);
|
|
AscCommon.CollaborativeEditing.Set_GlobalLockSelection(false);
|
|
|
|
if (this.m_fEndLoadCallBack)
|
|
{
|
|
this.m_fEndLoadCallBack();
|
|
this.m_fEndLoadCallBack = null;
|
|
}
|
|
|
|
var nPageIndex = undefined;
|
|
if (this.Is_Fast())
|
|
{
|
|
var oParagraph = this.m_oLogicDocument.GetCurrentParagraph();
|
|
nPageIndex = oParagraph ? Math.max(oParagraph.GetAbsoluteCurrentPage(), editor.GetCurrentVisiblePage()) : undefined;
|
|
}
|
|
|
|
this.m_oLogicDocument.ResumeRecalculate();
|
|
this.m_oLogicDocument.RecalculateByChanges(this.CoHistory.GetAllChanges(), this.m_nRecalcIndexStart, this.m_nRecalcIndexEnd, false, nPageIndex);
|
|
this.m_oLogicDocument.UpdateTracks();
|
|
|
|
let oform = this.m_oLogicDocument.GetOFormDocument();
|
|
if (oform)
|
|
oform.onEndLoadChanges();
|
|
|
|
editor.sync_EndAction(Asc.c_oAscAsyncActionType.BlockInteraction, Asc.c_oAscAsyncAction.ApplyChanges);
|
|
};
|
|
CWordCollaborativeEditing.prototype.Check_MergeData = function()
|
|
{
|
|
var LogicDocument = editor.WordControl.m_oLogicDocument;
|
|
LogicDocument.Comments.Check_MergeData();
|
|
};
|
|
CWordCollaborativeEditing.prototype.OnEnd_CheckLock = function(isDontLockInFastMode, fCallback)
|
|
{
|
|
// Если задан fCallback, тогда действие нужно выполнять именно на нём, поэотому возвращаемое значение true
|
|
|
|
var aIds = [];
|
|
for (var nIndex = 0, nCount = this.m_aCheckLocks.length; nIndex < nCount; ++nIndex)
|
|
{
|
|
var oItem = this.m_aCheckLocks[nIndex];
|
|
|
|
if (true === oItem) // сравниваем по значению и типу обязательно
|
|
{
|
|
if (fCallback)
|
|
fCallback(true);
|
|
|
|
return true;
|
|
}
|
|
else if (false !== oItem)
|
|
{
|
|
aIds.push(oItem);
|
|
}
|
|
}
|
|
|
|
if ((true === isDontLockInFastMode && true === this.Is_Fast()) || !this.canSendChanges())
|
|
{
|
|
if (fCallback)
|
|
{
|
|
fCallback(false);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (fCallback)
|
|
{
|
|
if (aIds.length > 0)
|
|
{
|
|
var oThis = this;
|
|
editor.CoAuthoringApi.askLock(aIds, function(result)
|
|
{
|
|
oThis.Set_GlobalLock(false);
|
|
|
|
if (result["lock"])
|
|
{
|
|
oThis.private_LockByMe();
|
|
fCallback(false);
|
|
}
|
|
else if (result["error"])
|
|
{
|
|
fCallback(true);
|
|
}
|
|
});
|
|
|
|
this.Set_GlobalLock(true);
|
|
}
|
|
else
|
|
{
|
|
fCallback(false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (aIds.length > 0)
|
|
{
|
|
// Отправляем запрос на сервер со списком Id
|
|
editor.CoAuthoringApi.askLock(aIds, this.OnCallback_AskLock);
|
|
|
|
// Ставим глобальный лок, только во время совместного редактирования
|
|
if (-1 === this.m_nUseType)
|
|
{
|
|
this.Set_GlobalLock(true);
|
|
}
|
|
else
|
|
{
|
|
this.private_LockByMe();
|
|
this.m_aCheckLocks.length = 0;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype.private_LockByMe = function()
|
|
{
|
|
for (var nIndex = 0, nCount = this.m_aCheckLocks.length; nIndex < nCount; ++nIndex)
|
|
{
|
|
var oItem = this.m_aCheckLocks[nIndex];
|
|
if (true !== oItem && false !== oItem) // сравниваем по значению и типу обязательно
|
|
{
|
|
var oClass = AscCommon.g_oTableId.Get_ById(oItem);
|
|
if (oClass)
|
|
{
|
|
oClass.Lock.Set_Type(AscCommon.c_oAscLockTypes.kLockTypeMine);
|
|
this.Add_Unlock2(oClass);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype.OnCallback_AskLock = function(result)
|
|
{
|
|
var oThis = AscCommon.CollaborativeEditing;
|
|
var oEditor = editor;
|
|
|
|
if (true === oThis.Get_GlobalLock())
|
|
{
|
|
// Здесь проверяем есть ли длинная операция, если она есть, то до ее окончания нельзя делать
|
|
// Undo, иначе точка истории уберется, а изменения допишутся в предыдущую.
|
|
if (false == oEditor.checkLongActionCallback(oThis.OnCallback_AskLock, result))
|
|
return;
|
|
|
|
// Снимаем глобальный лок
|
|
oThis.Set_GlobalLock(false);
|
|
|
|
if (result["lock"])
|
|
{
|
|
oThis.private_LockByMe();
|
|
}
|
|
else if (result["error"])
|
|
{
|
|
// Если у нас началось редактирование диаграммы, а вернулось, что ее редактировать нельзя,
|
|
// посылаем сообщение о закрытии редактора диаграмм.
|
|
if (oEditor.frameManager.isLoadingChartEditor)
|
|
oEditor.sync_closeChartEditor();
|
|
|
|
if (oEditor.frameManager.isLoadingOleEditor)
|
|
oEditor.sync_closeOleEditor();
|
|
|
|
// Делаем откат на 1 шаг назад и удаляем из Undo/Redo эту последнюю точку
|
|
oEditor.WordControl.m_oLogicDocument.Document_Undo();
|
|
AscCommon.History.Clear_Redo();
|
|
}
|
|
|
|
oEditor.frameManager.endLoadChartEditor();
|
|
oEditor.frameManager.endLoadOleEditor();
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype.AddContentControlForSkippingOnCheckEditingLock = function(oContentControl)
|
|
{
|
|
this.m_aSkipContentControlsOnCheckEditingLock[oContentControl.GetId()] = oContentControl;
|
|
};
|
|
CWordCollaborativeEditing.prototype.RemoveContentControlForSkippingOnCheckEditingLock = function(oContentControl)
|
|
{
|
|
delete this.m_aSkipContentControlsOnCheckEditingLock[oContentControl.GetId()];
|
|
};
|
|
CWordCollaborativeEditing.prototype.IsNeedToSkipContentControlOnCheckEditingLock = function(oContentControl)
|
|
{
|
|
if (this.m_aSkipContentControlsOnCheckEditingLock[oContentControl.GetId()] === oContentControl)
|
|
return true;
|
|
|
|
return false;
|
|
};
|
|
CWordCollaborativeEditing.prototype.Start_CollaborationEditing = function()
|
|
{
|
|
this.m_nUseType = -1;
|
|
};
|
|
CWordCollaborativeEditing.prototype.End_CollaborationEditing = function()
|
|
{
|
|
if (this.m_nUseType <= 0)
|
|
{
|
|
if (this.m_oLogicDocument && !this.m_oLogicDocument.GetHistory().Have_Changes() && !this.Have_OtherChanges())
|
|
this.m_nUseType = 1;
|
|
else
|
|
this.m_nUseType = 0;
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype._PreUndo = function()
|
|
{
|
|
let logicDocument = this.m_oLogicDocument;
|
|
|
|
logicDocument.DrawingDocument.EndTrackTable(null, true);
|
|
logicDocument.TurnOffCheckChartSelection();
|
|
|
|
return this.private_SaveDocumentState()
|
|
};
|
|
CWordCollaborativeEditing.prototype._PostUndo = function(state, changes)
|
|
{
|
|
this.private_RestoreDocumentState(state);
|
|
this.private_RecalculateDocument(changes);
|
|
|
|
let logicDocument = this.m_oLogicDocument;
|
|
logicDocument.TurnOnCheckChartSelection();
|
|
logicDocument.UpdateSelection();
|
|
logicDocument.UpdateInterface();
|
|
logicDocument.UpdateRulers();
|
|
};
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// Функции для работы с сохраненными позициями документа.
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
CWordCollaborativeEditing.prototype.Remove_ForeignCursor = function(UserId)
|
|
{
|
|
AscCommon.CCollaborativeEditingBase.prototype.Remove_ForeignCursor.call(this, UserId);
|
|
var DrawingDocument = this.m_oLogicDocument.DrawingDocument;
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
this.Remove_ForeignCursorXY(UserId);
|
|
this.Remove_ForeignCursorToShow(UserId);
|
|
};
|
|
CWordCollaborativeEditing.prototype.Update_ForeignCursorsPositions = function()
|
|
{
|
|
for (var UserId in this.m_aForeignCursors)
|
|
{
|
|
var DocPos = this.m_aForeignCursors[UserId];
|
|
if (!DocPos || DocPos.length <= 0)
|
|
continue;
|
|
|
|
this.m_aForeignCursorsPos.Update_DocumentPosition(DocPos);
|
|
|
|
var Run = DocPos[DocPos.length - 1].Class;
|
|
var InRunPos = DocPos[DocPos.length - 1].Position;
|
|
|
|
this.Update_ForeignCursorPosition(UserId, Run, InRunPos, false);
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype.Update_ForeignCursorPosition = function(UserId, Run, InRunPos, isRemoveLabel)
|
|
{
|
|
var DrawingDocument = this.m_oLogicDocument.DrawingDocument;
|
|
|
|
if (!(Run instanceof AscCommonWord.ParaRun))
|
|
return;
|
|
|
|
var Paragraph = Run.GetParagraph();
|
|
|
|
if (!Paragraph)
|
|
{
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
return;
|
|
}
|
|
|
|
var ParaContentPos = Paragraph.Get_PosByElement(Run);
|
|
if (!ParaContentPos)
|
|
{
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
return;
|
|
}
|
|
ParaContentPos.Update(InRunPos, ParaContentPos.GetDepth() + 1);
|
|
|
|
var XY = Paragraph.Get_XYByContentPos(ParaContentPos);
|
|
if (XY && XY.Height > 0.001)
|
|
{
|
|
var ShortId = this.m_aForeignCursorsId[UserId] ? this.m_aForeignCursorsId[UserId] : UserId;
|
|
DrawingDocument.Collaborative_UpdateTarget(UserId, ShortId, XY.X, XY.Y, XY.Height, XY.PageNum, Paragraph.Get_ParentTextTransform());
|
|
this.Add_ForeignCursorXY(UserId, XY.X, XY.Y, XY.PageNum, XY.Height, Paragraph, isRemoveLabel);
|
|
|
|
if (true === this.m_aForeignCursorsToShow[UserId])
|
|
{
|
|
this.Show_ForeignCursorLabel(UserId);
|
|
this.Remove_ForeignCursorToShow(UserId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
this.Remove_ForeignCursorXY(UserId);
|
|
this.Remove_ForeignCursorToShow(UserId);
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype.OnEnd_ReadForeignChanges = function()
|
|
{
|
|
AscCommon.CCollaborativeEditingBase.prototype.OnEnd_ReadForeignChanges.apply(this, arguments);
|
|
|
|
if (this.m_oLogicDocument && this.m_oLogicDocument.GetApi())
|
|
{
|
|
var oApi = this.m_oLogicDocument.GetApi();
|
|
if (this.m_oLogicDocument.GetBookmarksManager().IsNeedUpdate())
|
|
{
|
|
oApi.asc_OnBookmarksUpdate();
|
|
}
|
|
|
|
if (this.m_oLogicDocument && this.m_oLogicDocument.ClearListsCache)
|
|
this.m_oLogicDocument.ClearListsCache();
|
|
|
|
if (this.m_oLogicDocument && this.m_oLogicDocument.Settings && this.m_oLogicDocument.Settings.DocumentProtection)
|
|
{
|
|
let updateFromUser = this.m_oLogicDocument.Settings.DocumentProtection.GetNeedUpdate();
|
|
if (updateFromUser) {
|
|
oApi.asc_OnProtectionUpdate(updateFromUser);
|
|
this.m_oLogicDocument.Settings.DocumentProtection.SetNeedUpdate(null);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CWordCollaborativeEditing.prototype.private_RecalculateDocument = function(arrChanges)
|
|
{
|
|
this.m_oLogicDocument.RecalculateByChanges(arrChanges);
|
|
};
|
|
CWordCollaborativeEditing.prototype.private_UpdateForeignCursor = function(CursorInfo, UserId, Show, UserShortId)
|
|
{
|
|
this.m_oLogicDocument.Update_ForeignCursor(CursorInfo, UserId, Show, UserShortId);
|
|
};
|
|
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
window['AscCommon'] = window['AscCommon'] || {};
|
|
window['AscCommon'].CWordCollaborativeEditing = CWordCollaborativeEditing;
|