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;
|