Yajbir Singh
647 lines
23 KiB
JavaScript
647 lines
23 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 CCollaborativeEditing()
|
|
{
|
|
AscCommon.CCollaborativeEditingBase.call(this);
|
|
this.PosExtChangesX = [];
|
|
this.PosExtChangesY = [];
|
|
this.ScaleX = null;
|
|
this.ScaleY = null;
|
|
}
|
|
|
|
CCollaborativeEditing.prototype = Object.create(AscCommon.CCollaborativeEditingBase.prototype);
|
|
CCollaborativeEditing.prototype.constructor = CCollaborativeEditing;
|
|
|
|
CCollaborativeEditing.prototype.GetEditorApi = function()
|
|
{
|
|
return Asc.editor;
|
|
};
|
|
CCollaborativeEditing.prototype.GetDrawingDocument = function()
|
|
{
|
|
return Asc.editor.getDrawingDocument();
|
|
};
|
|
CCollaborativeEditing.prototype.GetPresentation = function()
|
|
{
|
|
return Asc.editor.private_GetLogicDocument();
|
|
};
|
|
CCollaborativeEditing.prototype.Send_Changes = function(IsUserSave, AdditionalInfo, IsUpdateInterface, isAfterAskSave)
|
|
{
|
|
// Пересчитываем позиции
|
|
this.Refresh_DCChanges();
|
|
this.RefreshPosExtChanges();
|
|
// Генерируем свои изменения
|
|
let StartPoint = ( null === AscCommon.History.SavedIndex ? 0 : AscCommon.History.SavedIndex + 1 );
|
|
let LastPoint = -1;
|
|
if ( this.m_nUseType <= 0 )
|
|
{
|
|
// (ненужные точки предварительно удаляем)
|
|
AscCommon.History.Clear_Redo();
|
|
LastPoint = AscCommon.History.Points.length - 1;
|
|
}
|
|
else
|
|
{
|
|
LastPoint = AscCommon.History.Index;
|
|
}
|
|
// Просчитаем сколько изменений на сервер пересылать не надо
|
|
let SumIndex = 0;
|
|
let StartPoint2 = Math.min( StartPoint, LastPoint + 1 );
|
|
for ( let PointIndex = 0; PointIndex < StartPoint2; PointIndex++ )
|
|
{
|
|
let Point = AscCommon.History.Points[PointIndex];
|
|
SumIndex += Point.Items.length;
|
|
}
|
|
let deleteIndex = ( null === AscCommon.History.SavedIndex ? null : SumIndex );
|
|
|
|
let aChanges = [], aChanges2 = [];
|
|
for ( let PointIndex = StartPoint; PointIndex <= LastPoint; PointIndex++ )
|
|
{
|
|
let Point = AscCommon.History.Points[PointIndex];
|
|
|
|
AscCommon.History.Update_PointInfoItem(PointIndex, StartPoint, LastPoint, SumIndex, deleteIndex);
|
|
for ( let Index = 0; Index < Point.Items.length; Index++ )
|
|
{
|
|
let Item = Point.Items[Index];
|
|
let oChanges = new AscCommon.CCollaborativeChanges();
|
|
oChanges.Set_FromUndoRedo( Item.Class, Item.Data, Item.Binary );
|
|
aChanges2.push(Item.Data);
|
|
aChanges.push( oChanges.m_pData );
|
|
}
|
|
}
|
|
|
|
|
|
// Пока пользователь сидит один, мы не чистим его локи до тех пор пока не зайдет второй
|
|
let bCollaborative = this.getCollaborativeEditing();
|
|
|
|
let num_arr = [];
|
|
let drawingDocument = this.GetDrawingDocument();
|
|
let presentation = this.GetPresentation();
|
|
if (bCollaborative)
|
|
{
|
|
let map = this.Release_Locks();
|
|
|
|
let UnlockCount2 = this.m_aNeedUnlock2.length;
|
|
for (let Index = 0; Index < UnlockCount2; Index++ )
|
|
{
|
|
let Class = this.m_aNeedUnlock2[Index];
|
|
Class.Lock.Set_Type( AscCommon.c_oAscLockTypes.kLockTypeNone, false);
|
|
if(Class instanceof AscCommon.CCore)
|
|
{
|
|
Asc.editor.sendEvent("asc_onLockCore", false);
|
|
}
|
|
|
|
let check_obj = null;
|
|
if(Class.getObjectType)
|
|
{
|
|
if(Class.isDrawing && AscCommon.isRealObject(Class.parent))
|
|
{
|
|
let nParentNum = Class.getParentNum();
|
|
if(nParentNum !== -1)
|
|
{
|
|
|
|
map[nParentNum] = true;
|
|
}
|
|
|
|
check_obj =
|
|
{
|
|
"type": c_oAscLockTypeElemPresentation.Object,
|
|
"slideId": Class.parent.Get_Id(),
|
|
"objId": Class.Get_Id(),
|
|
"guid": Class.Get_Id()
|
|
};
|
|
}
|
|
else if(AscFormat.isSlideLikeObject(Class))
|
|
{
|
|
check_obj =
|
|
{
|
|
"type": c_oAscLockTypeElemPresentation.Slide,
|
|
"val": Class.Get_Id(),
|
|
"guid": Class.Get_Id()
|
|
};
|
|
}
|
|
else if(Class instanceof AscCommon.CComment){
|
|
if(Class.Parent && Class.Parent.slide){
|
|
if(Class.Parent.slide === presentation){
|
|
check_obj =
|
|
{
|
|
"type": c_oAscLockTypeElemPresentation.Slide,
|
|
"val": presentation.commentsLock.Get_Id(),
|
|
"guid": presentation.commentsLock.Get_Id()
|
|
};
|
|
}
|
|
else {
|
|
if(Class.Parent.slide.deleteLock){
|
|
check_obj =
|
|
{
|
|
"type": c_oAscLockTypeElemPresentation.Object,
|
|
"slideId": Class.Parent.slide.deleteLock.Get_Id(),
|
|
"objId": Class.Get_Id(),
|
|
"guid": Class.Get_Id()
|
|
};
|
|
map[Class.Parent.slide.num] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(check_obj)
|
|
Asc.editor.CoAuthoringApi.releaseLocks( check_obj );
|
|
}
|
|
}
|
|
|
|
|
|
if(Asc.editor.WordControl.m_oDrawingDocument.IsLockObjectsEnable)
|
|
{
|
|
for(let key in map)
|
|
{
|
|
if(map.hasOwnProperty(key))
|
|
{
|
|
num_arr.push(parseInt(key, 10));
|
|
}
|
|
}
|
|
num_arr.sort(AscCommon.fSortAscending);
|
|
}
|
|
this.m_aNeedUnlock.length = 0;
|
|
this.m_aNeedUnlock2.length = 0;
|
|
}
|
|
|
|
if (0 < aChanges.length || null !== deleteIndex)
|
|
{
|
|
this.CoHistory.AddOwnChanges(aChanges2, deleteIndex);
|
|
Asc.editor.CoAuthoringApi.saveChanges(aChanges, deleteIndex, AdditionalInfo, editor.canUnlockDocument2, bCollaborative);
|
|
AscCommon.History.CanNotAddChanges = true;
|
|
} else
|
|
Asc.editor.CoAuthoringApi.unLockDocument(!!isAfterAskSave, editor.canUnlockDocument2, null, bCollaborative);
|
|
Asc.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);
|
|
}
|
|
|
|
for(let i = 0; i < num_arr.length; ++i)
|
|
{
|
|
Asc.editor.WordControl.m_oDrawingDocument.OnRecalculateSlide(num_arr[i]);
|
|
}
|
|
if(num_arr.length > 0)
|
|
{
|
|
Asc.editor.WordControl.m_oDrawingDocument.OnEndRecalculate();
|
|
}
|
|
let oSlide = presentation.GetCurrentSlide();
|
|
if(oSlide && oSlide.notesShape){
|
|
Asc.editor.WordControl.m_oDrawingDocument.Notes_OnRecalculate(presentation.CurPage, oSlide.NotesWidth, oSlide.getNotesHeight());
|
|
}
|
|
presentation.Document_UpdateInterfaceState();
|
|
presentation.Document_UpdateUndoRedoState();
|
|
|
|
// drawingDocument.ClearCachePages();
|
|
// drawingDocument.FirePaint();
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.Release_Locks = function()
|
|
{
|
|
let map_redraw = {};
|
|
let UnlockCount = this.m_aNeedUnlock.length;
|
|
let presentation = this.GetPresentation();
|
|
for ( let Index = 0; Index < UnlockCount; Index++ )
|
|
{
|
|
let CurLockType = this.m_aNeedUnlock[Index].Lock.Get_Type();
|
|
let Class = this.m_aNeedUnlock[Index];
|
|
if ( AscCommon.c_oAscLockTypes.kLockTypeOther3 != CurLockType && AscCommon.c_oAscLockTypes.kLockTypeOther != CurLockType )
|
|
{
|
|
Class.Lock.Set_Type( AscCommon.c_oAscLockTypes.kLockTypeNone, false);
|
|
if ( Class instanceof AscCommonSlide.PropLocker )
|
|
{
|
|
let object = AscCommon.g_oTableId.Get_ById(Class.objectId);
|
|
if(object instanceof AscCommonSlide.CPresentation)
|
|
{
|
|
if(Class === presentation.themeLock)
|
|
{
|
|
Asc.editor.sendEvent("asc_onUnLockDocumentTheme");
|
|
}
|
|
else if(Class === presentation.schemeLock)
|
|
{
|
|
Asc.editor.sendEvent("asc_onUnLockDocumentSchema");
|
|
}
|
|
else if(Class === presentation.slideSizeLock)
|
|
{
|
|
Asc.editor.sendEvent("asc_onUnLockDocumentProps");
|
|
}
|
|
else if(Class === presentation.viewPrLock)
|
|
{
|
|
Asc.editor.sendEvent("asc_onUnLockViewProps");
|
|
}
|
|
else if (Class === presentation.hdrFtrLock)
|
|
{
|
|
Asc.editor.sendEvent("asc_onUnLockSlideHdrFtrApplyToAll");
|
|
}
|
|
}
|
|
}
|
|
if(Class instanceof AscCommon.CComment)
|
|
{
|
|
Asc.editor.sync_UnLockComment(Class.Get_Id());
|
|
if(Class.Parent && Class.Parent.slide && presentation !== Class.Parent.slide)
|
|
{
|
|
map_redraw[Class.Parent.slide.num] = true;
|
|
}
|
|
}
|
|
if(Class instanceof AscCommon.CCore)
|
|
{
|
|
Asc.editor.sendEvent("asc_onLockCore", false);
|
|
}
|
|
}
|
|
else if ( AscCommon.c_oAscLockTypes.kLockTypeOther3 === CurLockType )
|
|
{
|
|
Class.Lock.Set_Type( AscCommon.c_oAscLockTypes.kLockTypeOther, false);
|
|
}
|
|
if(Class.isDrawing)
|
|
{
|
|
let nIdx = Class.getParentNum();
|
|
if(nIdx !== -1)
|
|
{
|
|
map_redraw[nIdx] = true;
|
|
}
|
|
}
|
|
}
|
|
return map_redraw;
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.OnEnd_Load_Objects = function()
|
|
{
|
|
// Данная функция вызывается, когда загрузились внешние объекты (картинки и шрифты)
|
|
|
|
// Снимаем лок
|
|
AscCommon.CollaborativeEditing.Set_GlobalLock(false);
|
|
AscCommon.CollaborativeEditing.Set_GlobalLockSelection(false);
|
|
|
|
// Запускаем полный пересчет документа
|
|
let LogicDocument = this.GetPresentation();
|
|
|
|
const arrChanges = this.CoHistory.GetAllChanges();
|
|
const oRecalcData = LogicDocument.History.Get_RecalcData(null, arrChanges, this.m_nRecalcIndexStart, this.m_nRecalcIndexEnd);
|
|
LogicDocument.Recalculate(oRecalcData);
|
|
LogicDocument.Document_UpdateSelectionState();
|
|
LogicDocument.Document_UpdateInterfaceState();
|
|
|
|
Asc.editor.sync_EndAction(Asc.c_oAscAsyncActionType.BlockInteraction, Asc.c_oAscAsyncAction.ApplyChanges);
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.OnEnd_CheckLock = function(DontLockInFastMode)
|
|
{
|
|
let drawingDocument = this.GetDrawingDocument();
|
|
let aIds = [];
|
|
let Count = this.m_aCheckLocks.length;
|
|
for ( let Index = 0; Index < Count; Index++ )
|
|
{
|
|
let oItem = this.m_aCheckLocks[Index];
|
|
|
|
if ( true === oItem ) // сравниваем по значению и типу обязательно
|
|
return true;
|
|
else if ( false !== oItem )
|
|
aIds.push( oItem );
|
|
}
|
|
|
|
|
|
if (true === DontLockInFastMode && true === this.Is_Fast())
|
|
return false;
|
|
|
|
if ( aIds.length > 0 )
|
|
{
|
|
// Отправляем запрос на сервер со списком Id
|
|
Asc.editor.CoAuthoringApi.askLock( aIds, this.OnCallback_AskLock );
|
|
|
|
// Ставим глобальный лок, только во время совместного редактирования
|
|
if ( -1 === this.m_nUseType )
|
|
{
|
|
this.Set_GlobalLock(true);
|
|
}
|
|
else
|
|
{
|
|
// Пробегаемся по массиву и проставляем, что залочено нами
|
|
Count = this.m_aCheckLocks.length;
|
|
for ( let Index = 0; Index < Count; Index++ )
|
|
{
|
|
let oItem = this.m_aCheckLocks[Index];
|
|
let items = [];
|
|
switch(oItem["type"])
|
|
{
|
|
case c_oAscLockTypeElemPresentation.Object:
|
|
{
|
|
items.push(oItem["objId"]);
|
|
items.push(oItem["slideId"]);
|
|
break;
|
|
}
|
|
case c_oAscLockTypeElemPresentation.Slide:
|
|
{
|
|
items.push(oItem["val"]);
|
|
break;
|
|
}
|
|
case c_oAscLockTypeElemPresentation.Presentation:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(let i = 0; i < items.length; ++i)
|
|
{
|
|
let item = items[i];
|
|
if ( true !== item && false !== item ) // сравниваем по значению и типу обязательно
|
|
{
|
|
let Class = AscCommon.g_oTableId.Get_ById( item );
|
|
if ( null != Class )
|
|
{
|
|
Class.Lock.Set_Type( AscCommon.c_oAscLockTypes.kLockTypeMine, false );
|
|
this.Add_Unlock2( Class );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.m_aCheckLocks.length = 0;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
CCollaborativeEditing.prototype.OnCallback_AskLock = function(result)
|
|
{
|
|
let presentation = AscCommon.CollaborativeEditing.GetPresentation();
|
|
if (true === AscCommon.CollaborativeEditing.Get_GlobalLock())
|
|
{
|
|
if (!Asc.editor.checkLongActionCallback(AscCommon.CollaborativeEditing.OnCallback_AskLock, result))
|
|
return;
|
|
|
|
// Снимаем глобальный лок
|
|
AscCommon.CollaborativeEditing.Set_GlobalLock(false);
|
|
|
|
if (result["lock"])
|
|
{
|
|
// Пробегаемся по массиву и проставляем, что залочено нами
|
|
|
|
let Count = AscCommon.CollaborativeEditing.m_aCheckLocks.length;
|
|
for ( let Index = 0; Index < Count; Index++ )
|
|
{
|
|
let oItem = AscCommon.CollaborativeEditing.m_aCheckLocks[Index];
|
|
let item;
|
|
switch(oItem["type"])
|
|
{
|
|
case c_oAscLockTypeElemPresentation.Object:
|
|
{
|
|
item = oItem["objId"];
|
|
break;
|
|
}
|
|
case c_oAscLockTypeElemPresentation.Slide:
|
|
{
|
|
item = oItem["val"];
|
|
break;
|
|
}
|
|
case c_oAscLockTypeElemPresentation.Presentation:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if ( true !== oItem && false !== oItem ) // сравниваем по значению и типу обязательно
|
|
{
|
|
let Class = AscCommon.g_oTableId.Get_ById( item );
|
|
if ( null != Class )
|
|
{
|
|
Class.Lock.Set_Type( AscCommon.c_oAscLockTypes.kLockTypeMine );
|
|
AscCommon.CollaborativeEditing.Add_Unlock2( Class );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (result["error"])
|
|
{
|
|
// Если у нас началось редактирование диаграммы, а вернулось, что ее редактировать нельзя,
|
|
// посылаем сообщение о закрытии редактора диаграмм.
|
|
if (Asc.editor.frameManager.isLoadingChartEditor)
|
|
Asc.editor.sync_closeChartEditor();
|
|
|
|
if (Asc.editor.frameManager.isLoadingOleEditor)
|
|
Asc.editor.sync_closeOleEditor();
|
|
|
|
// Делаем откат на 1 шаг назад и удаляем из Undo/Redo эту последнюю точку
|
|
presentation.Document_Undo();
|
|
AscCommon.History.Clear_Redo();
|
|
}
|
|
|
|
}
|
|
Asc.editor.frameManager.endLoadChartEditor();
|
|
Asc.editor.frameManager.endLoadOleEditor();
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.AddPosExtChanges = function(Item, ChangeObject)
|
|
{
|
|
if(ChangeObject.IsHorizontal())
|
|
{
|
|
this.PosExtChangesX.push(Item);
|
|
}
|
|
else
|
|
{
|
|
this.PosExtChangesY.push(Item);
|
|
}
|
|
};
|
|
|
|
|
|
CCollaborativeEditing.prototype.RewritePosExtChanges = function(changesArr, scale)
|
|
{
|
|
for(let i = 0; i < changesArr.length; ++i)
|
|
{
|
|
let changes = changesArr[i];
|
|
let data = changes.Data;
|
|
data.New *= scale;
|
|
data.Old *= scale;
|
|
let Binary_Writer = AscCommon.History.BinaryWriter;
|
|
let Binary_Pos = Binary_Writer.GetCurPosition();
|
|
if (Asc.editor.binaryChanges) {
|
|
Binary_Writer.WriteWithLen(this, function () {
|
|
Binary_Writer.WriteString2(changes.Class.Get_Id());
|
|
Binary_Writer.WriteLong(changes.Data.Type);
|
|
changes.Data.WriteToBinary(Binary_Writer);
|
|
});
|
|
} else {
|
|
Binary_Writer.WriteString2(changes.Class.Get_Id());
|
|
Binary_Writer.WriteLong(changes.Data.Type);
|
|
changes.Data.WriteToBinary(Binary_Writer);
|
|
}
|
|
|
|
let Binary_Len = Binary_Writer.GetCurPosition() - Binary_Pos;
|
|
|
|
changes.Binary.Pos = Binary_Pos;
|
|
changes.Binary.Len = Binary_Len;
|
|
}
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.RefreshPosExtChanges = function()
|
|
{
|
|
if(this.ScaleX != null && this.ScaleY != null)
|
|
{
|
|
this.RewritePosExtChanges(this.PosExtChangesX, this.ScaleX);
|
|
this.RewritePosExtChanges(this.PosExtChangesY, this.ScaleY);
|
|
}
|
|
this.PosExtChangesX.length = 0;
|
|
this.PosExtChangesY.length = 0;
|
|
this.ScaleX = null;
|
|
this.ScaleY = null;
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.Update_ForeignCursorsPositions = function()
|
|
{
|
|
let DrawingDocument = this.GetDrawingDocument();
|
|
let oPresentation = this.GetPresentation();
|
|
let oTargetDocContentOrTable;
|
|
let oCurController = oPresentation.GetCurrentController();
|
|
if(oCurController){
|
|
oTargetDocContentOrTable = oCurController.getTargetDocContent(undefined, true);
|
|
}
|
|
if(!oTargetDocContentOrTable){
|
|
for (let UserId in this.m_aForeignCursors){
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
}
|
|
return;
|
|
}
|
|
let bTable = (oTargetDocContentOrTable instanceof AscCommonWord.CTable);
|
|
for (let UserId in this.m_aForeignCursors){
|
|
let DocPos = this.m_aForeignCursors[UserId];
|
|
if (!DocPos || DocPos.length <= 0)
|
|
continue;
|
|
|
|
this.m_aForeignCursorsPos.Update_DocumentPosition(DocPos);
|
|
|
|
let Run = DocPos[DocPos.length - 1].Class;
|
|
let InRunPos = DocPos[DocPos.length - 1].Position;
|
|
this.Update_ForeignCursorPosition(UserId, Run, InRunPos, false, oTargetDocContentOrTable, bTable);
|
|
}
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.Update_ForeignCursorPosition = function(UserId, Run, InRunPos, isRemoveLabel, oTargetDocContentOrTable, bTable){
|
|
if (!(Run instanceof AscCommonWord.ParaRun))
|
|
return;
|
|
|
|
let DrawingDocument = this.GetDrawingDocument();
|
|
let oPresentation = this.GetPresentation();
|
|
let Paragraph = Run.GetParagraph();
|
|
if (!Paragraph || !Paragraph.Parent){
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
return;
|
|
}
|
|
|
|
if(!bTable){
|
|
if(oTargetDocContentOrTable !== Paragraph.Parent){
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
return;
|
|
}
|
|
}
|
|
else{
|
|
if(!Paragraph.Parent.Parent || !Paragraph.Parent.Parent.Row ||
|
|
!Paragraph.Parent.Parent.Row.Table || Paragraph.Parent.Parent.Row.Table !== oTargetDocContentOrTable){
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
return;
|
|
}
|
|
}
|
|
|
|
let ParaContentPos = Paragraph.Get_PosByElement(Run);
|
|
if (!ParaContentPos){
|
|
DrawingDocument.Collaborative_RemoveTarget(UserId);
|
|
return;
|
|
}
|
|
ParaContentPos.Update(InRunPos, ParaContentPos.GetDepth() + 1);
|
|
let XY = Paragraph.Get_XYByContentPos(ParaContentPos);
|
|
if (XY && XY.Height > 0.001){
|
|
let ShortId = this.m_aForeignCursorsId[UserId] ? this.m_aForeignCursorsId[UserId] : UserId;
|
|
DrawingDocument.Collaborative_UpdateTarget(UserId, ShortId, XY.X, XY.Y, XY.Height, oPresentation.CurPage, 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);
|
|
}
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.private_RecalculateDocument = function(arrChanges){
|
|
this.GetPresentation().Recalculate(AscCommon.History.Get_RecalcData(null, arrChanges));
|
|
};
|
|
|
|
CCollaborativeEditing.prototype.private_UpdateForeignCursor = function(CursorInfo, UserId, Show, UserShortId)
|
|
{
|
|
this.GetPresentation().Update_ForeignCursor(CursorInfo, UserId, Show, UserShortId);
|
|
};
|
|
CCollaborativeEditing.prototype._PreUndo = function() {
|
|
let logicDocument = this.m_oLogicDocument;
|
|
|
|
logicDocument.DrawingDocument.EndTrackTable(null, true);
|
|
logicDocument.TurnOffCheckChartSelection();
|
|
|
|
return this.private_SaveDocumentState();
|
|
};
|
|
CCollaborativeEditing.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();
|
|
};
|
|
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
window['AscCommon'] = window['AscCommon'] || {};
|
|
window['AscCommon'].SlideCollaborativeEditing = CCollaborativeEditing;
|