1311 lines
40 KiB
JavaScript
1311 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, undefined)
|
||
{
|
||
const FLAG_MATH = 0x0001;
|
||
const FLAG_SHAPE = 0x0002;
|
||
const FLAG_TABLE = 0x0004;
|
||
const FLAG_NOT_PARAGRAPH = 0x0008; // Есть не параграф в массиве
|
||
|
||
/**
|
||
* Класс, используемый для вставки или переноса содержимого внутри документа
|
||
* @constructor
|
||
*/
|
||
function CSelectedContent()
|
||
{
|
||
this.Elements = [];
|
||
this.Flags = 0;
|
||
|
||
this.DrawingObjects = [];
|
||
this.Comments = [];
|
||
this.CommentsMarks = {};
|
||
this.Maths = [];
|
||
this.PermRangeMarks = [];
|
||
|
||
this.LogicDocument = null;
|
||
|
||
this.NewCommentsGuid = false;
|
||
this.SaveNumberingValues = false;
|
||
this.CopyComments = true;
|
||
this.MoveDrawing = false; // Только для переноса автофигур
|
||
this.ForceInline = false;
|
||
this.CursorInLastRun = false; // TODO: Данный флаг не работает для формул и неинлайновой вставки
|
||
|
||
this.InsertOptions = {
|
||
Table : Asc.c_oSpecialPasteProps.overwriteCells
|
||
};
|
||
|
||
// Опции для отслеживания переноса
|
||
this.TrackRevisions = false;
|
||
this.MoveTrackId = null;
|
||
this.MoveTrackRuns = [];
|
||
this.HaveMovedParts = false;
|
||
|
||
this.LastSection = null;
|
||
|
||
this.AnchorPos = null;
|
||
this.Select = true;
|
||
this.ParaAnchorPos = null;
|
||
this.Run = null;
|
||
this.PasteHelper = null;
|
||
|
||
this.IsPresentationContent = false;
|
||
}
|
||
|
||
CSelectedContent.prototype.Reset = function()
|
||
{
|
||
this.Elements = [];
|
||
this.Flags = 0;
|
||
|
||
this.DrawingObjects = [];
|
||
this.Comments = [];
|
||
this.Maths = [];
|
||
this.PermRangeMarks = [];
|
||
|
||
|
||
this.MoveDrawing = false;
|
||
};
|
||
CSelectedContent.prototype.Add = function(oElement)
|
||
{
|
||
this.Elements.push(oElement);
|
||
};
|
||
CSelectedContent.prototype.GetContentArray = function()
|
||
{
|
||
let content = [];
|
||
for (let i = 0, count = this.Elements.length; i < count; ++i)
|
||
{
|
||
content.push(this.Elements[i].Element);
|
||
}
|
||
return content;
|
||
};
|
||
CSelectedContent.prototype.EndCollect = function(oLogicDocument)
|
||
{
|
||
this.private_CollectObjects();
|
||
this.private_CheckComments(oLogicDocument);
|
||
this.private_CheckTrackMove(oLogicDocument);
|
||
this.private_CheckPermRangeMarks(oLogicDocument);
|
||
};
|
||
CSelectedContent.prototype.SetNewCommentsGuid = function(isNew)
|
||
{
|
||
this.NewCommentsGuid = isNew;
|
||
};
|
||
CSelectedContent.prototype.SetMoveDrawing = function(isMoveDrawing)
|
||
{
|
||
this.MoveDrawing = isMoveDrawing;
|
||
};
|
||
CSelectedContent.prototype.IsMoveDrawing = function()
|
||
{
|
||
return this.MoveDrawing;
|
||
};
|
||
CSelectedContent.prototype.SetCopyComments = function(isCopy)
|
||
{
|
||
this.CopyComments = isCopy;
|
||
};
|
||
CSelectedContent.prototype.CanConvertToMath = function()
|
||
{
|
||
// Проверка возможности конвертации имеющегося контента в контент для вставки в формулу
|
||
// Если формулы уже имеются, то ничего не конвертируем
|
||
return !(this.Flags & FLAG_NOT_PARAGRAPH);
|
||
};
|
||
CSelectedContent.prototype.ForceInlineInsert = function(isForce)
|
||
{
|
||
this.ForceInline = undefined === isForce ? true : !!isForce;
|
||
};
|
||
CSelectedContent.prototype.HaveShape = function()
|
||
{
|
||
return !!(this.Flags & FLAG_SHAPE);
|
||
};
|
||
CSelectedContent.prototype.HaveMath = function()
|
||
{
|
||
return !!(this.Flags & FLAG_MATH);
|
||
};
|
||
CSelectedContent.prototype.HaveTable = function()
|
||
{
|
||
return !!(this.Flags & FLAG_TABLE);
|
||
};
|
||
CSelectedContent.prototype.CanInsert = function(oAnchorPos)
|
||
{
|
||
if (this.Elements.length <= 0)
|
||
return false;
|
||
|
||
let oParagraph = oAnchorPos.Paragraph;
|
||
|
||
var oDocContent = oParagraph.GetParent();
|
||
if (!oDocContent)
|
||
return false;
|
||
|
||
// Автофигуры не вставляем в другие автофигуры, сноски и концевые сноски
|
||
// Единственное исключение, если вставка происходит картинки в картиночное поле (для замены картинки)
|
||
let oParentShape = oDocContent.Is_DrawingShape(true);
|
||
if (((oParentShape && !oParentShape.isForm()) || true === oDocContent.IsFootnote()) && true === this.HaveShape())
|
||
return false;
|
||
|
||
// В заголовки диаграмм не вставляем формулы
|
||
if(this.HaveMath())
|
||
{
|
||
if(oParagraph.bFromDocument === false)
|
||
{
|
||
let oDrawing = oDocContent.Is_DrawingShape(true);
|
||
if(oDrawing)
|
||
{
|
||
let nDrawingType = null;
|
||
if(oDrawing.getObjectType)
|
||
{
|
||
nDrawingType = oDrawing.getObjectType();
|
||
}
|
||
if(nDrawingType !== AscDFH.historyitem_type_Shape)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (oParagraph.bFromDocument === false && (this.DrawingObjects.length > 0 || this.HaveTable()))
|
||
return false;
|
||
|
||
let oParaAnchorPos = oParagraph.Get_ParaNearestPos(oAnchorPos);
|
||
if (!oParaAnchorPos || oParaAnchorPos.Classes.length < 2)
|
||
return false;
|
||
|
||
let oRun = oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 1];
|
||
if (!oRun || !(oRun instanceof AscCommonWord.ParaRun))
|
||
return false;
|
||
|
||
// Пока автофигуры не поддерживаются внутри формул, запрещаем их туда всталять
|
||
if (oRun.IsMathRun() && this.IsMoveDrawing())
|
||
return false;
|
||
|
||
return (oRun.IsMathRun() ? this.CanConvertToMath() : true);
|
||
};
|
||
CSelectedContent.prototype.Insert = function(oAnchorPos, isSelect)
|
||
{
|
||
if (!this.CanInsert(oAnchorPos))
|
||
return false;
|
||
|
||
let oParagraph = oAnchorPos.Paragraph;
|
||
let oDocContent = oParagraph.GetParent();
|
||
let oLogicDocument = oParagraph.GetLogicDocument();
|
||
|
||
this.LogicDocument = oLogicDocument; // Может быть не задан (например при вставке в формулу в таблицах)
|
||
this.IsPresentationContent = !oParagraph.bFromDocument;
|
||
|
||
this.PrepareObjectsForInsert();
|
||
this.private_CheckContentBeforePaste(oAnchorPos, oDocContent);
|
||
|
||
let oParaAnchorPos = oParagraph.Get_ParaNearestPos(oAnchorPos);
|
||
|
||
let oRun = oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 1];
|
||
|
||
this.ParaAnchorPos = oParaAnchorPos;
|
||
this.Select = isSelect;
|
||
this.Run = oRun;
|
||
this.AnchorPos = oAnchorPos;
|
||
this.Select = !!isSelect;
|
||
this.PasteHelper = oRun ? oRun.GetParagraph() : null;
|
||
|
||
let isLocalTrack = false;
|
||
if (oLogicDocument && oLogicDocument.IsDocumentEditor())
|
||
{
|
||
isLocalTrack = oLogicDocument.GetLocalTrackRevisions();
|
||
oLogicDocument.SetLocalTrackRevisions(false);
|
||
}
|
||
|
||
if (this.private_IsBlockLevelSdtPlaceholder())
|
||
{
|
||
this.private_InsertToBlockLevelSdtWithPlaceholder();
|
||
}
|
||
else if (oRun.IsMathRun())
|
||
{
|
||
this.private_InsertToMathRun();
|
||
}
|
||
else if (oRun.GetParentPictureContentControl())
|
||
{
|
||
this.private_InsertToPictureCC();
|
||
}
|
||
else if (oRun.GetParentForm())
|
||
{
|
||
this.private_InsertToForm();
|
||
}
|
||
else if (this.private_IsInlineInsert())
|
||
{
|
||
this.private_InsertInline();
|
||
}
|
||
else if (this.private_IsOverwriteTableCells())
|
||
{
|
||
this.private_OverwriteTableCells();
|
||
}
|
||
else
|
||
{
|
||
this.private_InsertCommon();
|
||
}
|
||
|
||
this.CheckTemporaryContentControl();
|
||
|
||
if (false !== isLocalTrack)
|
||
oLogicDocument.SetLocalTrackRevisions(isLocalTrack);
|
||
|
||
if (window.g_asc_plugins)
|
||
{
|
||
let aAllOleObjects = [];
|
||
let aAllOleObjectsData = [];
|
||
for(let nDrawing = 0; nDrawing < this.DrawingObjects.length; ++nDrawing)
|
||
{
|
||
this.DrawingObjects[nDrawing].GetAllOleObjects(null, aAllOleObjects);
|
||
}
|
||
for(let nOle = 0; nOle < aAllOleObjects.length; ++nOle)
|
||
{
|
||
aAllOleObjectsData.push(aAllOleObjects[nOle].getDataObject())
|
||
}
|
||
window.g_asc_plugins.onPluginEvent("onInsertOleObjects", aAllOleObjectsData);
|
||
}
|
||
|
||
return true;
|
||
};
|
||
CSelectedContent.prototype.ReplaceContent = function(oDocContent, isSelect)
|
||
{
|
||
if (this.Elements.length <= 0)
|
||
return;
|
||
|
||
oDocContent.ClearContent(false);
|
||
for (let nPos = 0, nCount = this.Elements.length; nPos < nCount; ++nPos)
|
||
{
|
||
let oElement = this.Elements[nPos].Element;
|
||
oDocContent.AddToContent(nPos, oElement);
|
||
}
|
||
|
||
if (true === isSelect)
|
||
{
|
||
oDocContent.SelectAll();
|
||
}
|
||
else
|
||
{
|
||
oDocContent.RemoveSelection();
|
||
oDocContent.MoveCursorToEndPos();
|
||
}
|
||
|
||
oDocContent.SetThisElementCurrent();
|
||
};
|
||
CSelectedContent.prototype.GetPasteHelperElement = function()
|
||
{
|
||
return this.PasteHelper;
|
||
};
|
||
CSelectedContent.prototype.PrepareObjectsForInsert = function()
|
||
{
|
||
let oLogicDocument = this.LogicDocument;
|
||
|
||
if (oLogicDocument && oLogicDocument.IsDocumentEditor())
|
||
{
|
||
if (this.NewCommentsGuid)
|
||
this.private_CreateNewCommentsGuid();
|
||
|
||
this.private_CopyDocPartNames();
|
||
|
||
if (this.CopyComments)
|
||
this.private_CopyComments();
|
||
}
|
||
};
|
||
CSelectedContent.prototype.SetInsertOptionForTable = function(nType)
|
||
{
|
||
this.InsertOptions.Table = nType;
|
||
};
|
||
/**
|
||
* Converts current content to ParaMath if it possible. Doesn't change current SelectedContent
|
||
* @returns {?AscCommonWord.ParaMath}
|
||
* */
|
||
CSelectedContent.prototype.ConvertToMath = function()
|
||
{
|
||
if (!this.CanConvertToMath())
|
||
return null;
|
||
|
||
var oParaMath = new AscCommonWord.ParaMath();
|
||
oParaMath.Root.Remove_FromContent(0, oParaMath.Root.GetElementsCount());
|
||
|
||
for (let nParaIndex = 0, nParasCount = this.Elements.length; nParaIndex < nParasCount; ++nParaIndex)
|
||
{
|
||
let oParagraph = this.Elements[nParaIndex].Element;
|
||
if (!oParagraph.IsParagraph())
|
||
continue;
|
||
|
||
for (var nInParaPos = 0; nInParaPos < oParagraph.GetElementsCount(); ++nInParaPos)
|
||
{
|
||
var oElement = oParagraph.Content[nInParaPos];
|
||
let nType = oElement.GetType();
|
||
if (para_Run === nType)
|
||
{
|
||
oParaMath.Push(oElement.ToMathRun());
|
||
}
|
||
else if (para_Math === nType)
|
||
{
|
||
oParaMath.Concat(oElement);
|
||
}
|
||
}
|
||
}
|
||
|
||
oParaMath.Root.Correct_Content(true);
|
||
return oParaMath;
|
||
};
|
||
/**
|
||
* Устанавливаем, что сейчас происходит перенос во время рецензирования
|
||
* @param {boolean} isTrackRevision
|
||
* @param {string} sMoveId
|
||
*/
|
||
CSelectedContent.prototype.SetMoveTrack = function(isTrackRevision, sMoveId)
|
||
{
|
||
this.TrackRevisions = isTrackRevision;
|
||
this.MoveTrackId = sMoveId;
|
||
};
|
||
/**
|
||
* Проверяем собираем ли содержимое для переноса в рецензировании
|
||
* @returns {boolean}
|
||
*/
|
||
CSelectedContent.prototype.IsMoveTrack = function()
|
||
{
|
||
return this.MoveTrackId !== null;
|
||
};
|
||
/**
|
||
* @returns {boolean}
|
||
*/
|
||
CSelectedContent.prototype.IsTrackRevisions = function()
|
||
{
|
||
return this.TrackRevisions;
|
||
};
|
||
/**
|
||
* Добавляем ран, который участвует в переносе
|
||
* @param {ParaRun} oRun
|
||
*/
|
||
CSelectedContent.prototype.AddRunForMoveTrack = function(oRun)
|
||
{
|
||
this.MoveTrackRuns.push(oRun);
|
||
};
|
||
/**
|
||
* Устанавливаем есть ли в содержимом текст перенесенный во время рецензирования
|
||
* @param {boolean} isHave
|
||
*/
|
||
CSelectedContent.prototype.SetMovedParts = function(isHave)
|
||
{
|
||
this.HaveMovedParts = isHave;
|
||
};
|
||
/**
|
||
* Запрашиваем, есть ли перенесенная во время рецензирования часть
|
||
* @returns {boolean}
|
||
*/
|
||
CSelectedContent.prototype.IsHaveMovedParts = function()
|
||
{
|
||
return this.HaveMovedParts;
|
||
};
|
||
/**
|
||
* Запоминаем секцию, на которой закончилось выделение (если оно было в основной части документа)
|
||
* @param {AscWord.SectPr} oSectPr
|
||
*/
|
||
CSelectedContent.prototype.SetLastSection = function(oSectPr)
|
||
{
|
||
this.LastSection = oSectPr;
|
||
};
|
||
/**
|
||
* Получаем секцию, на которой закончилось выделение
|
||
* @returns {null | AscWord.SectPr}
|
||
*/
|
||
CSelectedContent.prototype.GetLastSection = function()
|
||
{
|
||
return this.LastSection;
|
||
};
|
||
/**
|
||
* Сохранять значения нумерации
|
||
* @param {boolean} isSave
|
||
*/
|
||
CSelectedContent.prototype.SetSaveNumberingValues = function(isSave)
|
||
{
|
||
this.SaveNumberingValues = isSave;
|
||
};
|
||
/**
|
||
* Заппрашиваем, нужно ли сохранять расчитанные значения нумерации
|
||
* @returns {boolean}
|
||
*/
|
||
CSelectedContent.prototype.IsSaveNumberingValues = function()
|
||
{
|
||
return this.SaveNumberingValues;
|
||
};
|
||
/**
|
||
* По умолчанию мы выводим курсор за пределы вставленных элементов, с данным флагом мы оставляем его
|
||
* внутри последнего рана
|
||
* NB: Данный флаг работает только для инлайновой вставки, и не в формулу
|
||
*/
|
||
CSelectedContent.prototype.PlaceCursorInLastInsertedRun = function(isInLast)
|
||
{
|
||
this.CursorInLastRun = undefined === isInLast ? true : !!isInLast;
|
||
};
|
||
/**
|
||
* Конвертируем элементы в один элемент с простым текстом
|
||
*/
|
||
CSelectedContent.prototype.ConvertToText = function()
|
||
{
|
||
var oParagraph = this.private_CreateParagraph();
|
||
|
||
var sText = "";
|
||
for (var nIndex = 0, nCount = this.Elements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oElement = this.Elements[nIndex].Element;
|
||
if (oElement.IsParagraph())
|
||
sText += oElement.GetText({ParaSeparator : ""});
|
||
}
|
||
|
||
var oRun = new ParaRun(oParagraph, null);
|
||
oRun.AddText(sText);
|
||
oParagraph.AddToContent(0, oRun);
|
||
|
||
this.Elements.length = 0;
|
||
this.Elements.push(new CSelectedElement(oParagraph, false));
|
||
};
|
||
CSelectedContent.prototype.GetText = function(oPr)
|
||
{
|
||
let text = "";
|
||
|
||
if (1 === this.Elements.length
|
||
&& this.Elements[0].Element.IsParagraph()
|
||
&& this.Elements[0].Element.IsEmpty({SkipDrawing: true}))
|
||
{
|
||
let drawings = this.Elements[0].Element.GetAllDrawingObjects();
|
||
let graphicObj = 1 === drawings.length ? drawings[0].GraphicObj : null;
|
||
let docContent = graphicObj ? graphicObj.getDocContent() : null;
|
||
if (docContent)
|
||
text = docContent.GetText(oPr);
|
||
}
|
||
else
|
||
{
|
||
for (var nIndex = 0, nCount = this.Elements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oElement = this.Elements[nIndex].Element;
|
||
if (oElement.IsParagraph() || oElement.IsTable() || oElement.IsBlockLevelSdt())
|
||
text += oElement.GetText(oPr);
|
||
}
|
||
}
|
||
return text;
|
||
};
|
||
CSelectedContent.prototype.ConvertToPresentation = function(Parent)
|
||
{
|
||
let Elements = this.Elements.slice(0);
|
||
this.Elements.length = 0;
|
||
|
||
for (let nIndex = 0, nCount = Elements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
let oSelectedElement = Elements[nIndex];
|
||
var oElement = oSelectedElement.Element;
|
||
if (oElement.IsParagraph())
|
||
{
|
||
this.Elements.push(new CSelectedElement(AscFormat.ConvertParagraphToPPTX(oElement, Parent.DrawingDocument, Parent, true, false), oSelectedElement.SelectedAll))
|
||
}
|
||
}
|
||
};
|
||
CSelectedContent.prototype.ConvertToInline = function()
|
||
{
|
||
var oParagraph = this.private_CreateParagraph();
|
||
|
||
for (var nIndex = 0, nCount = this.Elements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oElement = this.Elements[nIndex].Element;
|
||
if (oElement.IsParagraph())
|
||
oParagraph.ConcatContent(oElement.Content);
|
||
}
|
||
|
||
this.Elements.length = 0;
|
||
this.Elements.push(new CSelectedElement(oParagraph, false));
|
||
};
|
||
//----------------- Private Area -----------------------------------------------------------------------------------
|
||
CSelectedContent.prototype.private_CollectObjects = function()
|
||
{
|
||
for (let nPos = 0, nCount = this.Elements.length; nPos < nCount; ++nPos)
|
||
{
|
||
let oElement = this.Elements[nPos].Element;
|
||
|
||
oElement.Set_DocumentPrev(0 === nPos ? null : this.Elements[nPos - 1].Element);
|
||
oElement.Set_DocumentNext(nPos === nCount - 1 ? null : this.Elements[nPos + 1].Element);
|
||
oElement.ProcessComplexFields();
|
||
|
||
let arrParagraphs = oElement.GetAllParagraphs();
|
||
for (let nParaIndex = 0, nParasCount = arrParagraphs.length; nParaIndex < nParasCount; ++nParaIndex)
|
||
{
|
||
let oParagraph = arrParagraphs[nParaIndex];
|
||
oParagraph.GetAllDrawingObjects(this.DrawingObjects);
|
||
oParagraph.GetAllComments(this.Comments);
|
||
oParagraph.GetAllMaths(this.Maths);
|
||
oParagraph.GetAllPermRangeMarks(this.PermRangeMarks);
|
||
}
|
||
|
||
if (oElement.IsParagraph() && nCount > 1)
|
||
oElement.CorrectContent();
|
||
|
||
if (oElement.IsTable())
|
||
this.Flags |= FLAG_TABLE;
|
||
|
||
if (!oElement.IsParagraph())
|
||
this.Flags |= FLAG_NOT_PARAGRAPH;
|
||
|
||
oElement.MoveCursorToEndPos(false);
|
||
}
|
||
|
||
if (this.Maths.length)
|
||
this.Flags |= FLAG_MATH;
|
||
|
||
for (let nPos = 0, nCount = this.DrawingObjects.length; nPos < nCount; ++nPos)
|
||
{
|
||
let oDrawing = this.DrawingObjects[nPos];
|
||
if (oDrawing.IsShape() || oDrawing.IsGroup())
|
||
{
|
||
this.Flags |= FLAG_SHAPE;
|
||
break;
|
||
}
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_CheckComments = function(oLogicDocument)
|
||
{
|
||
if (!(oLogicDocument instanceof AscCommonWord.CDocument))
|
||
return;
|
||
|
||
var mCommentsMarks = {};
|
||
for (var nIndex = 0, nCount = this.Comments.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oMark = this.Comments[nIndex].Comment;
|
||
|
||
var sId = oMark.GetCommentId();
|
||
if (!mCommentsMarks[sId])
|
||
mCommentsMarks[sId] = {};
|
||
|
||
if (oMark.IsCommentStart())
|
||
mCommentsMarks[sId].Start = oMark;
|
||
else
|
||
mCommentsMarks[sId].End = oMark;
|
||
}
|
||
|
||
// Пробегаемся по найденным комментариям и удаляем те, у которых нет начала или конца
|
||
var oCommentsManager = oLogicDocument.GetCommentsManager();
|
||
for (var sId in mCommentsMarks)
|
||
{
|
||
var oEntry = mCommentsMarks[sId];
|
||
|
||
var oParagraph = null;
|
||
if (!oEntry.Start && oEntry.End)
|
||
oParagraph = oEntry.End.GetParagraph();
|
||
else if (oEntry.Start && !oEntry.End)
|
||
oParagraph = oEntry.Start.GetParagraph();
|
||
|
||
var oComment = oCommentsManager.GetById(sId);
|
||
if ((!oEntry.Start && !oEntry.End) || !oComment)
|
||
delete mCommentsMarks[sId];
|
||
else
|
||
oEntry.Comment = oComment;
|
||
|
||
if (oParagraph)
|
||
{
|
||
var bOldValue = oParagraph.DeleteCommentOnRemove;
|
||
oParagraph.DeleteCommentOnRemove = false;
|
||
oParagraph.RemoveCommentMarks(sId);
|
||
oParagraph.DeleteCommentOnRemove = bOldValue;
|
||
delete mCommentsMarks[sId];
|
||
}
|
||
}
|
||
|
||
this.CommentsMarks = mCommentsMarks;
|
||
};
|
||
CSelectedContent.prototype.private_CheckTrackMove = function(oLogicDocument)
|
||
{
|
||
if (this.Elements.length <= 0 || !oLogicDocument || !oLogicDocument.TrackMoveId)
|
||
return;
|
||
|
||
var isCanMove = !this.IsHaveMovedParts();
|
||
for (var nIndex = 0, nCount = this.Elements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (!this.Elements[nIndex].Element.IsParagraph())
|
||
{
|
||
isCanMove = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (oLogicDocument.TrackMoveRelocation)
|
||
isCanMove = true;
|
||
|
||
if (isCanMove)
|
||
{
|
||
if (oLogicDocument.TrackMoveRelocation)
|
||
{
|
||
var oMarks = oLogicDocument.GetTrackRevisionsManager().GetMoveMarks(oLogicDocument.TrackMoveId);
|
||
if (oMarks)
|
||
{
|
||
oMarks.To.Start.RemoveThisMarkFromDocument();
|
||
oMarks.To.End.RemoveThisMarkFromDocument();
|
||
}
|
||
}
|
||
|
||
var oStartElement = this.Elements[0].Element;
|
||
var oEndElement = this.Elements[this.Elements.length - 1].Element;
|
||
|
||
var oStartParagraph = oStartElement.GetFirstParagraph();
|
||
var oEndParagraph = oEndElement.GetLastParagraph();
|
||
|
||
oStartParagraph.AddToContent(0, new CParaRevisionMove(true, false, oLogicDocument.TrackMoveId));
|
||
|
||
if (oEndParagraph !== oEndElement || this.Elements[this.Elements.length - 1].SelectedAll)
|
||
{
|
||
var oEndRun = oEndParagraph.GetParaEndRun();
|
||
oEndRun.AddAfterParaEnd(new AscWord.CRunRevisionMove(false, false, oLogicDocument.TrackMoveId));
|
||
|
||
var oInfo = new AscWord.ReviewInfo();
|
||
oInfo.Update();
|
||
oInfo.SetMove(Asc.c_oAscRevisionsMove.MoveTo);
|
||
oEndRun.SetReviewTypeWithInfo(reviewtype_Add, oInfo, false);
|
||
}
|
||
else
|
||
{
|
||
oEndParagraph.AddToContent(oEndParagraph.GetElementsCount(), new CParaRevisionMove(false, false, oLogicDocument.TrackMoveId));
|
||
}
|
||
|
||
for (var nIndex = 0, nCount = this.MoveTrackRuns.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oRun = this.MoveTrackRuns[nIndex];
|
||
var oInfo = new AscWord.ReviewInfo();
|
||
oInfo.Update();
|
||
oInfo.SetMove(Asc.c_oAscRevisionsMove.MoveTo);
|
||
oRun.SetReviewTypeWithInfo(reviewtype_Add, oInfo);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
oLogicDocument.TrackMoveId = null;
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_CheckPermRangeMarks = function(logicDocument)
|
||
{
|
||
// TODO: Пока мы удаляем все метки. В будущем надо сделать, что если скопированы начало и конец, то мы
|
||
// приписываем им новый id диапазона, а если скопировано только начала или конец, то удаляем такие метки
|
||
|
||
for (let markIndex = 0, markCount = this.PermRangeMarks.length; markIndex < markCount; ++markIndex)
|
||
{
|
||
let mark = this.PermRangeMarks[markIndex];
|
||
mark.removeMark();
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_CreateNewCommentsGuid = function()
|
||
{
|
||
let oManager = this.LogicDocument.GetCommentsManager();
|
||
for (var Index = 0; Index < this.Comments.length; Index++)
|
||
{
|
||
var comment = oManager.GetById(this.Comments[Index].Comment.CommentId);
|
||
if (comment)
|
||
{
|
||
comment.CreateNewCommentsGuid();
|
||
}
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_CopyDocPartNames = function()
|
||
{
|
||
var arrCC = [];
|
||
for (var nIndex = 0, nCount = this.Elements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
this.Elements[nIndex].Element.GetAllContentControls(arrCC);
|
||
}
|
||
|
||
var oGlossaryDocument = this.LogicDocument.GetGlossaryDocument();
|
||
for (var nIndex = 0, nCount = arrCC.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
var oCC = arrCC[nIndex];
|
||
|
||
var sPlaceHolderName = oCC.GetPlaceholder();
|
||
if (sPlaceHolderName)
|
||
{
|
||
var oDocPart = oGlossaryDocument.GetDocPartByName(sPlaceHolderName);
|
||
if (!oDocPart || oGlossaryDocument.IsDefaultDocPart(oDocPart))
|
||
continue;
|
||
|
||
var sNewName = oGlossaryDocument.GetNewName();
|
||
oGlossaryDocument.AddDocPart(oDocPart.Copy(sNewName));
|
||
oCC.SetPlaceholder(sNewName);
|
||
}
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_CopyComments = function()
|
||
{
|
||
let oLogicDocument = this.LogicDocument;
|
||
|
||
var oCommentsManager = this.LogicDocument.GetCommentsManager();
|
||
for (let sId in this.CommentsMarks)
|
||
{
|
||
let oEntry = this.CommentsMarks[sId];
|
||
|
||
var oNewComment = oEntry.Comment.Copy();
|
||
oCommentsManager.Add(oNewComment);
|
||
|
||
var sNewId = oNewComment.GetId();
|
||
oLogicDocument.GetApi().sync_AddComment(sNewId, oNewComment.GetData());
|
||
oEntry.Start.SetCommentId(sNewId);
|
||
oEntry.End.SetCommentId(sNewId);
|
||
|
||
oNewComment.SetRangeStart(oEntry.Start.GetId());
|
||
oNewComment.SetRangeEnd(oEntry.End.GetId());
|
||
}
|
||
};
|
||
/**
|
||
* Проверяем содержимое, которые мы вставляем, в зависимости от места куда оно вставляется
|
||
* @param oAnchorPos {NearestPos}
|
||
* @param oDocContent {AscCommonWord.CDocumentContent}
|
||
*/
|
||
CSelectedContent.prototype.private_CheckContentBeforePaste = function(oAnchorPos, oDocContent)
|
||
{
|
||
var oParagraph = oAnchorPos.Paragraph;
|
||
|
||
// Если мы вставляем в специальный контент контрол, тогда производим простую вставку текста
|
||
var oParaState = oParagraph.SaveSelectionState();
|
||
oParagraph.RemoveSelection();
|
||
oParagraph.Set_ParaContentPos(oAnchorPos.ContentPos, false, -1, -1, false);
|
||
var arrContentControls = oParagraph.GetSelectedContentControls();
|
||
oParagraph.LoadSelectionState(oParaState);
|
||
|
||
for (var nIndex = 0, nCount = arrContentControls.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (arrContentControls[nIndex].IsComboBox() || arrContentControls[nIndex].IsDropDownList())
|
||
{
|
||
this.ConvertToText();
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (this.IsPresentationContent)
|
||
this.ConvertToPresentation(oDocContent);
|
||
|
||
if (this.ForceInline)
|
||
this.ConvertToInline();
|
||
};
|
||
CSelectedContent.prototype.private_AdjustSizeForInlineDrawing = function()
|
||
{
|
||
if (this.MoveDrawing)
|
||
return;
|
||
|
||
if (1 === this.DrawingObjects.length && 1 === this.Elements.length)
|
||
{
|
||
let oParaDrawing = this.DrawingObjects[0];
|
||
if (oParaDrawing.IsInline())
|
||
{
|
||
let oElement = this.Elements[0].Element;
|
||
if (oElement.IsParagraph())
|
||
{
|
||
let isAdditionalContent = oElement.CheckRunContent(function(oRun)
|
||
{
|
||
for (let nPos = 0, nCount = oRun.GetElementsCount(); nPos < nCount; ++nPos)
|
||
{
|
||
let oItem = oRun.GetElement(nPos);
|
||
if (oItem && !oItem.IsParaEnd() && !oItem.IsDrawing())
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
if (!isAdditionalContent)
|
||
oParaDrawing.CheckFitToColumn();
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_CheckInsertSignatures = function()
|
||
{
|
||
var aDrawings = this.DrawingObjects;
|
||
var nDrawing, oDrawing, oSp;
|
||
var sLastSignatureId = null;
|
||
for (nDrawing = 0; nDrawing < aDrawings.length; ++nDrawing)
|
||
{
|
||
oDrawing = aDrawings[nDrawing];
|
||
oSp = oDrawing.GraphicObj;
|
||
if (oSp && oSp.signatureLine)
|
||
{
|
||
oSp.setSignature(oSp.signatureLine);
|
||
sLastSignatureId = oSp.signatureLine.id;
|
||
}
|
||
}
|
||
if (sLastSignatureId)
|
||
{
|
||
editor.sendEvent("asc_onAddSignature", sLastSignatureId);
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_IsInlineInsert = function()
|
||
{
|
||
return (1 === this.Elements.length && !this.Elements[0].SelectedAll && this.Elements[0].Element.IsParagraph() && (!this.Elements[0].Element.IsEmpty() || this.ForceInline));
|
||
};
|
||
CSelectedContent.prototype.private_IsOverwriteTableCells = function()
|
||
{
|
||
let oParagraph = this.Run.GetParagraph();
|
||
if (!oParagraph)
|
||
return false;
|
||
|
||
let nDstIndex = oParagraph.GetIndex();
|
||
let oDocContent = oParagraph.GetParent();
|
||
if (!oDocContent || oParagraph !== oDocContent.GetElement(nDstIndex))
|
||
return false;
|
||
|
||
return (Asc.c_oSpecialPasteProps.overwriteCells === this.InsertOptions.Table
|
||
&& 1 === this.Elements.length
|
||
&& this.Elements[0].Element.IsTable()
|
||
&& oDocContent.GetParent() instanceof AscWord.CTableCell);
|
||
};
|
||
CSelectedContent.prototype.private_InsertToMathRun = function()
|
||
{
|
||
let oParaAnchorPos = this.ParaAnchorPos;
|
||
|
||
let oMathContent = oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 2];
|
||
let nInMathContentPos = oParaAnchorPos.NearPos.ContentPos.Data[oParaAnchorPos.Classes.length - 2];
|
||
|
||
let paraMath = oMathContent.ParaMath;
|
||
let insertMath = this.ConvertToMath();
|
||
let paragraph = paraMath ? paraMath.GetParagraph() : null;
|
||
if (!insertMath || !paraMath || !paragraph)
|
||
return;
|
||
|
||
if (paraMath.GetParent() instanceof AscWord.CInlineLevelSdt && paraMath.GetParent().IsContentControlEquation())
|
||
{
|
||
let contentControl = paraMath.GetParent();
|
||
paraMath = contentControl.ReplacePlaceholderEquation();
|
||
contentControl.RemoveContentControlWrapper();
|
||
|
||
oMathContent = paraMath.Root;
|
||
oMathContent.AddToContent(0, new AscWord.CRun(paragraph, true));
|
||
oMathContent.InsertMathContent(insertMath.Root, 0, this.Select);
|
||
}
|
||
else
|
||
{
|
||
let oRun = oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 1];
|
||
let oNewRun = oRun.Split(oParaAnchorPos.NearPos.ContentPos, oParaAnchorPos.Classes.length - 1);
|
||
oMathContent.AddToContent(nInMathContentPos + 1, oNewRun);
|
||
oMathContent.InsertMathContent(insertMath.Root, nInMathContentPos + 1, this.Select);
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_InsertToPictureCC = function()
|
||
{
|
||
let oPictureCC = this.Run.GetParentPictureContentControl()
|
||
|
||
var oSrcPicture = null;
|
||
for (var nIndex = 0, nCount = this.DrawingObjects.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (this.DrawingObjects[nIndex].IsPicture())
|
||
{
|
||
oSrcPicture = this.DrawingObjects[nIndex].GraphicObj.copy();
|
||
break;
|
||
}
|
||
}
|
||
|
||
var arrParaDrawings = oPictureCC.GetAllDrawingObjects();
|
||
if (arrParaDrawings.length > 0 && oSrcPicture)
|
||
{
|
||
oPictureCC.SetShowingPlcHdr(false);
|
||
oSrcPicture.setParent(arrParaDrawings[0]);
|
||
arrParaDrawings[0].Set_GraphicObject(oSrcPicture);
|
||
|
||
if (oPictureCC.IsPictureForm())
|
||
oPictureCC.UpdatePictureFormLayout();
|
||
|
||
let oLogicDocument = this.LogicDocument;
|
||
if (oLogicDocument)
|
||
{
|
||
oLogicDocument.DrawingObjects.resetSelection();
|
||
oLogicDocument.RemoveSelection();
|
||
oPictureCC.SelectContentControl();
|
||
|
||
if (oLogicDocument.IsDocumentEditor() && arrParaDrawings[0].IsPicture())
|
||
oLogicDocument.OnChangeForm(oPictureCC);
|
||
}
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_InsertToForm = function()
|
||
{
|
||
let oParaAnchorPos = this.ParaAnchorPos;
|
||
|
||
let oRun = this.Run;
|
||
let oForm = oRun.GetParentForm();
|
||
|
||
let nInLastClassPos = oParaAnchorPos.NearPos.ContentPos.Data[oParaAnchorPos.Classes.length - 1];
|
||
|
||
if (oForm.IsComplexForm())
|
||
{
|
||
this.ConvertToInline();
|
||
return this.private_InsertInline();
|
||
}
|
||
|
||
if ((!oForm.IsTextForm() && !oForm.IsComboBox() && !oForm.IsDatePicker()))
|
||
return;
|
||
|
||
let newLineSep = "";
|
||
if (oForm.IsMultiLineForm() || (oForm.IsTextForm() && !oForm.IsFixedForm()))
|
||
newLineSep = "\n";
|
||
|
||
let sInsertedText = this.GetText({
|
||
ParaSeparator : newLineSep,
|
||
TableCellSeparator : newLineSep,
|
||
TableRowSeparator : newLineSep,
|
||
NewLineSeparator : newLineSep
|
||
});
|
||
|
||
if (sInsertedText
|
||
&& sInsertedText.length
|
||
&& newLineSep
|
||
&& sInsertedText[sInsertedText.length - 1] === newLineSep)
|
||
{
|
||
sInsertedText = sInsertedText.slice(0, -1);
|
||
}
|
||
|
||
if (!sInsertedText || !sInsertedText.length)
|
||
return;
|
||
|
||
var isPlaceHolder = oRun.GetParentForm().IsPlaceHolder();
|
||
if (isPlaceHolder && oRun.GetParent() instanceof CInlineLevelSdt)
|
||
{
|
||
var oInlineLeveLSdt = oRun.GetParent();
|
||
oInlineLeveLSdt.ReplacePlaceHolderWithContent();
|
||
oRun = oInlineLeveLSdt.GetElement(0);
|
||
nInLastClassPos = 0;
|
||
}
|
||
|
||
let nInRunStartPos = nInLastClassPos;
|
||
oRun.State.ContentPos = nInLastClassPos;
|
||
oRun.AddText(sInsertedText, nInLastClassPos);
|
||
let nInRunEndPos = oRun.State.ContentPos;
|
||
|
||
let nLastClassLen = oRun.GetElementsCount();
|
||
nInRunStartPos = Math.min(nLastClassLen, Math.min(nInRunStartPos, nInRunEndPos));
|
||
nInRunEndPos = Math.min(nLastClassLen, nInRunEndPos);
|
||
|
||
if (this.Select)
|
||
{
|
||
oRun.Selection.Use = true;
|
||
oRun.Selection.StartPos = nInRunStartPos;
|
||
oRun.Selection.EndPos = nInRunEndPos;
|
||
oRun.State.ContentPos = nInRunEndPos;
|
||
oRun.SelectThisElement(1, true);
|
||
}
|
||
else
|
||
{
|
||
oRun.SetThisElementCurrent();
|
||
oRun.State.ContentPos = nInRunEndPos;
|
||
}
|
||
};
|
||
CSelectedContent.prototype.private_InsertInline = function()
|
||
{
|
||
let oParaAnchorPos = this.ParaAnchorPos;
|
||
|
||
let runParent = this.Run.GetParent();
|
||
let inlineSdt = runParent && runParent instanceof CInlineLevelSdt ? runParent : null;
|
||
if (inlineSdt && inlineSdt.IsPlaceHolder())
|
||
{
|
||
if (inlineSdt.IsContentControlTemporary())
|
||
{
|
||
let oResult = inlineSdt.RemoveContentControlWrapper();
|
||
|
||
let oSdtParent = oResult.Parent;
|
||
let oSdtPos = oResult.Pos;
|
||
let oSdtCount = oResult.Count;
|
||
|
||
if (!oSdtParent
|
||
|| oParaAnchorPos.Classes.length < 3
|
||
|| oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 2] !== inlineSdt
|
||
|| oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 3] !== oSdtParent)
|
||
return;
|
||
|
||
let oRun = new ParaRun(undefined, false);
|
||
oRun.SetPr(inlineSdt.GetDefaultTextPr().Copy());
|
||
|
||
oSdtParent.RemoveFromContent(oSdtPos, oSdtCount);
|
||
oSdtParent.AddToContent(oSdtPos, oRun);
|
||
|
||
oParaAnchorPos.Classes.length--;
|
||
oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 1] = oRun;
|
||
oParaAnchorPos.NearPos.ContentPos.Update(oSdtPos, oParaAnchorPos.Classes.length - 2);
|
||
oParaAnchorPos.NearPos.ContentPos.Update(0, oParaAnchorPos.Classes.length - 1);
|
||
}
|
||
else
|
||
{
|
||
inlineSdt.ReplacePlaceHolderWithContent();
|
||
oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 1] = inlineSdt.GetElement(0);
|
||
oParaAnchorPos.NearPos.ContentPos.Update(0, oParaAnchorPos.Classes.length - 2);
|
||
oParaAnchorPos.NearPos.ContentPos.Update(0, oParaAnchorPos.Classes.length - 1);
|
||
}
|
||
inlineSdt = null;
|
||
}
|
||
|
||
let oRun = oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 1];
|
||
let oNewRun = oRun.Split(oParaAnchorPos.NearPos.ContentPos, oParaAnchorPos.Classes.length - 1);
|
||
|
||
let oParent = oParaAnchorPos.Classes[oParaAnchorPos.Classes.length - 2];
|
||
let nInParentPos = oParaAnchorPos.NearPos.ContentPos.Data[oParaAnchorPos.Classes.length - 2];
|
||
|
||
oParent.AddToContent(nInParentPos + 1, oNewRun);
|
||
|
||
let oParagraph = this.Elements[0].Element;
|
||
let nElementsCount = oParagraph.Content.length - 1; // Последний ран с para_End не добавляем
|
||
|
||
let isSelect = this.Select && !this.MoveDrawing;
|
||
for (let nPos = 0; nPos < nElementsCount; ++nPos)
|
||
{
|
||
let oItem = oParagraph.GetElement(nPos);
|
||
oParent.AddToContent(nInParentPos + 1 + nPos, oItem);
|
||
|
||
if (isSelect)
|
||
oItem.SelectAll();
|
||
else
|
||
oItem.RemoveSelection();
|
||
}
|
||
|
||
if (this.MoveDrawing)
|
||
{
|
||
}
|
||
else if (isSelect)
|
||
{
|
||
oParent.Selection.Use = true;
|
||
oParent.Selection.StartPos = nInParentPos + 1;
|
||
oParent.Selection.EndPos = nInParentPos + 1 + nElementsCount - 1;
|
||
oParent.SelectThisElement(1, true);
|
||
}
|
||
else
|
||
{
|
||
oParent.RemoveSelection();
|
||
oParent.SetThisElementCurrent();
|
||
if (this.CursorInLastRun)
|
||
{
|
||
oParent.SetCurrentPos(nInParentPos + nElementsCount);
|
||
oParent.GetElement(nInParentPos + nElementsCount).MoveCursorToEndPos();
|
||
}
|
||
else
|
||
{
|
||
oParent.SetCurrentPos(nInParentPos + 1 + nElementsCount);
|
||
oParent.GetElement(nInParentPos + nElementsCount).MoveCursorToStartPos();
|
||
}
|
||
}
|
||
|
||
if (oParent.CorrectContent)
|
||
oParent.CorrectContent();
|
||
|
||
if (this.LogicDocument && this.LogicDocument.IsDocumentEditor())
|
||
this.private_AdjustSizeForInlineDrawing();
|
||
|
||
if (inlineSdt && inlineSdt.IsContentControlTemporary())
|
||
inlineSdt.RemoveContentControlWrapper()
|
||
|
||
this.private_CheckInsertSignatures();
|
||
};
|
||
CSelectedContent.prototype.private_OverwriteTableCells = function()
|
||
{
|
||
let oTableCell = this.Run.GetParagraph().GetParent().GetParent();
|
||
return oTableCell.InsertTableContent(this.Elements[0].Element);
|
||
};
|
||
CSelectedContent.prototype.private_InsertCommon = function()
|
||
{
|
||
let oParagraph = this.Run.GetParagraph();
|
||
if (!oParagraph)
|
||
return;
|
||
|
||
let nDstIndex = oParagraph.GetIndex();
|
||
let oDocContent = oParagraph.GetParent();
|
||
if (!oDocContent || oParagraph !== oDocContent.GetElement(nDstIndex))
|
||
return;
|
||
|
||
oParagraph.RemoveSelection();
|
||
oParagraph.MoveCursorToAnchorPos(this.AnchorPos);
|
||
|
||
let oParagraphS, oParagraphE, nInsertPos;
|
||
if (oParagraph.IsCursorAtBegin())
|
||
{
|
||
oParagraphS = null;
|
||
oParagraphE = oParagraph;
|
||
nInsertPos = nDstIndex;
|
||
}
|
||
else
|
||
{
|
||
oParagraphS = oParagraph;
|
||
oParagraphE = new AscWord.Paragraph(undefined, this.IsPresentationContent);
|
||
oParagraphS.Split(oParagraphE);
|
||
oDocContent.AddToContent(nDstIndex + 1, oParagraphE);
|
||
nInsertPos = nDstIndex + 1;
|
||
}
|
||
|
||
let nSelectionStart = nInsertPos;
|
||
let nStartPos = 0;
|
||
if (oParagraphS
|
||
&& this.Elements[0].Element.IsParagraph()
|
||
&& -1 !== oParagraphS.GetIndex())
|
||
{
|
||
let nParagraphSPos = oParagraphS.GetIndex();
|
||
let oInsertParagraph = this.Elements[0].Element;
|
||
oInsertParagraph.ConcatBefore(oParagraphS, this.Select ? 1 : 0);
|
||
|
||
oDocContent.AddToContent(nParagraphSPos, oInsertParagraph);
|
||
oDocContent.RemoveFromContent(nParagraphSPos + 1, 1);
|
||
nSelectionStart = nParagraphSPos;
|
||
nStartPos++;
|
||
|
||
oParagraphS = oInsertParagraph;
|
||
}
|
||
|
||
let nEndPos = this.Elements.length - 1;
|
||
let isConcatE = false;
|
||
if (oParagraphE
|
||
&& this.Elements.length > 1
|
||
&& this.Elements[nEndPos].Element.IsParagraph()
|
||
&& !this.Elements[nEndPos].SelectedAll)
|
||
{
|
||
oParagraphE.ConcatBefore(this.Elements[nEndPos].Element, this.Select ? -1 : 0);
|
||
nEndPos--;
|
||
isConcatE = true;
|
||
}
|
||
else
|
||
{
|
||
oParagraphE.MoveCursorToStartPos();
|
||
}
|
||
|
||
for (let nPos = nStartPos; nPos <= nEndPos; ++nPos)
|
||
{
|
||
let oElement = this.Elements[nPos].Element;
|
||
oDocContent.AddToContent(nInsertPos++, oElement);
|
||
|
||
if (this.Select)
|
||
{
|
||
oElement.SelectAll(1);
|
||
}
|
||
else
|
||
{
|
||
oElement.RemoveSelection();
|
||
oElement.MoveCursorToEndPos();
|
||
}
|
||
}
|
||
let nSelectionEnd = isConcatE ? oParagraphE.GetIndex() : nInsertPos - 1;
|
||
|
||
if (this.Select)
|
||
{
|
||
oDocContent.Selection.Use = true;
|
||
oDocContent.Selection.StartPos = nSelectionStart;
|
||
oDocContent.Selection.EndPos = nSelectionEnd;
|
||
oDocContent.CurPos.ContentPos = nSelectionEnd;
|
||
oDocContent.SetThisElementCurrent();
|
||
}
|
||
else
|
||
{
|
||
if (oParagraphS && oParagraphS !== oParagraphE)
|
||
{
|
||
oParagraphS.RemoveSelection();
|
||
oParagraphS.MoveCursorToEndPos();
|
||
}
|
||
|
||
oParagraphE.RemoveSelection();
|
||
oDocContent.CurPos.ContentPos = nInsertPos;
|
||
oDocContent.SetThisElementCurrent();
|
||
}
|
||
|
||
this.private_CheckInsertSignatures();
|
||
|
||
if (isConcatE && oParagraphE)
|
||
this.PasteHelper = oParagraphE;
|
||
else
|
||
this.PasteHelper = this.Elements[this.Elements.length - 1].Element;
|
||
};
|
||
CSelectedContent.prototype.private_GetDrawingDocument = function()
|
||
{
|
||
let _editor = editor;
|
||
if (!_editor && Asc && Asc.editor)
|
||
_editor = Asc.editor;
|
||
|
||
if (!_editor)
|
||
return null;
|
||
|
||
return _editor.getDrawingDocument();
|
||
};
|
||
CSelectedContent.prototype.private_CreateParagraph = function()
|
||
{
|
||
return new AscWord.Paragraph(undefined, this.IsPresentationContent);
|
||
};
|
||
CSelectedContent.prototype.private_IsBlockLevelSdtPlaceholder = function()
|
||
{
|
||
let paragraph = this.Run.GetParagraph();
|
||
if (!paragraph)
|
||
return false;
|
||
|
||
let paraIndex = paragraph.GetIndex();
|
||
let docContent = paragraph.GetParent();
|
||
|
||
if (!docContent
|
||
|| paragraph !== docContent.GetElement(paraIndex)
|
||
|| !docContent.IsBlockLevelSdtContent())
|
||
return false;
|
||
|
||
let blockSdt = docContent.GetParent();
|
||
return (blockSdt.IsPlaceHolder() || blockSdt.IsEmpty());
|
||
};
|
||
CSelectedContent.prototype.private_InsertToBlockLevelSdtWithPlaceholder = function()
|
||
{
|
||
let blockSdt = this.Run.GetParagraph().GetParent().GetParent();
|
||
blockSdt.ReplacePlaceHolderWithContent();
|
||
let docContent = blockSdt.GetContent();
|
||
this.ReplaceContent(docContent, true);
|
||
};
|
||
CSelectedContent.prototype.CheckTemporaryContentControl = function()
|
||
{
|
||
let paragraph = this.Run.GetParagraph();
|
||
if (!paragraph)
|
||
return;
|
||
|
||
let paraIndex = paragraph.GetIndex();
|
||
let docContent = paragraph.GetParent();
|
||
|
||
if (!docContent
|
||
|| paragraph !== docContent.GetElement(paraIndex)
|
||
|| !docContent.IsBlockLevelSdtContent())
|
||
return;
|
||
|
||
let blockSdt = docContent.GetParent();
|
||
if (blockSdt.IsContentControlTemporary())
|
||
blockSdt.RemoveContentControlWrapper();
|
||
};
|
||
|
||
/**
|
||
* @param oElement
|
||
* @param isSelectedAll
|
||
* @constructor
|
||
*/
|
||
function CSelectedElement(oElement, isSelectedAll)
|
||
{
|
||
this.Element = oElement;
|
||
this.SelectedAll = isSelectedAll;
|
||
}
|
||
|
||
|
||
//--------------------------------------------------------export----------------------------------------------------
|
||
window['AscCommonWord'] = window['AscCommonWord'] || {};
|
||
window['AscCommonWord'].CSelectedContent = CSelectedContent;
|
||
window['AscCommonWord'].CSelectedElement = CSelectedElement;
|
||
|
||
})(window);
|