/*
 * (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";
var c_oAscRevisionsChangeType = Asc.c_oAscRevisionsChangeType;
function CParagraphContentBase()
{
	this.Type      = para_Unknown;
	this.Paragraph = null;
	this.Parent    = null;

	this.StartLine  = -1;
	this.StartRange = -1;

	this.Lines       = [];
	this.LinesLength = 0;
}
CParagraphContentBase.prototype.GetType = function()
{
	return this.Type;
};
CParagraphContentBase.prototype.Get_Type = function()
{
	return this.Type;
};
CParagraphContentBase.prototype.GetLogicDocument = function()
{
	return this.Paragraph ? this.Paragraph.GetLogicDocument() : null;
};
CParagraphContentBase.prototype.GetLinesCount = function()
{
	return 0;
};
CParagraphContentBase.prototype.CanSplit = function()
{
	return false;
};
CParagraphContentBase.prototype.IsParagraphContentElement = function()
{
	return true;
};
CParagraphContentBase.prototype.IsStopCursorOnEntryExit = function()
{
	return false;
};
CParagraphContentBase.prototype.PreDelete = function()
{
};
CParagraphContentBase.prototype.GetCurrentPermRanges = function(permRanges, isCurrent)
{
};
CParagraphContentBase.prototype.CorrectPosToPermRanges = function(state, paraPos, depth, isCurrent)
{
};
/**
 * Выствялем параграф, в котром лежит данный элемент
 * @param {Paragraph} oParagraph
 */
CParagraphContentBase.prototype.SetParagraph = function(oParagraph)
{
	this.Paragraph = oParagraph;
};
/**
 * ВЫставляем родительский класс
 * @param oParent
 */
CParagraphContentBase.prototype.SetParent = function(oParent)
{
	this.Parent = oParent;
};
/**
 * Получаем параграф, в котором лежит данный элемент
 * @returns {null|Paragraph}
 */
CParagraphContentBase.prototype.GetParagraph = function()
{
	return this.Paragraph;
};
CParagraphContentBase.prototype.IsThisElementCurrent = function()
{
	return false;
};
CParagraphContentBase.prototype.IsRun = function()
{
	return false;
};
CParagraphContentBase.prototype.IsMath = function()
{
	return false;
};
CParagraphContentBase.prototype.IsAnnotationMark = function()
{
	return false;
};
CParagraphContentBase.prototype.Is_Empty = function()
{
	return true;
};
CParagraphContentBase.prototype.IsEmpty = function()
{
	return this.Is_Empty();
};
CParagraphContentBase.prototype.Is_CheckingNearestPos = function()
{
	return false;
};
CParagraphContentBase.prototype.Get_CompiledTextPr = function()
{
	return null;
};
CParagraphContentBase.prototype.Clear_TextPr = function()
{

};
CParagraphContentBase.prototype.Remove = function()
{
	return false;
};
CParagraphContentBase.prototype.Get_DrawingObjectRun = function(Id)
{
	return null;
};
CParagraphContentBase.prototype.Get_DrawingObjectContentPos = function(Id, ContentPos, Depth)
{
	return false;
};
CParagraphContentBase.prototype.GetRunByElement = function(oRunElement)
{
	return null;
};
CParagraphContentBase.prototype.Get_Layout = function(DrawingLayout, UseContentPos, ContentPos, Depth)
{
};
/**
 * Ищем список элементов, идущих после заданной позициц
 * @param oRunElements {CParagraphRunElements}
 * @param isUseContentPos {boolean}
 * @param nDepth {number}
 */
CParagraphContentBase.prototype.GetNextRunElements = function(oRunElements, isUseContentPos, nDepth)
{
};
/**
 * Ищем список элементов рана, предществующих заданной позиции
 * @param oRunElements {CParagraphRunElements}
 * @param isUseContentPos {boolean}
 * @param nDepth {number}
 */
CParagraphContentBase.prototype.GetPrevRunElements = function(oRunElements, isUseContentPos, nDepth)
{
};
CParagraphContentBase.prototype.CollectDocumentStatistics = function(ParaStats)
{
};
CParagraphContentBase.prototype.Create_FontMap = function(Map)
{
};
CParagraphContentBase.prototype.Get_AllFontNames = function(AllFonts)
{
};
CParagraphContentBase.prototype.GetSelectedText = function(bAll, bClearText, oPr)
{
	return "";
};
CParagraphContentBase.prototype.GetSelectDirection = function()
{
	return 1;
};
CParagraphContentBase.prototype.Clear_TextFormatting = function( DefHyper )
{
};
/**
 * Проверяем можно ли добавлять буквицу
 * @returns {null | boolean}
 */
CParagraphContentBase.prototype.CanAddDropCap = function()
{
	return null;
};
/**
 * Проверяем можно ли использовать селект для добавления буквицы
 * @param isUsePos {boolean}
 * @param oEndPos {AscWord.CParagraphContentPos}
 * @param nDepth {number}
 * @returns {boolean}
 */
CParagraphContentBase.prototype.CheckSelectionForDropCap = function(isUsePos, oEndPos, nDepth)
{
	return true;
};
CParagraphContentBase.prototype.Get_TextForDropCap = function(DropCapText, UseContentPos, ContentPos, Depth)
{
};
CParagraphContentBase.prototype.Get_StartTabsCount = function(TabsCounter)
{
	return true;
};
CParagraphContentBase.prototype.Remove_StartTabs = function(TabsCounter)
{
	return true;
};
CParagraphContentBase.prototype.Copy = function(Selected, oPr, isCopyReviewPr)
{
	return new this.constructor();
};
CParagraphContentBase.prototype.GetSelectedContent = function(oSelectedContent)
{
	return this.Copy();
};
CParagraphContentBase.prototype.CopyContent = function(Selected)
{
	return [];
};
CParagraphContentBase.prototype.Split = function()
{
	return new ParaRun();
};
CParagraphContentBase.prototype.SplitNoDuplicate = function(oContentPos, nDepth, oNewParagraph)
{

};
CParagraphContentBase.prototype.Get_Text = function(Text)
{
};
CParagraphContentBase.prototype.Apply_TextPr = function(oTextPr, isIncFontSize, isApplyToAll)
{
};
CParagraphContentBase.prototype.Get_ParaPosByContentPos = function(ContentPos, Depth)
{
	return new CParaPos(this.StartRange, this.StartLine, 0, 0);
};
CParagraphContentBase.prototype.UpdateBookmarks = function(oManager)
{
};
/**
 * @param oSpellCheckerEngine {AscWord.CParagraphSpellCheckerCollector}
 * @param nDepth {number}
 */
CParagraphContentBase.prototype.CheckSpelling = function(oSpellCheckerEngine, nDepth)
{
};
CParagraphContentBase.prototype.GetParent = function()
{
	if (this.Parent)
		return this.Parent;

	if (!this.Paragraph)
		return null;

	var oContentPos = this.Paragraph.Get_PosByElement(this);
	if (!oContentPos || oContentPos.GetDepth() < 0)
		return null;

	oContentPos.DecreaseDepth(1);
	return this.Paragraph.Get_ElementByPos(oContentPos);
};
CParagraphContentBase.prototype.GetPosInParent = function(_oParent)
{
	var oParent = (_oParent? _oParent : this.GetParent());
	if (!oParent || !oParent.Content)
		return -1;

	for (var nPos = 0, nCount = oParent.Content.length; nPos < nCount; ++nPos)
	{
		if (this === oParent.Content[nPos])
			return nPos;
	}

	return -1;
};
CParagraphContentBase.prototype.RemoveThisFromParent = function(updatePosition)
{
	let parent      = this.GetParent();
	let posInParent = this.GetPosInParent(parent);
	
	if (parent && -1 !== posInParent)
		parent.RemoveFromContent(posInParent, 1);
	
	if (false !== updatePosition)
	{
		if (posInParent < parent.GetElementsCount() && parent.GetElement(posInParent).IsCursorPlaceable())
		{
			parent.GetElement(posInParent).MoveCursorToStartPos();
			parent.GetElement(posInParent).SetThisElementCurrentInParagraph();
		}
		else if (posInParent > 0 && parent.GetElement(posInParent - 1).IsCursorPlaceable())
		{
			parent.GetElement(posInParent - 1).MoveCursorToStartPos();
			parent.GetElement(posInParent - 1).SetThisElementCurrentInParagraph();
		}
	}
	
	parent.CorrectContent();
};
CParagraphContentBase.prototype.RemoveTabsForTOC = function(isTab)
{
	return isTab;
};
/**
 * Ищем сложное поле заданного типа
 * @param nType
 * @returns {?CComplexField}
 */
CParagraphContentBase.prototype.GetComplexField = function(nType)
{
	return null;
};
/**
 * Ищем все сложные поля заданного типа
 * @param nType
 * @param arrComplexFields
 */
CParagraphContentBase.prototype.GetComplexFieldsArray = function(nType, arrComplexFields)
{
};
//----------------------------------------------------------------------------------------------------------------------
// Функции пересчета
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentBase.prototype.Recalculate_Reset = function(StartRange, StartLine)
{
	this.StartLine   = StartLine;
	this.StartRange  = StartRange;
};
CParagraphContentBase.prototype.Recalculate_Range = function(PRS, ParaPr)
{
};
CParagraphContentBase.prototype.Recalculate_Set_RangeEndPos = function(PRS, PRP, Depth)
{
};
CParagraphContentBase.prototype.Recalculate_SetRangeBounds = function(_CurLine, _CurRange, oStartPos, oEndPos, nDepth)
{
};
CParagraphContentBase.prototype.GetContentWidthInRange = function(oStartPos, oEndPos, nDepth)
{
	return 0;
};
CParagraphContentBase.prototype.Recalculate_LineMetrics = function(PRS, ParaPr, _CurLine, _CurRange)
{
};
CParagraphContentBase.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
{
};
CParagraphContentBase.prototype.Recalculate_Range_Spaces = function(PRSA, CurLine, CurRange, CurPage)
{
};
CParagraphContentBase.prototype.Recalculate_PageEndInfo = function(PRSI, _CurLine, _CurRange)
{
};
CParagraphContentBase.prototype.RecalculateEndInfo = function(oPRSI)
{

};
CParagraphContentBase.prototype.SaveRecalculateObject = function(Copy)
{
	var RecalcObj = new CRunRecalculateObject(this.StartLine, this.StartRange);
	return RecalcObj;
};
CParagraphContentBase.prototype.LoadRecalculateObject = function(RecalcObj, Parent)
{
	this.StartLine  = RecalcObj.StartLine;
	this.StartRange = RecalcObj.StartRange;
};
CParagraphContentBase.prototype.PrepareRecalculateObject = function()
{
};
/**
 * Пустой ли заданный отрезок
 * @param nCurLine {number}
 * @param nCurRange {number}
 * @returns {boolean}
 */
CParagraphContentBase.prototype.IsEmptyRange = function(nCurLine, nCurRange)
{
	return true;
};
CParagraphContentBase.prototype.Check_Range_OnlyMath = function(Checker, CurRange, CurLine)
{
};
/**
 * Проверяем является ли элемент в заданной позиции неинлайновой формулой
 * @param {number} nMathPos
 * @return {boolean}
 */
CParagraphContentBase.prototype.CheckMathPara = function(nMathPos)
{
	return false;
};
CParagraphContentBase.prototype.ProcessNotInlineObjectCheck = function(oChecker)
{
};
CParagraphContentBase.prototype.CheckNotInlineObject = function(nMathPos, nDirection)
{
	return false;
};
CParagraphContentBase.prototype.Check_PageBreak = function()
{
	return false;
};
/**
 * Проверяем нужно ли разрывать страницу после заданного PageBreak элемента
 * @param oPBChecker {CParagraphCheckSplitPageOnPageBreak}
 * @returns {boolean}
 */
CParagraphContentBase.prototype.CheckSplitPageOnPageBreak = function(oPBChecker)
{
	return false;
};
CParagraphContentBase.prototype.recalculateCursorPosition = function(positionCalculator, isCurrent)
{
};
CParagraphContentBase.prototype.RecalculateMinMaxContentWidth = function(MinMax)
{
};
CParagraphContentBase.prototype.Get_Range_VisibleWidth = function(RangeW, _CurLine, _CurRange)
{
};
CParagraphContentBase.prototype.Shift_Range = function(Dx, Dy, _CurLine, _CurRange, _CurPage)
{
};
//----------------------------------------------------------------------------------------------------------------------
// Функции отрисовки
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentBase.prototype.Draw_HighLights = function(PDSH)
{
};
CParagraphContentBase.prototype.Draw_Elements = function(PDSE)
{
};
CParagraphContentBase.prototype.Draw_Lines = function(PDSL)
{
};
CParagraphContentBase.prototype.SkipDraw = function(PDS)
{
};
//----------------------------------------------------------------------------------------------------------------------
// Функции для работы с курсором
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentBase.prototype.IsCursorPlaceable = function()
{
	return false;
};
CParagraphContentBase.prototype.Cursor_Is_Start = function()
{
	return true;
};
CParagraphContentBase.prototype.Cursor_Is_NeededCorrectPos = function()
{
	return true;
};
CParagraphContentBase.prototype.Cursor_Is_End = function()
{
	return true;
};
CParagraphContentBase.prototype.IsStartPos = function(contentPos, depth)
{
	return true;
};
CParagraphContentBase.prototype.IsEndPos = function(contentPos, depth)
{
	return true;
};
/**
 * TODO: Надо объединить эту функцию с  IsCursorPlaceable, поскольку они по смыслу одинаковые
 * и сделать тут по умолчанию false
 */
CParagraphContentBase.prototype.CanPlaceCursorInside = function()
{
	return true;
};
CParagraphContentBase.prototype.MoveCursorToStartPos = function()
{
};
CParagraphContentBase.prototype.MoveCursorToEndPos = function(SelectFromEnd)
{
};
CParagraphContentBase.prototype.getParagraphContentPosByXY = function(searchState)
{
	return false;
};
CParagraphContentBase.prototype.Get_ParaContentPos = function(bSelection, bStart, ContentPos, bUseCorrection)
{
};
CParagraphContentBase.prototype.Set_ParaContentPos = function(ContentPos, Depth)
{
};
CParagraphContentBase.prototype.Get_PosByElement = function(Class, ContentPos, Depth, UseRange, Range, Line)
{
	if (this === Class)
		return true;

	return false;
};
CParagraphContentBase.prototype.Get_ElementByPos = function(ContentPos, Depth)
{
	return this;
};
CParagraphContentBase.prototype.Get_ClassesByPos = function(Classes, ContentPos, Depth)
{
	Classes.push(this);
};
CParagraphContentBase.prototype.GetPosByDrawing = function(Id, ContentPos, Depth)
{
	return false;
};
CParagraphContentBase.prototype.Get_RunElementByPos = function(ContentPos, Depth)
{
	return null;
};
CParagraphContentBase.prototype.Get_LastRunInRange = function(_CurLine, _CurRange)
{
	return null;
};
CParagraphContentBase.prototype.Get_LeftPos = function(SearchPos, ContentPos, Depth, UseContentPos)
{
};
CParagraphContentBase.prototype.Get_RightPos = function(SearchPos, ContentPos, Depth, UseContentPos, StepEnd)
{
};
CParagraphContentBase.prototype.Get_WordStartPos = function(SearchPos, ContentPos, Depth, UseContentPos)
{
};
CParagraphContentBase.prototype.Get_WordEndPos = function(SearchPos, ContentPos, Depth, UseContentPos, StepEnd)
{
};
CParagraphContentBase.prototype.Get_EndRangePos = function(_CurLine, _CurRange, SearchPos, Depth)
{
	return false;
};
CParagraphContentBase.prototype.Get_StartRangePos = function(_CurLine, _CurRange, SearchPos, Depth)
{
	return false;
};
CParagraphContentBase.prototype.Get_StartRangePos2 = function(_CurLine, _CurRange, ContentPos, Depth)
{
};
CParagraphContentBase.prototype.Get_EndRangePos2 = function(_CurLine, _CurRange, ContentPos, Depth)
{
};
CParagraphContentBase.prototype.Get_StartPos = function(ContentPos, Depth)
{
};
CParagraphContentBase.prototype.Get_EndPos = function(BehindEnd, ContentPos, Depth)
{
};
CParagraphContentBase.prototype.MoveCursorOutsideElement = function(isBefore)
{
	var oParent = this.GetParent();
	if (!oParent)
		return;

	var nPosInParent = this.GetPosInParent(oParent);

	if (isBefore)
	{
		if (nPosInParent <= 0)
		{
			if (this.SetThisElementCurrent)
				this.SetThisElementCurrent();

			this.MoveCursorToStartPos();
		}
		else
		{
			var oElement = oParent.GetElement(nPosInParent - 1);
			if (oElement.IsCursorPlaceable())
			{
				if (oElement.SetThisElementCurrent)
					oElement.SetThisElementCurrent();

				oElement.MoveCursorToEndPos();
			}
			else
			{
				if (this.SetThisElementCurrent)
					this.SetThisElementCurrent();

				this.MoveCursorToStartPos();
			}
		}
	}
	else
	{
		if (nPosInParent >= oParent.GetElementsCount() - 1)
		{
			if (this.SetThisElementCurrent)
				this.SetThisElementCurrent();

			this.MoveCursorToEndPos();
		}
		else
		{
			var oElement = oParent.GetElement(nPosInParent + 1);
			if (oElement.IsCursorPlaceable())
			{
				if (oElement.SetThisElementCurrent)
					oElement.SetThisElementCurrent();

				oElement.MoveCursorToStartPos();
			}
			else
			{
				if (this.SetThisElementCurrent)
					this.SetThisElementCurrent();

				this.MoveCursorToEndPos();
			}
		}
	}
};
//----------------------------------------------------------------------------------------------------------------------
// Функции для работы с селектом
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentBase.prototype.Set_SelectionContentPos = function(StartContentPos, EndContentPos, Depth, StartFlag, EndFlag)
{
};
CParagraphContentBase.prototype.RemoveSelection = function()
{
};
CParagraphContentBase.prototype.SelectAll = function(Direction)
{
};
CParagraphContentBase.prototype.drawSelectionInRange = function(line, range, drawState)
{
};
CParagraphContentBase.prototype.IsSelectionEmpty = function(CheckEnd)
{
	return true;
};
CParagraphContentBase.prototype.Selection_CheckParaEnd = function()
{
	return false;
};
CParagraphContentBase.prototype.IsSelectedAll = function(Props)
{
	return true;
};
CParagraphContentBase.prototype.IsSelectedFromStart = function()
{
	return true;
};
CParagraphContentBase.prototype.IsSelectedToEnd = function()
{
	return true;
};
/**
 * Функция коррекции селекта, чтобы убрать из селекта плавающие объекты, идущие в начале
 * @param nDirection {number} - направление селекта
 * @returns {boolean}
 */
CParagraphContentBase.prototype.SkipAnchorsAtSelectionStart = function(nDirection)
{
	return true;
};
CParagraphContentBase.prototype.Selection_CheckParaContentPos = function(ContentPos)
{
	return true;
};
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentBase.prototype.GetCurrentParaPos = function(align)
{
	return new CParaPos(this.StartRange, this.StartLine, 0, 0);
};
CParagraphContentBase.prototype.Get_TextPr = function(ContentPos, Depth)
{
	return new CTextPr();
};
CParagraphContentBase.prototype.Get_FirstTextPr = function(bByPos)
{
	return new CTextPr();
};
CParagraphContentBase.prototype.SetReviewType = function(ReviewType, RemovePrChange)
{
};
CParagraphContentBase.prototype.SetReviewTypeWithInfo = function(ReviewType, ReviewInfo)
{
};
CParagraphContentBase.prototype.CheckRevisionsChanges = function(Checker, ContentPos, Depth)
{
};
CParagraphContentBase.prototype.AcceptRevisionChanges = function(Type, bAll)
{
};
CParagraphContentBase.prototype.RejectRevisionChanges = function(Type, bAll)
{
};
CParagraphContentBase.prototype.GetTextPr = function(ContentPos, Depth)
{
	return this.Get_TextPr(ContentPos, Depth);
};
CParagraphContentBase.prototype.ApplyTextPr = function(oTextPr, isIncFontSize, isApplyToAll)
{
	return this.Apply_TextPr(oTextPr, isIncFontSize, isApplyToAll);
};
/**
 * Функция для поиска внутри элементов параграфа
 * @param {AscCommonWord.CParagraphSearch} oParaSearch
 */
CParagraphContentBase.prototype.Search = function(oParaSearch)
{
};
CParagraphContentBase.prototype.AddSearchResult = function(oSearchResult, isStart, oContentPos, nDepth)
{
};
CParagraphContentBase.prototype.ClearSearchResults = function()
{
};
CParagraphContentBase.prototype.RemoveSearchResult = function(oSearchResult)
{
};
CParagraphContentBase.prototype.GetSearchElementId = function(bNext, bUseContentPos, ContentPos, Depth)
{
	return null;
};
CParagraphContentBase.prototype.Check_NearestPos = function(ParaNearPos, Depth)
{
};
CParagraphContentBase.prototype.RestartSpellCheck = function()
{
};
CParagraphContentBase.prototype.GetDirectTextPr = function()
{
	return null;
};
CParagraphContentBase.prototype.GetAllAnnotationMarks = function(marks)
{
	return marks ? marks : [];
};
CParagraphContentBase.prototype.GetAllFields = function(isUseSelection, arrFields)
{
	return arrFields ? arrFields : [];
};
CParagraphContentBase.prototype.GetAllSeqFieldsByType = function(sType, aFields)
{
};
/**
 * Проверяем можно ли добавлять комментарий по заданому селекту
 * @returns {boolean}
 */
CParagraphContentBase.prototype.CanAddComment = function()
{
	return true;
};
/**
 * Получаем позицию заданного элемента в документе
 * @param {?Array} arrPos
 * @returns {Array}
 */
CParagraphContentBase.prototype.GetDocumentPositionFromObject = function(arrPos)
{
	if (!arrPos)
		arrPos = [];

	var oParagraph = this.GetParagraph();
	if (oParagraph)
	{
		if (arrPos.length > 0)
		{
			var oParaContentPos = oParagraph.Get_PosByElement(this);
			if (oParaContentPos)
			{
				var nDepth = oParaContentPos.GetDepth();
				while (nDepth > 0)
				{
					var Pos = oParaContentPos.Get(nDepth);
					oParaContentPos.SetDepth(nDepth - 1);
					var Class = oParagraph.Get_ElementByPos(oParaContentPos);
					nDepth--;

					arrPos.splice(0, 0, {Class : Class, Position : Pos});
				}
				arrPos.splice(0, 0, {Class : this.Paragraph, Position : oParaContentPos.Get(0)});
			}

			this.Paragraph.GetDocumentPositionFromObject(arrPos);
		}
		else
		{
			this.Paragraph.GetDocumentPositionFromObject(arrPos);

			var oParaContentPos = this.Paragraph.Get_PosByElement(this);
			if (oParaContentPos)
			{
				arrPos.push({Class : this.Paragraph, Position : oParaContentPos.Get(0)});

				var nDepth    = oParaContentPos.GetDepth();
				var nCurDepth = 1;
				while (nCurDepth <= nDepth)
				{
					var Pos = oParaContentPos.Get(nCurDepth);
					oParaContentPos.SetDepth(nCurDepth - 1);
					var Class = this.Paragraph.Get_ElementByPos(oParaContentPos);
					++nCurDepth;

					arrPos.push({Class : Class, Position : Pos});
				}
			}
		}
	}

	return arrPos;
};
/**
 * Получаем массив всех конент контролов, внутри которых лежит данный класс
 * @returns {Array}
 */
CParagraphContentBase.prototype.GetParentContentControls = function()
{
	var oDocPos = this.GetDocumentPositionFromObject();
	oDocPos.push({Class : this, Pos : 0});

	var arrContentControls = [];
	for (var nIndex = 0, nCount = oDocPos.length; nIndex < nCount; ++nIndex)
	{
		if (oDocPos[nIndex].Class instanceof CInlineLevelSdt)
			arrContentControls.push(oDocPos[nIndex].Class);
		else if (oDocPos[nIndex].Class instanceof CDocumentContent && oDocPos[nIndex].Class.Parent instanceof CBlockLevelSdt)
			arrContentControls.push(oDocPos[nIndex].Class.Parent);
	}

	return arrContentControls;
};
/**
 * Проверяем есть ли выделение внутри объекта
 * @returns {boolean}
 */
CParagraphContentBase.prototype.IsSelectionUse = function()
{
	return false;
};
/**
 * Начинается ли элемент с новой строки
 * @returns {boolean}
 */
CParagraphContentBase.prototype.IsStartFromNewLine = function()
{
	return false;
};
/**
 * Удаляем из параграфа заданный элемент, если он тут есть
 * @param element
 */
CParagraphContentBase.prototype.RemoveElement = function(element)
{
};
/**
 * Пробегаемся по все ранам с заданной функцией
 * @param fCheck - функция проверки содержимого рана
 * @param {AscWord.CParagraphContentPos} oStartPos
 * @param {AscWord.CParagraphContentPos} oEndPos
 * @param {number} nDepth
 * @param {?AscWord.CParagraphContentPos} oCurrentPos
 * @param {boolean} [isForward=false]
 * @returns {boolean}
 */
CParagraphContentBase.prototype.CheckRunContent = function(fCheck, oStartPos, oEndPos, nDepth, oCurrentPos, isForward)
{
	return false;
};
/**
 * Собираем сложные поля параграфа
 * @param {AscWord.ParagraphComplexFieldStack} oComplexFields
 */
CParagraphContentBase.prototype.ProcessComplexFields = function(oComplexFields)
{
};
/**
 * Собираем информацию о выделенной части документа
 * @param oInfo {CSelectedElementsInfo}
 * @param oContentPos
 * @param nDepth
 */
CParagraphContentBase.prototype.GetSelectedElementsInfo = function(oInfo, oContentPos, nDepth)
{
};
/**
 * Проверяем является ли данный элемент цельным, т.е. его нальзя разбить на части и
 * @returns {boolean}
 */
CParagraphContentBase.prototype.IsSolid = function()
{
	return true;
};
/**
 * Корректируем позицию внутри контента, для элементов с содержимым
 */
CParagraphContentBase.prototype.CorrectContentPos = function()
{
};
/**
 * Получаем самый первый ран в параграфе
 * @returns {?ParaRun}
 */
CParagraphContentBase.prototype.GetFirstRun = function()
{
	return null;
};
/**
 * Делаем данный элемент, состоящим из одного рана и возвращаем его, либо возвращаем null
 * @returns {?ParaRun}
 */
CParagraphContentBase.prototype.MakeSingleRunElement = function()
{
	return null;
};
/**
 * Очищаем полностью содержимое данного элемента
 * !!!ПУСТОЙ РАН ТУТ НЕ ДОБАВЛЯЕТСЯ!!!
 */
CParagraphContentBase.prototype.ClearContent = function()
{
};
/**
 * Получаем позиции до и после первого элемента у рана заданного типа
 * @param nType {number}
 * @param oStartPos {AscWord.CParagraphContentPos}
 * @param oEndPos {AscWord.CParagraphContentPos}
 * @param nDepth {number} глубина данного элемента
 * @returns {boolean}
 */
CParagraphContentBase.prototype.GetFirstRunElementPos = function(nType, oStartPos, oEndPos, nDepth)
{
	return false;
};
/**
 * @param isRecalculated
 */
CParagraphContentBase.prototype.SetIsRecalculated = function(isRecalculated)
{
};
/**
 * Устанавливаем текущие позиции на текущий элемент
 */
CParagraphContentBase.prototype.SetThisElementCurrentInParagraph = function()
{
	var oParagraph = this.GetParagraph();
	if (!this.IsCursorPlaceable() || !oParagraph)
		return;

	let contentPos = this.Paragraph.Get_PosByElement(this);
	if (!contentPos)
		return;
	
	// Дополним полученную позицию текущей в текущем элементе
	this.Get_ParaContentPos(false, false, contentPos, false);

	this.Paragraph.Set_ParaContentPos(contentPos, true, -1, -1, false);
};
CParagraphContentBase.prototype.createDuplicateForSmartArt = function(oPr)
{
	return this.Copy(false, oPr, false);
};
/**
 * Подсчитываем на сколько элементов разбивается данный элемент с заданным сепаратором
 * @param oEngine {CTextToTableEngine}
 */
CParagraphContentBase.prototype.CalculateTextToTable = function(oEngine){};

CParagraphContentBase.prototype.GetAllPermRangeMarks = function(marks)
{
	return [];
};
CParagraphContentBase.prototype.IsUseInDocument = function()
{
	return !!(this.Paragraph
		&& this.Paragraph.IsUseInDocument()
		&& this.IsUseInParagraph());
};
CParagraphContentBase.prototype.IsUseInParagraph = function()
{
	return (this.Paragraph && !!this.Paragraph.Get_PosByElement(this));
};

/**
 * Это базовый класс для элементов содержимого(контент) параграфа, у которых есть свое содержимое.
 * @constructor
 * @extends {CParagraphContentBase}
 */
function CParagraphContentWithContentBase()
{
	CParagraphContentBase.call(this);
    
    // Массив Lines разделен на три части
    // 1. Состоит из одного элемента, означающего количество строк
    // 2. Количество элементов указывается в первой части, каждый элемент означает относительный сдвиг начала информации 
    //    о строке в 3 части (поэтому первый элемент всегда равен 0).    
    // 3. Сама информация о начале и конце отрезка в строке. Каждый отрезок представлен парой StartPos, EndPos.
    //
    // Пример. 2 строки, в первой строке 3 отрезка, во второй строке 1 отрезок
    // this.Lines = [2, 0, 6, 0, 15, 15, 17, 17, 20, 20, 25];

	this.Lines = [0];

    this.StartLine   = -1;
    this.StartRange  = -1;
}

CParagraphContentWithContentBase.prototype = Object.create(CParagraphContentBase.prototype);
CParagraphContentWithContentBase.prototype.constructor = CParagraphContentWithContentBase;

CParagraphContentWithContentBase.prototype.Recalculate_Reset = function(StartRange, StartLine)
{
    this.StartLine   = StartLine;
    this.StartRange  = StartRange;

    this.protected_ClearLines();
};

CParagraphContentWithContentBase.prototype.protected_ClearLines = function()
{
	this.Lines = [0];
};

CParagraphContentWithContentBase.prototype.protected_GetRangeOffset = function(LineIndex, RangeIndex)
{
    return (1 + this.Lines[0] + this.Lines[1 + LineIndex] + RangeIndex * 2);
};

CParagraphContentWithContentBase.prototype.protected_GetRangeStartPos = function(LineIndex, RangeIndex)
{
    return this.Lines[this.protected_GetRangeOffset(LineIndex, RangeIndex)];
};

CParagraphContentWithContentBase.prototype.protected_GetRangeEndPos = function(LineIndex, RangeIndex)
{
    return this.Lines[this.protected_GetRangeOffset(LineIndex, RangeIndex) + 1];
};

CParagraphContentWithContentBase.prototype.protected_GetLinesCount = function()
{
    return this.Lines[0];
};

CParagraphContentWithContentBase.prototype.protected_GetRangesCount = function(LineIndex)
{
    if (LineIndex === this.Lines[0] - 1)
        return (this.Lines.length - this.Lines[1 + LineIndex] - (this.Lines[0] + 1)) / 2;
    else
        return (this.Lines[1 + LineIndex + 1] - this.Lines[1 + LineIndex]) / 2;
};

CParagraphContentWithContentBase.prototype.getRangePos = function(line, range)
{
	let _line  = line - this.StartLine;
	let _range = _line ? range : range - this.StartRange;
	
	return [
		this.protected_GetRangeStartPos(_line, _range),
		this.protected_GetRangeEndPos(_line, _range),
	];
};
CParagraphContentWithContentBase.prototype.GetLinesCount = function()
{
	return this.protected_GetLinesCount();
};

// Здесь предполагается, что строки с номерами меньше, чем LineIndex заданы, а также заданы и отрезки в строке 
// LineIndex, с номерами меньшими, чем RangeIndex. В данной функции удаляются все записи, которые идут после LineIndex,
// RangeIndex. Т.е. удаляются все строки, с номерами больше, чем LineIndex, и в строке LineIndex удаляются все отрезки 
// с номерами больше, чем RangeIndex. Возвращается позиция предпоследнего отрезка, либо 0.
CParagraphContentWithContentBase.prototype.protected_AddRange = function(LineIndex, RangeIndex)
{
    // Удаляем лишние записи о строках и отрезках
    if (this.Lines[0] >= LineIndex + 1)
    {
        var RangeOffset = this.protected_GetRangeOffset(LineIndex, 0) + RangeIndex * 2;
        this.Lines.splice(RangeOffset, this.Lines.length - RangeOffset);

        if (this.Lines[0] !== LineIndex + 1 && 0 === RangeIndex)
            this.Lines.splice(LineIndex + 1, this.Lines[0] - LineIndex);
        else if (this.Lines[0] !== LineIndex + 1 && 0 !== RangeIndex)
        {
            this.Lines.splice(LineIndex + 2, this.Lines[0] - LineIndex - 1);
            this.Lines[0] = LineIndex + 1;
        }
    }

    if (0 === RangeIndex)
    {
        if (this.Lines[0] !== LineIndex + 1)
        {
            // Добавляем информацию о новой строке, сначала ее относительный сдвиг, потом меняем само количество строк
            var OffsetValue = this.Lines.length - LineIndex - 1;
            this.Lines.splice(LineIndex + 1, 0, OffsetValue);
            this.Lines[0] = LineIndex + 1;
        }
    }
    
    var RangeOffset = 1 + this.Lines[0] + this.Lines[LineIndex + 1] + RangeIndex * 2; // this.protected_GetRangeOffset(LineIndex, RangeIndex);
    
    // Резервируем место для StartPos и EndPos заданного отрезка
    this.Lines[RangeOffset + 0] = 0;
    this.Lines[RangeOffset + 1] = 0;    
    
    if (0 !== LineIndex || 0 !== RangeIndex)
        return this.Lines[RangeOffset - 1];
    else
        return 0;
};

// Заполняем добавленный отрезок значениями
CParagraphContentWithContentBase.prototype.protected_FillRange = function(LineIndex, RangeIndex, StartPos, EndPos)
{
    var RangeOffset = this.protected_GetRangeOffset(LineIndex, RangeIndex);
    this.Lines[RangeOffset + 0] = StartPos;
    this.Lines[RangeOffset + 1] = EndPos;
};
CParagraphContentWithContentBase.prototype.protected_FillRangeEndPos = function(LineIndex, RangeIndex, EndPos)
{
    var RangeOffset = this.protected_GetRangeOffset(LineIndex, RangeIndex);
    this.Lines[RangeOffset + 1] = EndPos;
};
CParagraphContentWithContentBase.prototype.private_UpdateSpellChecking = function()
{
	if (this.Paragraph)
	{
		this.Paragraph.SpellChecker.ClearCollector();
		this.Paragraph.RecalcInfo.NeedSpellCheck();
	}
};
CParagraphContentWithContentBase.prototype.private_UpdateShapeText = function()
{
	if (this.Paragraph)
		this.Paragraph.RecalcInfo.NeedShapeText();
};
CParagraphContentWithContentBase.prototype.SelectThisElement = function(nDirection, isUseInnerSelection)
{
	if (!this.Paragraph)
		return false;

	var ContentPos = this.Paragraph.Get_PosByElement(this);
	if (!ContentPos)
		return false;

	var StartPos = ContentPos.Copy();
	var EndPos   = ContentPos.Copy();

	if (isUseInnerSelection)
	{
		this.Get_ParaContentPos(true, true, StartPos, false);
		this.Get_ParaContentPos(true, false, EndPos, false);
	}
	else
	{
		this.Get_StartPos(StartPos, StartPos.GetDepth() + 1);
		this.Get_EndPos(true, EndPos, EndPos.GetDepth() + 1);
	}

	if (nDirection < 0)
	{
		let Temp = StartPos;
		StartPos = EndPos;
		EndPos   = Temp;
	}

	this.Paragraph.Selection.Use   = true;
	this.Paragraph.Selection.Start = false;
	this.Paragraph.Set_ParaContentPos(StartPos, true, -1, -1);
	this.Paragraph.Set_SelectionContentPos(StartPos, EndPos, false);
	this.Paragraph.Document_SetThisElementCurrent(false);

	return true;
};
CParagraphContentWithContentBase.prototype.SetThisElementCurrent = function()
{
	let paragraph = this.GetParagraph();
	if (!paragraph)
		return;

	var ContentPos = paragraph.Get_PosByElement(this);
	if (!ContentPos)
		return;

	var StartPos = ContentPos.Copy();
	this.Get_StartPos(StartPos, StartPos.GetDepth() + 1);

	paragraph.Set_ParaContentPos(StartPos, true, -1, -1, false);
	paragraph.Document_SetThisElementCurrent(false);
};
CParagraphContentWithContentBase.prototype.IsThisElementCurrent = function()
{
	if (!this.Paragraph)
		return false;

	let oParaPos = this.Paragraph.GetPosByElement(this);
	if (!oParaPos)
		return false;

	if (!this.Paragraph.IsSelectionUse())
	{
		let oCurPos = this.Paragraph.Get_ParaContentPos(false, false, false);

		if (!oParaPos.IsPartOf(oCurPos))
			return false;
	}
	else
	{
		let oStartPos = this.Paragraph.Get_ParaContentPos(true, true, false);
		let oEndPos   = this.Paragraph.Get_ParaContentPos(true, false, false);

		if (!oParaPos.IsPartOf(oStartPos) || !oParaPos.IsPartOf(oEndPos))
			return false;
	}

	return this.Paragraph.IsThisElementCurrent();
};
CParagraphContentWithContentBase.prototype.GetStartPosInParagraph = function()
{
	if (!this.Paragraph)
		return null;

	let oContentPos = this.Paragraph.GetPosByElement(this);
	if (!oContentPos)
		return null;

	let oResultPos = oContentPos.Copy();
	this.Get_StartPos(oResultPos, oResultPos.GetDepth() + 1);
	return oResultPos;
};
CParagraphContentWithContentBase.prototype.GetEndPosInParagraph = function()
{
	if (!this.Paragraph)
		return null;

	let oContentPos = this.Paragraph.GetPosByElement(this);
	if (!oContentPos)
		return null;

	let oResultPos = oContentPos.Copy();
	this.Get_EndPos(true, oResultPos, oResultPos.GetDepth() + 1);
	return oResultPos;
};
CParagraphContentWithContentBase.prototype.protected_GetPrevRangeEndPos = function(LineIndex, RangeIndex)
{
    var RangeCount  = this.protected_GetRangesCount(LineIndex - 1);
    var RangeOffset = this.protected_GetRangeOffset(LineIndex - 1, RangeCount - 1);

    return LineIndex == 0 && RangeIndex == 0 ? 0 : this.Lines[RangeOffset + 1];
};
CParagraphContentWithContentBase.prototype.updateTrackRevisions = function()
{
	if (this.Paragraph)
		this.Paragraph.updateTrackRevisions();
};
CParagraphContentWithContentBase.prototype.CanSplit = function()
{
	return true;
};
CParagraphContentWithContentBase.prototype.PreDelete = function(isDeep)
{
};
CParagraphContentWithContentBase.prototype.private_UpdateDocumentOutline = function()
{
	if (this.Paragraph)
		this.Paragraph.UpdateDocumentOutline();
};
CParagraphContentWithContentBase.prototype.IsSolid = function()
{
	return false;
};
CParagraphContentWithContentBase.prototype.ProcessNotInlineObjectCheck = function(oChecker)
{
	oChecker.Result = false;
	oChecker.Found  = true;
};
CParagraphContentWithContentBase.prototype.OnContentChange = function()
{
	let oParent = this.GetParent();
	if (oParent)
	{
		oParent.OnContentChange();
	}
	else
	{
		let oParagraph = this.GetParagraph();
		if (oParagraph)
			oParagraph.OnContentChange();
	}
};
CParagraphContentWithContentBase.prototype.OnTextPrChange = function()
{
	let oParent = this.GetParent();
	if (oParent && oParent.OnTextPrChange)
	{
		oParent.OnTextPrChange();
	}
	else
	{
		let oParagraph = this.GetParagraph();
		if (oParagraph)
			oParagraph.OnTextPrChange();
	}
};

/**
 * Это базовый класс для элементов параграфа, которые сами по себе могут содержать элементы параграфа.
 * @constructor
 * @extends {CParagraphContentWithContentBase}
 */
function CParagraphContentWithParagraphLikeContent()
{
	CParagraphContentWithContentBase.call(this);

    this.Type              = undefined;
    this.Paragraph         = null;                  // Ссылка на родительский класс параграф.
    this.m_oContentChanges = new AscCommon.CContentChanges(); // Список изменений(добавление/удаление элементов)
    this.Content           = [];                    // Содержимое данного элемента.

    this.State             = new CParaRunState();   // Состояние курсора/селекта.
    this.Selection         = this.State.Selection;  // Для более быстрого и более простого обращения к селекту.

    this.NearPosArray      = [];
    this.SearchMarks       = [];
}

CParagraphContentWithParagraphLikeContent.prototype = Object.create(CParagraphContentWithContentBase.prototype);
CParagraphContentWithParagraphLikeContent.prototype.constructor = CParagraphContentWithParagraphLikeContent;

CParagraphContentWithParagraphLikeContent.prototype.Get_Type = function()
{
    return this.Type;
};
CParagraphContentWithParagraphLikeContent.prototype.Copy = function(Selected, oPr)
{
	var NewElement = new this.constructor();

	var StartPos = 0;
	var EndPos   = this.Content.length - 1;

	if (true === Selected && true === this.State.Selection.Use)
	{
		StartPos = this.State.Selection.StartPos;
		EndPos   = this.State.Selection.EndPos;

		if (StartPos > EndPos)
		{
			StartPos = this.State.Selection.EndPos;
			EndPos   = this.State.Selection.StartPos;
		}
	}

	let newElementPos = 0;
	for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
	{
		let newItems = this.Content[CurPos].Copy(Selected && (StartPos === CurPos || EndPos === CurPos), oPr);
		if (Array.isArray(newItems))
		{
			for (let newIndex = 0, newCount = newItems.length; newIndex < newCount; ++newIndex)
			{
				NewElement.AddToContent(newElementPos++, newItems[newIndex]);
			}
		}
		else if (newItems)
		{
			NewElement.AddToContent(newElementPos++, newItems);
		}
	}

	return NewElement;
};
CParagraphContentWithParagraphLikeContent.prototype.IsPlaceHolder = function()
{
	return false;
};
CParagraphContentWithParagraphLikeContent.prototype.GetSelectedContent = function(oSelectedContent)
{
	var oNewElement = new this.constructor();

	var nStartPos = this.State.Selection.StartPos;
	var nEndPos   = this.State.Selection.EndPos;

	if (nStartPos > nEndPos)
	{
		nStartPos = this.State.Selection.EndPos;
		nEndPos   = this.State.Selection.StartPos;
	}

	var nItemPos = 0;
	for (var nPos = nStartPos, nItemPos = 0; nPos <= nEndPos; ++nPos)
	{
		var oNewItem = this.Content[nPos].GetSelectedContent(oSelectedContent);
		if (oNewItem)
		{
			oNewElement.AddToContent(nItemPos, oNewItem);
			nItemPos++;
		}
	}

	if (0 === nItemPos)
		return null;

	return oNewElement;
};
CParagraphContentWithParagraphLikeContent.prototype.CopyContent = function(Selected)
{
    var CopyContent = [];

    var StartPos = 0;
    var EndPos = this.Content.length - 1;

    if (true === Selected && true === this.State.Selection.Use)
    {
        StartPos = this.State.Selection.StartPos;
        EndPos   = this.State.Selection.EndPos;
        if (StartPos > EndPos)
        {
            StartPos = this.State.Selection.EndPos;
            EndPos   = this.State.Selection.StartPos;
        }
    }

    for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
    {
        var Item = this.Content[CurPos];

        if ((StartPos === CurPos || EndPos === CurPos) && true !== Item.IsSelectedAll())
        {
            var Content = Item.CopyContent(Selected);
            for (var ContentPos = 0, ContentLen = Content.length; ContentPos < ContentLen; ContentPos++)
            {
                CopyContent.push(Content[ContentPos]);
            }
        }
        else
        {
            CopyContent.push(Item.Copy(false, {CopyReviewPr : true}));
        }
    }

    return CopyContent;
};
CParagraphContentWithParagraphLikeContent.prototype.Clear_ContentChanges = function()
{
    this.m_oContentChanges.Clear();
};
CParagraphContentWithParagraphLikeContent.prototype.Add_ContentChanges = function(Changes)
{
    this.m_oContentChanges.Add( Changes );
};
CParagraphContentWithParagraphLikeContent.prototype.Refresh_ContentChanges = function()
{
    this.m_oContentChanges.Refresh();
};
CParagraphContentWithParagraphLikeContent.prototype.Recalc_RunsCompiledPr = function()
{
    var Count = this.Content.length;
    for (var Pos = 0; Pos < Count; Pos++)
    {
        var Item = this.Content[Pos];

        if (Item.Recalc_RunsCompiledPr)
            Item.Recalc_RunsCompiledPr();
    }
};
CParagraphContentWithParagraphLikeContent.prototype.GetAllDrawingObjects = function(arrDrawingObjects)
{
	if (!arrDrawingObjects)
		arrDrawingObjects = [];

	for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		var oItem = this.Content[nPos];

		if (oItem.GetAllDrawingObjects)
			oItem.GetAllDrawingObjects(arrDrawingObjects);
	}

	return arrDrawingObjects;
};
CParagraphContentWithParagraphLikeContent.prototype.SetParagraph = function(Paragraph)
{
	this.Paragraph = Paragraph;

	var ContentLen = this.Content.length;
	for (var CurPos = 0; CurPos < ContentLen; CurPos++)
	{
		this.Content[CurPos].SetParagraph(Paragraph);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.SetParent = function(oParent)
{
	this.Parent = oParent;

	for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		if (this.Content[nPos].SetParent)
			this.Content[nPos].SetParent(this);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.SetCurrentPos = function(nPos)
{
	this.State.ContentPos = Math.max(0, Math.min(this.Content.length - 1, nPos));
};
CParagraphContentWithParagraphLikeContent.prototype.Is_Empty = function(oPr)
{
    for (var Index = 0, ContentLen = this.Content.length; Index < ContentLen; Index++)
    {
        if (false === this.Content[Index].Is_Empty(oPr))
            return false;
    }

    return true;
};
CParagraphContentWithParagraphLikeContent.prototype.Is_CheckingNearestPos = function()
{
    return (this.NearPosArray.length > 0);
};
CParagraphContentWithParagraphLikeContent.prototype.IsStartFromNewLine = function()
{
    if (this.Content.length < 0)
        return false;

    return this.Content[0].IsStartFromNewLine();
};
CParagraphContentWithParagraphLikeContent.prototype.GetSelectedElementsInfo = function(oInfo, oContentPos, nDepth)
{
	if (oContentPos)
	{
		var nPos = oContentPos.Get(nDepth);
		if (this.Content[nPos].GetSelectedElementsInfo)
			this.Content[nPos].GetSelectedElementsInfo(oInfo, oContentPos, nDepth + 1);
	}
	else
	{
		if (true === this.Selection.Use && (oInfo.IsCheckAllSelection() || this.Selection.StartPos === this.Selection.EndPos))
		{
			var nStartPos = this.Selection.StartPos < this.Selection.EndPos ? this.Selection.StartPos : this.Selection.EndPos;
			var nEndPos   = this.Selection.StartPos < this.Selection.EndPos ? this.Selection.EndPos : this.Selection.StartPos;

			for (var nPos = nStartPos; nPos <= nEndPos; ++nPos)
			{
				this.Content[nPos].GetSelectedElementsInfo(oInfo);
			}
		}
		else if (false === this.Selection.Use)
		{
			this.Content[this.State.ContentPos].GetSelectedElementsInfo(oInfo);
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetSelectedText = function(bAll, bClearText, oPr)
{
    var Str = "";
    for (var Pos = 0, Count = this.Content.length; Pos < Count; Pos++)
    {
        var _Str = this.Content[Pos].GetSelectedText(bAll, bClearText, oPr);

        if (null === _Str)
            return null;

        Str += _Str;
    }

    return Str;
};
CParagraphContentWithParagraphLikeContent.prototype.GetSelectDirection = function()
{
    if (true !== this.Selection.Use)
        return 0;

    if (this.Selection.StartPos < this.Selection.EndPos)
        return 1;
    else if (this.Selection.StartPos > this.Selection.EndPos)
        return -1;

    return this.Content[this.Selection.StartPos].GetSelectDirection();
};
CParagraphContentWithParagraphLikeContent.prototype.Get_TextPr = function(_ContentPos, Depth)
{
    if ( undefined === _ContentPos )
        return this.Content[0].Get_TextPr();
    else
        return this.Content[_ContentPos.Get(Depth)].Get_TextPr(_ContentPos, Depth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.Get_FirstTextPr = function(bByPos)
{
	var oElement = null;
	if (this.Content.length > 0)
	{
		if (true === bByPos)
		{
			if (true === this.Selection.Use)
			{
				if (this.Selection.StartPos > this.Selection.EndPos)
					oElement = this.Content[this.Selection.EndPos];
				else
					oElement = this.Content[this.Selection.StartPos];
			}
			else
			{
				oElement = this.Content[this.State.ContentPos];
			}
		}
		else
		{
			for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
			{
				if (this.Content[nPos].IsCursorPlaceable())
				{
					oElement = this.Content[nPos];
					break;
				}
			}
		}
	}

	if (null !== oElement && undefined !== oElement)
	{
		if (para_Run === oElement.Type)
			return oElement.Get_TextPr();
		else
			return oElement.Get_FirstTextPr();
	}

	return new CTextPr();
};
CParagraphContentWithParagraphLikeContent.prototype.Get_CompiledTextPr = function(Copy)
{
    var TextPr = null;

    if (true === this.State.Selection)
    {
        var StartPos = this.State.Selection.StartPos;
        var EndPos   = this.State.Selection.EndPos;

        if (StartPos > EndPos)
        {
            StartPos = this.State.Selection.EndPos;
            EndPos   = this.State.Selection.StartPos;
        }

        TextPr = this.Content[StartPos].Get_CompiledTextPr(Copy);

        while (null === TextPr && StartPos < EndPos)
        {
            StartPos++;
            TextPr = this.Content[StartPos].Get_CompiledTextPr(Copy);
        }

        for (var CurPos = StartPos + 1; CurPos <= EndPos; CurPos++)
        {
            var CurTextPr = this.Content[CurPos].Get_CompiledPr(false);

            if (null !== CurTextPr)
                TextPr = TextPr.Compare(CurTextPr);
        }
    }
    else
    {
        var CurPos = this.State.ContentPos;

        if (CurPos >= 0 && CurPos < this.Content.length)
            TextPr = this.Content[CurPos].Get_CompiledTextPr(Copy);
    }

    return TextPr;
};
CParagraphContentWithParagraphLikeContent.prototype.Check_Content = function()
{
    // Данная функция запускается при чтении файла. Заглушка, на случай, когда в данном классе ничего не будет
    if (this.Content.length <= 0)
        this.Add_ToContent(0, new ParaRun(), false);
};
CParagraphContentWithParagraphLikeContent.prototype.Add_ToContent = function(Pos, Item, UpdatePosition)
{
    this.Content.splice(Pos, 0, Item);
    this.updateTrackRevisions();
	this.private_UpdateDocumentOutline();
    this.private_CheckUpdateBookmarks([Item]);
	this.private_UpdateSelectionPosOnAdd(Pos, 1);

    if (false !== UpdatePosition)
    {
		// Также передвинем всем метки переносов страниц и строк
        var LinesCount = this.protected_GetLinesCount();
        for (var CurLine = 0; CurLine < LinesCount; CurLine++)
        {
            var RangesCount = this.protected_GetRangesCount(CurLine);
            for (var CurRange = 0; CurRange < RangesCount; CurRange++)
            {
                var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
                var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

                if (StartPos > Pos)
                    StartPos++;

                if (EndPos > Pos)
                    EndPos++;

                this.protected_FillRange(CurLine, CurRange, StartPos, EndPos);
            }

            // Особый случай, когда мы добавляем элемент в самый последний ран
            if (Pos === this.Content.length - 1 && LinesCount - 1 === CurLine)
            {
                this.protected_FillRangeEndPos(CurLine, RangesCount - 1, this.protected_GetRangeEndPos(CurLine, RangesCount - 1) + 1);
            }
        }
    }

    // Обновляем позиции в NearestPos
    var NearPosLen = this.NearPosArray.length;
    for (var Index = 0; Index < NearPosLen; Index++)
    {
        var HyperNearPos = this.NearPosArray[Index];
        var ContentPos = HyperNearPos.NearPos.ContentPos;
        var Depth      = HyperNearPos.Depth;

        if (ContentPos.Data[Depth] >= Pos)
            ContentPos.Data[Depth]++;
    }

    // Обновляем позиции в поиске
    var SearchMarksCount = this.SearchMarks.length;
    for (var Index = 0; Index < SearchMarksCount; Index++)
    {
        var Mark       = this.SearchMarks[Index];
        var ContentPos = (true === Mark.Start ? Mark.SearchResult.StartPos : Mark.SearchResult.EndPos);
        var Depth      = Mark.Depth;

        if (ContentPos.Data[Depth] >= Pos)
            ContentPos.Data[Depth]++;
    }

	if (Item.SetParent)
		Item.SetParent(this);

    if (Item.SetParagraph)
    	Item.SetParagraph(this.GetParagraph());

	this.OnContentChange();
};
CParagraphContentWithParagraphLikeContent.prototype.ConcatContent = function (Items)
{
	let Pos = this.GetElementsCount();
	for (let i = 0; i < Items.length; ++i) {
		this.Add_ToContent(Pos + i, Items[i]);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.Remove_FromContent = function(Pos, Count, UpdatePosition)
{
	if (Count <= 0)
		return;

	for (var nIndex = Pos; nIndex < Pos + Count; ++nIndex)
	{
		this.Content[nIndex].PreDelete();
	}

	var DeletedItems = this.Content.slice(Pos, Pos + Count);
	this.Content.splice(Pos, Count);
    this.updateTrackRevisions();
	this.private_UpdateDocumentOutline();
	this.private_CheckUpdateBookmarks(DeletedItems);
	this.private_UpdateSelectionPosOnRemove(Pos, Count);

    if (false !== UpdatePosition)
    {
        // Также передвинем всем метки переносов страниц и строк
        var LinesCount = this.protected_GetLinesCount();
        for (var CurLine = 0; CurLine < LinesCount; CurLine++)
        {
            var RangesCount = this.protected_GetRangesCount(CurLine);
            for (var CurRange = 0; CurRange < RangesCount; CurRange++)
            {
                var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
                var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

                if (StartPos > Pos + Count)
                    StartPos -= Count;
                else if (StartPos > Pos)
                    StartPos = Math.max(0, Pos);

                if (EndPos >= Pos + Count)
                    EndPos -= Count;
                else if (EndPos >= Pos)
                    EndPos = Math.max(0, Pos);

                this.protected_FillRange(CurLine, CurRange, StartPos, EndPos);
            }
        }
    }

    // Обновляем позиции в NearestPos
    var NearPosLen = this.NearPosArray.length;
    for (var Index = 0; Index < NearPosLen; Index++)
    {
        var HyperNearPos = this.NearPosArray[Index];
        var ContentPos = HyperNearPos.NearPos.ContentPos;
        var Depth      = HyperNearPos.Depth;

        if (ContentPos.Data[Depth] > Pos + Count)
            ContentPos.Data[Depth] -= Count;
        else if (ContentPos.Data[Depth] > Pos)
            ContentPos.Data[Depth] = Math.max(0, Pos);
    }

    // Обновляем позиции в поиске
    var SearchMarksCount = this.SearchMarks.length;
    for (var Index = 0; Index < SearchMarksCount; Index++)
    {
        var Mark       = this.SearchMarks[Index];
        var ContentPos = (true === Mark.Start ? Mark.SearchResult.StartPos : Mark.SearchResult.EndPos);
        var Depth      = Mark.Depth;

        if (ContentPos.Data[Depth] > Pos + Count)
            ContentPos.Data[Depth] -= Count;
        else if (ContentPos.Data[Depth] > Pos)
            ContentPos.Data[Depth] = Math.max(0, Pos);
    }

	this.OnContentChange();
};
CParagraphContentWithParagraphLikeContent.prototype.Remove = function(Direction, bOnAddText)
{
	var Selection = this.State.Selection;

	if (true === Selection.Use)
	{
		var StartPos = Selection.StartPos;
		var EndPos   = Selection.EndPos;

		if (StartPos > EndPos)
		{
			StartPos = Selection.EndPos;
			EndPos   = Selection.StartPos;
		}

		var oTextPr = this.IsSelectedAll() ? this.GetDirectTextPr() : null;

		if (StartPos === EndPos)
		{
			if (this.Content[StartPos].IsSolid())
			{
				this.RemoveFromContent(StartPos, 1, true);
			}
			else
			{
				this.Content[StartPos].Remove(Direction, bOnAddText);
				
				let isTextDrag = this.Paragraph && this.Paragraph.LogicDocument ? this.Paragraph.LogicDocument.DragAndDropAction : false;
				if (StartPos !== this.Content.length - 1 && true === this.Content[StartPos].Is_Empty() && (!bOnAddText || isTextDrag))
				{
					this.RemoveFromContent(StartPos, 1, true);
					this.State.ContentPos = StartPos;
					this.Content[StartPos].MoveCursorToStartPos();
				}
				else
				{
					this.State.ContentPos = StartPos;
				}
			}
		}
		else
		{
			if (this.Content[EndPos].IsSolid())
			{
				this.RemoveFromContent(EndPos, 1, true);
			}
			else
			{
				this.Content[EndPos].Remove(Direction, bOnAddText);
				
				let isTextDrag = this.Paragraph && this.Paragraph.LogicDocument ? this.Paragraph.LogicDocument.DragAndDropAction : false;
				if (EndPos !== this.Content.length - 1
					&& true === this.Content[EndPos].Is_Empty()
					&& !(this.Content[StartPos] instanceof AscWord.CInlineLevelSdt)
					&& (!bOnAddText || isTextDrag))
				{
					this.Remove_FromContent(EndPos, 1, true);
				}
			}

			if (this.Paragraph && this.Paragraph.LogicDocument && true === this.Paragraph.LogicDocument.IsTrackRevisions())
			{
				for (var nCurPos = EndPos - 1; nCurPos > StartPos; --nCurPos)
				{
					if (para_Run === this.Content[nCurPos].Type)
					{
						if (para_Run == this.Content[nCurPos].Type && this.Content[nCurPos].CanDeleteInReviewMode())
							this.RemoveFromContent(nCurPos, 1);
						else
							this.Content[nCurPos].SetReviewType(reviewtype_Remove, true);
					}
					else
					{
						this.Content[nCurPos].Remove(Direction, bOnAddText);
						if (this.Content[nCurPos].IsEmpty())
							this.RemoveFromContent(nCurPos, 1);
					}
				}
			}
			else
			{
				for (var CurPos = EndPos - 1; CurPos > StartPos; CurPos--)
				{
					this.Remove_FromContent(CurPos, 1, true);
				}
			}

			if (this.Content[StartPos].IsSolid())
			{
				this.RemoveFromContent(StartPos, 1, true);
			}
			else
			{
				this.Content[StartPos].Remove(Direction, bOnAddText);

				if (true === this.Content[StartPos].Is_Empty())
					this.Remove_FromContent(StartPos, 1, true);
			}
		}
		this.RemoveSelection();

		if (this.Content.length <= 0)
		{
			this.AddToContent(0, new ParaRun(this.GetParagraph(), false));
			this.State.ContentPos = 0;

			if (oTextPr)
				this.Content[0].SetPr(oTextPr);
		}
		else
		{
			this.State.ContentPos = StartPos;
		}
	}
	else
	{
		var ContentPos = this.State.ContentPos;

		// TODO: Пересмотреть эту проверку. Выделять целиком КК нужно, если курсор изначально находился снаружи,
		//       а если он был внутри, то удалять нужно именно внутреннее содержимое
		if ((true === this.Cursor_Is_Start() || true === this.Cursor_Is_End())
			&& !this.IsEmpty()
			&& (!this.CanPlaceCursorInside()
				|| !(this instanceof CInlineLevelSdt)
				|| (!this.IsComplexForm() && !this.IsTextForm() && !this.IsComboBox() && !this.IsDatePicker())))
		{
			this.SelectAll();
			this.SelectThisElement(1);
		}
		else
		{
			while (false === this.Content[ContentPos].Remove(Direction, bOnAddText))
			{
				if (Direction < 0)
					ContentPos--;
				else
					ContentPos++;

				if (ContentPos < 0 || ContentPos >= this.Content.length)
					break;

				if (Direction < 0)
					this.Content[ContentPos].MoveCursorToEndPos(false);
				else
					this.Content[ContentPos].MoveCursorToStartPos();
				
				// Если после перемещения в следующий элемент появился селект, то мы останавливаем удаление,
				// чтобы пользователь видел, что он удаляет
				if (this.Content[ContentPos].IsSelectionUse())
					return true;
			}

			if (ContentPos < 0 || ContentPos >= this.Content.length)
				return false;
			else
			{
				if (ContentPos !== this.Content.length - 1 && true === this.Content[ContentPos].Is_Empty() && true !== bOnAddText)
					this.Remove_FromContent(ContentPos, 1, true);

				this.State.ContentPos = ContentPos;
			}
		}
	}

	return true;
};
CParagraphContentWithParagraphLikeContent.prototype.GetCurrentParaPos = function(align)
{
    var CurPos = this.State.ContentPos;

    if (CurPos >= 0 && CurPos < this.Content.length)
        return this.Content[CurPos].GetCurrentParaPos(align);

    return new CParaPos(this.StartRange, this.StartLine, 0, 0);
};
CParagraphContentWithParagraphLikeContent.prototype.Apply_TextPr = function(TextPr, IncFontSize, ApplyToAll)
{
    if ( true === ApplyToAll )
    {
        var ContentLen = this.Content.length;
        for ( var CurPos = 0; CurPos < ContentLen; CurPos++ )
        {
            this.Content[CurPos].Apply_TextPr( TextPr, IncFontSize, true );
        }
    }
    else
    {
        var Selection = this.State.Selection;

        if ( true === Selection.Use )
        {
            var StartPos = Selection.StartPos;
            var EndPos   = Selection.EndPos;

            if ( StartPos === EndPos )
            {
                var NewElements = this.Content[EndPos].Apply_TextPr( TextPr, IncFontSize, false );

                if ( para_Run === this.Content[EndPos].Type )
                {
                    var CenterRunPos = this.private_ReplaceRun( EndPos, NewElements );

                    if ( StartPos === this.State.ContentPos )
                        this.State.ContentPos = CenterRunPos;

                    // Подправим метки селекта
                    Selection.StartPos = CenterRunPos;
                    Selection.EndPos   = CenterRunPos;
                }
            }
            else
            {
                var Direction = 1;
                if ( StartPos > EndPos )
                {
                    var Temp = StartPos;
                    StartPos = EndPos;
                    EndPos = Temp;

                    Direction = -1;
                }

                for ( var CurPos = StartPos + 1; CurPos < EndPos; CurPos++ )
                {
                    this.Content[CurPos].Apply_TextPr( TextPr, IncFontSize, false );
                }


                var NewElements = this.Content[EndPos].Apply_TextPr( TextPr, IncFontSize, false );
                if ( para_Run === this.Content[EndPos].Type )
                    this.private_ReplaceRun( EndPos, NewElements );

                var NewElements = this.Content[StartPos].Apply_TextPr( TextPr, IncFontSize, false );
                if ( para_Run === this.Content[StartPos].Type )
                    this.private_ReplaceRun( StartPos, NewElements );

                // Подправим селект. Заметим, что метки выделения изменяются внутри функции Add_ToContent
                // за счет того, что EndPos - StartPos > 1.
                if ( Selection.StartPos < Selection.EndPos && true === this.Content[Selection.StartPos].IsSelectionEmpty() )
                    Selection.StartPos++;
                else if ( Selection.EndPos < Selection.StartPos && true === this.Content[Selection.EndPos].IsSelectionEmpty() )
                    Selection.EndPos++;

                if ( Selection.StartPos < Selection.EndPos && true === this.Content[Selection.EndPos].IsSelectionEmpty() )
                    Selection.EndPos--;
                else if ( Selection.EndPos < Selection.StartPos && true === this.Content[Selection.StartPos].IsSelectionEmpty() )
                    Selection.StartPos--;
            }
        }
        else
        {
            var Pos = this.State.ContentPos;
            var Element = this.Content[Pos];
            var NewElements = Element.Apply_TextPr( TextPr, IncFontSize, false );

            if ( para_Run === Element.Type )
            {
                var CenterRunPos = this.private_ReplaceRun( Pos, NewElements );
                this.State.ContentPos = CenterRunPos;
            }
        }
    }
};
CParagraphContentWithParagraphLikeContent.prototype.private_ReplaceRun = function(Pos, NewRuns)
{
    // По логике, можно удалить Run, стоящий в позиции Pos и добавить все раны, которые не null в массиве NewRuns.
    // Но, согласно работе ParaRun.Apply_TextPr, в массиве всегда идет ровно 3 рана (возможно null). Второй ран
    // всегда не null. Первый не null ран и есть ран, идущий в позиции Pos.

    var LRun = NewRuns[0];
    var CRun = NewRuns[1];
    var RRun = NewRuns[2];

    // CRun - всегда не null
    var CenterRunPos = Pos;

    if (null !== LRun)
    {
        this.Add_ToContent(Pos + 1, CRun, true);
        CenterRunPos = Pos + 1;
    }
    else
    {
        // Если LRun - null, значит CRun - это и есть тот ран который стоит уже в позиции Pos
    }

    if (null !== RRun)
        this.Add_ToContent(CenterRunPos + 1, RRun, true);

    return CenterRunPos;
};
CParagraphContentWithParagraphLikeContent.prototype.Clear_TextPr = function()
{
    var Count = this.Content.length;
    for ( var Index = 0; Index < Count; Index++ )
    {
        var Item = this.Content[Index];
        Item.Clear_TextPr();
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Check_NearestPos = function(ParaNearPos, Depth)
{
    var HyperNearPos = new CParagraphElementNearPos();
    HyperNearPos.NearPos = ParaNearPos.NearPos;
    HyperNearPos.Depth   = Depth;

    this.NearPosArray.push(HyperNearPos);
    ParaNearPos.Classes.push(this);

    var CurPos = ParaNearPos.NearPos.ContentPos.Get(Depth);
    this.Content[CurPos].Check_NearestPos(ParaNearPos, Depth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.Get_DrawingObjectRun = function(Id)
{
    var Run = null;

    var ContentLen = this.Content.length;
    for ( var CurPos = 0; CurPos < ContentLen; CurPos++ )
    {
        var Element = this.Content[CurPos];
        Run = Element.Get_DrawingObjectRun( Id );
        if (null !== Run)
            return Run;
    }

    return Run;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_DrawingObjectContentPos = function(Id, ContentPos, Depth)
{
    for (var Index = 0, ContentLen = this.Content.length; Index < ContentLen; Index++)
    {
        var Element = this.Content[Index];

        if (true === Element.Get_DrawingObjectContentPos(Id, ContentPos, Depth + 1))
        {
            ContentPos.Update2(Index, Depth);
            return true;
        }
    }

    return false;
};
CParagraphContentWithParagraphLikeContent.prototype.GetRunByElement = function(oRunElement)
{
	for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		var oResult = this.Content[nPos].GetRunByElement(oRunElement);
		if (oResult)
			return oResult;
	}

	return null;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_Layout = function(DrawingLayout, UseContentPos, ContentPos, Depth)
{
    var CurLine  = DrawingLayout.Line - this.StartLine;
    var CurRange = ( 0 === CurLine ? DrawingLayout.Range - this.StartRange : DrawingLayout.Range );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    var CurContentPos = ( true === UseContentPos ? ContentPos.Get(Depth) : -1 );

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Get_Layout(DrawingLayout, ( CurPos === CurContentPos ? true : false ), ContentPos, Depth + 1 );

        if (true === DrawingLayout.Layout)
            return;
    }
};
CParagraphContentWithParagraphLikeContent.prototype.GetNextRunElements = function(oRunElements, isUseContentPos, nDepth)
{
	if (oRunElements.IsEnoughElements())
		return;

	var nCurPos     = true === isUseContentPos ? oRunElements.ContentPos.Get(nDepth) : 0;
	var nContentLen = this.Content.length;
	
	if (nCurPos >= nContentLen)
		return;

	oRunElements.UpdatePos(nCurPos, nDepth);
	this.Content[nCurPos].GetNextRunElements(oRunElements, isUseContentPos, nDepth + 1);

	nCurPos++;

	while (nCurPos < nContentLen)
	{
		if (oRunElements.IsEnoughElements())
			return;

		oRunElements.UpdatePos(nCurPos, nDepth);
		this.Content[nCurPos].GetNextRunElements(oRunElements, false, nDepth + 1);

		nCurPos++;
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetPrevRunElements = function(oRunElements, isUseContentPos, nDepth)
{
	if (oRunElements.IsEnoughElements())
		return;

	var nCurPos = true === isUseContentPos ? oRunElements.ContentPos.Get(nDepth) : this.Content.length - 1;
	
	if (nCurPos < 0)
		return;

	oRunElements.UpdatePos(nCurPos, nDepth);
	this.Content[nCurPos].GetPrevRunElements(oRunElements, isUseContentPos, nDepth + 1);

	nCurPos--;

	while (nCurPos >= 0)
	{
		if (oRunElements.IsEnoughElements())
			return;

		oRunElements.UpdatePos(nCurPos, nDepth);
		this.Content[nCurPos].GetPrevRunElements(oRunElements, false, nDepth + 1);

		nCurPos--;
	}
};
CParagraphContentWithParagraphLikeContent.prototype.CollectDocumentStatistics = function(ParaStats)
{
	var Count = this.Content.length;
	for (var Index = 0; Index < Count; Index++)
		this.Content[Index].CollectDocumentStatistics(ParaStats);
};
CParagraphContentWithParagraphLikeContent.prototype.Create_FontMap = function(Map)
{
    var Count = this.Content.length;
    for (var Index = 0; Index < Count; Index++)
        this.Content[Index].Create_FontMap( Map );
};
CParagraphContentWithParagraphLikeContent.prototype.Get_AllFontNames = function(AllFonts)
{
    var Count = this.Content.length;
    for (var Index = 0; Index < Count; Index++)
        this.Content[Index].Get_AllFontNames( AllFonts );
};
CParagraphContentWithParagraphLikeContent.prototype.Clear_TextFormatting = function()
{
    for (var Pos = 0, Count = this.Content.length; Pos < Count; Pos++)
    {
        var Item = this.Content[Pos];
        Item.Clear_TextFormatting();
    }
};
CParagraphContentWithParagraphLikeContent.prototype.CanAddDropCap = function()
{
	for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		var bResult = this.Content[nPos].CanAddDropCap();
		if (null !== bResult)
			return bResult;
	}

	return null;
};
CParagraphContentWithParagraphLikeContent.prototype.CheckSelectionForDropCap = function(isUsePos, oEndPos, nDepth)
{
	var nEndPos = isUsePos ? oEndPos.Get(nDepth) : this.Content.length - 1;
	for (var nPos = 0; nPos <= nEndPos; ++nPos)
	{
		if (!this.Content[nPos].CheckSelectionForDropCap(nPos === nEndPos && isUsePos, oEndPos, nDepth + 1))
			return false;
	}

	return true;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_TextForDropCap = function(DropCapText, UseContentPos, ContentPos, Depth)
{
    var EndPos = ( true === UseContentPos ? ContentPos.Get(Depth) : this.Content.length - 1 );

    for ( var Pos = 0; Pos <= EndPos; Pos++ )
    {
        this.Content[Pos].Get_TextForDropCap( DropCapText, (true === UseContentPos && Pos === EndPos ? true : false), ContentPos, Depth + 1 );

        if ( true === DropCapText.Mixed && ( true === DropCapText.Check || DropCapText.Runs.length > 0 ) )
            return;
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Get_StartTabsCount = function(TabsCounter)
{
    var ContentLen = this.Content.length;
    for ( var Pos = 0; Pos < ContentLen; Pos++ )
    {
        var Element = this.Content[Pos];
        if ( false === Element.Get_StartTabsCount( TabsCounter ) )
            return false;
    }

    return true;
};
CParagraphContentWithParagraphLikeContent.prototype.Remove_StartTabs = function(TabsCounter)
{
    var ContentLen = this.Content.length;
    for ( var Pos = 0; Pos < ContentLen; Pos++ )
    {
        var Element = this.Content[Pos];
        if ( false === Element.Remove_StartTabs( TabsCounter ) )
            return false;
    }

    return true;
};
CParagraphContentWithParagraphLikeContent.prototype.Document_UpdateInterfaceState = function()
{
    if ( true === this.Selection.Use )
    {
        var StartPos = this.Selection.StartPos;
        var EndPos   = this.Selection.EndPos;
        if (StartPos > EndPos)
        {
            StartPos = this.Selection.EndPos;
            EndPos   = this.Selection.StartPos;
        }

        for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
        {
            var Element = this.Content[CurPos];

            if (true !== Element.IsSelectionEmpty() && Element.Document_UpdateInterfaceState)
                Element.Document_UpdateInterfaceState();
        }
    }
    else
    {
        var Element = this.Content[this.State.ContentPos];
        if (Element.Document_UpdateInterfaceState)
            Element.Document_UpdateInterfaceState();
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Split = function(ContentPos, Depth)
{
    var Element = new this.constructor();

    var CurPos = ContentPos.Get(Depth);

    var TextPr = this.Get_TextPr(ContentPos, Depth);

    // Разделяем текущий элемент (возвращается правая, отделившаяся часть, если она null, тогда заменяем
    // ее на пустой ран с заданными настройками).
    var NewElement = this.Content[CurPos].Split( ContentPos, Depth + 1 );

    if ( null === NewElement )
    {
        NewElement = new ParaRun();
        NewElement.Set_Pr( TextPr.Copy() );
    }

    // Теперь делим на три части:
    // 1. До элемента с номером CurPos включительно (оставляем эту часть в исходном параграфе)
    // 2. После элемента с номером CurPos (добавляем эту часть в новый параграф)
    // 3. Новый элемент, полученный после разделения элемента с номером CurPos, который мы
    //    добавляем в начало нового параграфа.

    var NewContent = this.Content.slice( CurPos + 1 );
    this.Remove_FromContent( CurPos + 1, this.Content.length - CurPos - 1, false );

    // Добавляем в новую гиперссылку Right элемент и NewContent
    var Count = NewContent.length;
    for ( var Pos = 0; Pos < Count; Pos++ )
        Element.Add_ToContent( Pos, NewContent[Pos], false );

    Element.Add_ToContent( 0, NewElement, false );

    return Element;
};
CParagraphContentWithParagraphLikeContent.prototype.SplitNoDuplicate = function(oContentPos, nDepth, oNewParagraph)
{
	if (this.IsSolid())
		return;

	var nCurPos = oContentPos.Get(nDepth);

	this.Content[nCurPos].SplitNoDuplicate(oContentPos, nDepth + 1, oNewParagraph);

	var arrNewContent = this.Content.slice(nCurPos + 1);
	this.RemoveFromContent(nCurPos + 1, this.Content.length - nCurPos - 1, false);

	var nNewPos = oNewParagraph.Content.length;
	for (var nPos = 0, nCount = arrNewContent.length; nPos < nCount; ++nPos)
		oNewParagraph.AddToContent(nNewPos + nPos, arrNewContent[nPos], false);
};
CParagraphContentWithParagraphLikeContent.prototype.Get_Text = function(Text)
{
    var ContentLen = this.Content.length;
    for ( var CurPos = 0; CurPos < ContentLen; CurPos++ )
    {
        this.Content[CurPos].Get_Text( Text );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.GetAllPermRangeMarks = function(marks)
{
	if (!marks)
		marks = [];
	
	for (let i = 0, count = this.Content.length; i < count; ++i)
	{
		this.Content[i].GetAllPermRangeMarks(marks);
	}
	
	return marks;
};
CParagraphContentWithParagraphLikeContent.prototype.GetAllParagraphs = function(Props, ParaArray)
{
    var ContentLen = this.Content.length;
    for (var CurPos = 0; CurPos < ContentLen; CurPos++)
    {
        if (this.Content[CurPos].GetAllParagraphs)
            this.Content[CurPos].GetAllParagraphs(Props, ParaArray);
    }
};
CParagraphContentWithParagraphLikeContent.prototype.GetAllTables = function(oProps, arrTables)
{
	if (!arrTables)
		arrTables = [];

	for (var nCurPos = 0, nLen = this.Content.length; nCurPos < nLen; ++nCurPos)
	{
		if (this.Content[nCurPos].GetAllTables)
			this.Content[nCurPos].GetAllTables(oProps, arrTables);
	}

	return arrTables;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_ClassesByPos = function(Classes, ContentPos, Depth)
{
    Classes.push(this);
    var CurPos = ContentPos.Get(Depth);
    if (0 <= CurPos && CurPos <= this.Content.length - 1)
        this.Content[CurPos].Get_ClassesByPos(Classes, ContentPos, Depth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.GetContentLength = function()
{
    return this.Content.length;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_Parent = function()
{
    if (!this.Paragraph)
        return null;

    var ContentPos = this.Paragraph.Get_PosByElement(this);
    if (!ContentPos || ContentPos.GetDepth() < 0)
        return null;

    ContentPos.DecreaseDepth(1);
    return this.Paragraph.Get_ElementByPos(ContentPos);
};
CParagraphContentWithParagraphLikeContent.prototype.Get_PosInParent = function(Parent)
{
    var _Parent = (_Parent? Parent : this.Get_Parent());
    if (!_Parent)
        return -1;

    for (var Pos = 0, Count = _Parent.Content.length; Pos < Count; ++Pos)
    {
        if (this === _Parent.Content[Pos])
            return Pos;
    }

    return -1;
};
CParagraphContentWithParagraphLikeContent.prototype.Correct_Content = function()
{
	if (this.Paragraph && !this.Paragraph.CanCorrectContent())
		return;

    if (this.Content.length <= 0)
        this.Add_ToContent(0, new ParaRun(this.GetParagraph(), false));
};
CParagraphContentWithParagraphLikeContent.prototype.CorrectContent = function()
{
	if (this.Paragraph && !this.Paragraph.CanCorrectContent())
		return;

	this.Correct_Content();
};
CParagraphContentWithParagraphLikeContent.prototype.UpdateBookmarks = function(oManager)
{
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		this.Content[nIndex].UpdateBookmarks(oManager);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.RemoveTabsForTOC = function(_isTab)
{
	var isTab = _isTab;
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		if (this.Content[nIndex].RemoveTabsForTOC(isTab))
			isTab = true;
	}

	return isTab;
};
CParagraphContentWithParagraphLikeContent.prototype.RemoveAll = function()
{
	this.Remove_FromContent(0, this.Content.length);
};
/**
 * Обновляем позиции курсора и селекта во время добавления элементов
 * @param nPosition {number}
 * @param [nCount=1] {number}
 */
CParagraphContentWithParagraphLikeContent.prototype.private_UpdateSelectionPosOnAdd = function(nPosition, nCount)
{
	if (this.Content.length <= 0)
	{
		this.State.ContentPos   = 0;
		this.Selection.StartPos = 0;
		this.Selection.EndPos   = 0;
		return;
	}

	if (undefined === nCount || null === nCount)
		nCount = 1;

	if (this.State.ContentPos >= nPosition)
		this.State.ContentPos += nCount;

	if (this.Selection.StartPos >= nPosition)
		this.Selection.StartPos += nCount;

	if (this.Selection.EndPos >= nPosition)
		this.Selection.EndPos += nCount;

	this.Selection.StartPos = Math.max(0, Math.min(this.Content.length - 1, this.Selection.StartPos));
	this.Selection.EndPos   = Math.max(0, Math.min(this.Content.length - 1, this.Selection.EndPos));
	this.State.ContentPos   = Math.max(0, Math.min(this.Content.length - 1, this.State.ContentPos));
};
/**
 * Обновляем позиции курсора и селекта во время удаления элементов
 * @param nPosition {number}
 * @param nCount {number}
 */
CParagraphContentWithParagraphLikeContent.prototype.private_UpdateSelectionPosOnRemove = function(nPosition, nCount)
{
	if (this.State.ContentPos >= nPosition + nCount)
	{
		this.State.ContentPos -= nCount;
	}
	else if (this.State.ContentPos >= nPosition)
	{
		if (nPosition < this.Content.length)
			this.State.ContentPos = nPosition;
		else if (nPosition > 0)
			this.State.ContentPos = nPosition - 1;
		else
			this.State.ContentPos = 0;
	}

	if (this.Selection.StartPos <= this.Selection.EndPos)
	{
		if (this.Selection.StartPos >= nPosition + nCount)
			this.Selection.StartPos -= nCount;
		else if (this.Selection.StartPos >= nPosition)
			this.Selection.StartPos = nPosition;

		if (this.Selection.EndPos >= nPosition + nCount)
			this.Selection.EndPos -= nCount;
		else if (this.Selection.EndPos >= nPosition)
			this.Selection.StartPos = nPosition - 1;

		if (this.Selection.StartPos > this.Selection.EndPos)
		{
			this.Selection.Use = false;
			this.Selection.StartPos = 0;
			this.Selection.EndPos   = 0;
		}
	}
	else
	{
		if (this.Selection.EndPos >= nPosition + nCount)
			this.Selection.EndPos -= nCount;
		else if (this.Selection.EndPos >= nPosition)
			this.Selection.EndPos = nPosition;

		if (this.Selection.StartPos >= nPosition + nCount)
			this.Selection.StartPos -= nCount;
		else if (this.Selection.StartPos >= nPosition)
			this.Selection.StartPos = nPosition - 1;

		if (this.Selection.EndPos > this.Selection.StartPos)
		{
			this.Selection.Use = false;
			this.Selection.StartPos = 0;
			this.Selection.EndPos   = 0;
		}
	}

	this.Selection.StartPos = Math.max(0, Math.min(this.Content.length - 1, this.Selection.StartPos));
	this.Selection.EndPos   = Math.max(0, Math.min(this.Content.length - 1, this.Selection.EndPos));
	this.State.ContentPos   = Math.max(0, Math.min(this.Content.length - 1, this.State.ContentPos));
};
CParagraphContentWithParagraphLikeContent.prototype.AddToContent = function(nPos, oItem, isUpdatePositions)
{
	return this.Add_ToContent(nPos, oItem, isUpdatePositions);
};
CParagraphContentWithParagraphLikeContent.prototype.AddToContentToEnd = function(oItem, isUpdatePositions)
{
	return this.Add_ToContent(this.GetElementsCount(), oItem, isUpdatePositions);
};
CParagraphContentWithParagraphLikeContent.prototype.RemoveFromContent = function(nPos, nCount, isUpdatePositions)
{
	return this.Remove_FromContent(nPos, nCount, isUpdatePositions);
};
CParagraphContentWithParagraphLikeContent.prototype.GetComplexField = function(nType)
{
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		var oResult = this.Content[nIndex].GetComplexField(nType);
		if (oResult)
			return oResult;
	}
	return null;
};
CParagraphContentWithParagraphLikeContent.prototype.GetComplexFieldsArray = function(nType, arrComplexFields)
{
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		this.Content[nIndex].GetComplexFieldsArray(nType, arrComplexFields);
	}
};
//----------------------------------------------------------------------------------------------------------------------
// Функции пересчета
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
{
    if ( this.Paragraph !== PRS.Paragraph )
    {
        this.Paragraph = PRS.Paragraph;
        this.private_UpdateSpellChecking();
    }

    var CurLine  = PRS.Line - this.StartLine;
    var CurRange = ( 0 === CurLine ? PRS.Range - this.StartRange : PRS.Range );

    // Добавляем информацию о новом отрезке
    var RangeStartPos = this.protected_AddRange(CurLine, CurRange);
    var RangeEndPos   = 0;

    var ContentLen = this.Content.length;
    var Pos = RangeStartPos;
    for ( ; Pos < ContentLen; Pos++ )
    {
        var Item = this.Content[Pos];

		if (para_Math === Item.Type)
		{
			Item.Set_Inline(!this.CheckMathPara(Pos));
		}

        if ( ( 0 === Pos && 0 === CurLine && 0 === CurRange ) || Pos !== RangeStartPos )
        {
            Item.Recalculate_Reset( PRS.Range, PRS.Line );
        }

        PRS.Update_CurPos( Pos, Depth );
        Item.Recalculate_Range( PRS, ParaPr, Depth + 1 );

        if ( true === PRS.NewRange )
        {
            RangeEndPos = Pos;
            break;
        }
    }

    if ( Pos >= ContentLen )
    {
        RangeEndPos = Pos - 1;
    }

    this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
};
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_Set_RangeEndPos = function(PRS, PRP, Depth)
{
    var CurLine  = PRS.Line - this.StartLine;
    var CurRange = ( 0 === CurLine ? PRS.Range - this.StartRange : PRS.Range );
    var CurPos   = PRP.Get(Depth);

    this.protected_FillRangeEndPos(CurLine, CurRange, CurPos);

    this.Content[CurPos].Recalculate_Set_RangeEndPos( PRS, PRP, Depth + 1 );
};
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_SetRangeBounds = function(_CurLine, _CurRange, oStartPos, oEndPos, nDepth)
{
	let isStartPos = oStartPos && nDepth <= oStartPos.GetDepth();
	let isEndPos   = oEndPos && nDepth <= oEndPos.GetDepth();

	let nStartPos = isStartPos ?  oStartPos.Get(nDepth) : 0;
	let nEndPos   = isEndPos ? oEndPos.Get(nDepth) : this.Content.length - 1;

	var CurLine  = _CurLine - this.StartLine;
	var CurRange = 0 === CurLine ? _CurRange - this.StartRange : _CurRange;

	if (isStartPos)
	{
		this.protected_FillRangeEndPos(CurLine, CurRange, nEndPos);
	}
	else
	{
		this.protected_AddRange(CurLine, CurRange);
		this.protected_FillRange(CurLine, CurRange, nStartPos, nEndPos);
	}

	for (let nPos = nStartPos; nPos <= nEndPos; ++nPos)
	{
		let oItem = this.Content[nPos];
		if (nPos !== nStartPos)
			oItem.Recalculate_Reset(_CurRange, _CurLine);

		oItem.Recalculate_SetRangeBounds(_CurLine, _CurRange, nPos === nStartPos ? oStartPos : null, nPos === nEndPos ? oEndPos : null, nDepth + 1);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetContentWidthInRange = function(oStartPos, oEndPos, nDepth)
{
	let nWidth = 0;

	let nStartPos = oStartPos && nDepth <= oStartPos.GetDepth() ? oStartPos.Get(nDepth) : 0;
	let nEndPos   = oEndPos && nDepth <= oEndPos.GetDepth() ? oEndPos.Get(nDepth) : this.Content.length - 1;

	for (let nPos = nStartPos; nPos <= nEndPos; ++nPos)
	{
		nWidth += this.Content[nPos].GetContentWidthInRange(nPos === nStartPos ? oStartPos : null, nPos === nEndPos ? oEndPos : null, nDepth + 1);
	}

	return nWidth;
};
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_LineMetrics = function(PRS, ParaPr, _CurLine, _CurRange)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = (0 === CurLine ? _CurRange - this.StartRange : _CurRange);

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
    {
        this.Content[CurPos].Recalculate_LineMetrics(PRS, ParaPr, _CurLine, _CurRange);
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Recalculate_Range_Width( PRSC, _CurLine, _CurRange );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_Range_Spaces = function(PRSA, _CurLine, _CurRange, _CurPage)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Recalculate_Range_Spaces( PRSA, _CurLine, _CurRange, _CurPage );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_PageEndInfo = function(PRSI, _CurLine, _CurRange)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Recalculate_PageEndInfo( PRSI, _CurLine, _CurRange );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.RecalculateEndInfo = function(oPRSI)
{
	for (var nCurPos = 0, nCount = this.Content.length; nCurPos < nCount; ++nCurPos)
	{
		this.Content[nCurPos].RecalculateEndInfo(oPRSI);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.SaveRecalculateObject = function(Copy)
{
	var RecalcObj = new CRunRecalculateObject(this.StartLine, this.StartRange);
	RecalcObj.Save_Lines(this, Copy);
	RecalcObj.Save_Content(this, Copy);
	return RecalcObj;
};
CParagraphContentWithParagraphLikeContent.prototype.LoadRecalculateObject = function(RecalcObj)
{
    RecalcObj.Load_Lines( this );
    RecalcObj.Load_Content( this );
};
CParagraphContentWithParagraphLikeContent.prototype.PrepareRecalculateObject = function()
{
	this.protected_ClearLines();

	var Count = this.Content.length;
	for (var Index = 0; Index < Count; Index++)
	{
		this.Content[Index].PrepareRecalculateObject();
	}
};
CParagraphContentWithParagraphLikeContent.prototype.IsEmptyRange = function(_CurLine, _CurRange)
{
	var CurLine  = _CurLine - this.StartLine;
	var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

	var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
	var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

	for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
	{
		if (false === this.Content[CurPos].IsEmptyRange(_CurLine, _CurRange))
			return false;
	}

	return true;
};
CParagraphContentWithParagraphLikeContent.prototype.Check_Range_OnlyMath = function(Checker, _CurRange, _CurLine)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Check_Range_OnlyMath(Checker, _CurRange, _CurLine);

        if (false === Checker.Result)
            break;
    }
};
/**
 * Проверяем является ли элемент в заданной позиции неинлайновой формулой
 * @param {number} nMathPos
 * @return {boolean}
 */
CParagraphContentWithParagraphLikeContent.prototype.CheckMathPara = function(nMathPos)
{
	if (!this.Content[nMathPos] || para_Math !== this.Content[nMathPos].Type)
		return false;

	return this.CheckNotInlineObject(nMathPos);
};
CParagraphContentWithParagraphLikeContent.prototype.CheckNotInlineObject = function(nMathPos, nDirection)
{
	var oParent = this.GetParent();

	var oChecker = new CParagraphMathParaChecker();
	if (undefined === nDirection || -1 === nDirection)
	{
		oChecker.SetDirection(-1);
		for (var nCurPos = nMathPos - 1; nCurPos >= 0; --nCurPos)
		{
			this.Content[nCurPos].ProcessNotInlineObjectCheck(oChecker);
			if (oChecker.IsStop())
				break;
		}

		if (!oChecker.GetResult())
			return false;


		if (!oChecker.IsStop() && oParent && !oParent.CheckNotInlineObject(this.GetPosInParent(oParent), -1))
			return false
	}

	if (undefined === nDirection || 1 === nDirection)
	{
		oChecker.SetDirection(1);
		for (var nCurPos = nMathPos + 1, nCount = this.Content.length; nCurPos < nCount; ++nCurPos)
		{
			this.Content[nCurPos].ProcessNotInlineObjectCheck(oChecker);
			if (oChecker.IsStop())
				break;
		}

		if (!oChecker.GetResult())
			return false;

		if (!oChecker.IsStop() && oParent && !oParent.CheckNotInlineObject(this.GetPosInParent(oParent), 1))
			return false;
	}

	return true;
};
CParagraphContentWithParagraphLikeContent.prototype.Check_PageBreak = function()
{
    var Count = this.Content.length;
    for (var Pos = 0; Pos < Count; Pos++)
    {
        if (true === this.Content[Pos].Check_PageBreak())
            return true;
    }

    return false;
};
CParagraphContentWithParagraphLikeContent.prototype.CheckSplitPageOnPageBreak = function(oPBChecker)
{
	for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		if (this.Content[nPos].CheckSplitPageOnPageBreak(oPBChecker))
			return true;
	}

	return false;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_ParaPosByContentPos = function(ContentPos, Depth)
{
    var Pos = ContentPos.Get(Depth);

    return this.Content[Pos].Get_ParaPosByContentPos( ContentPos, Depth + 1 );
};
CParagraphContentWithParagraphLikeContent.prototype.recalculateCursorPosition = function(positionCalculator, isCurrent)
{
	let rangePos = this.getRangePos(positionCalculator.line, positionCalculator.range);
	let startPos = rangePos[0];
	let endPos   = rangePos[1];
	
	for (let pos = startPos; pos <= endPos; ++pos)
	{
		let item = this.Content[pos];
		item.recalculateCursorPosition(positionCalculator, isCurrent && pos === this.State.ContentPos);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.Refresh_RecalcData = function(Data)
{
    if (undefined !== this.Paragraph && null !== this.Paragraph)
        this.Paragraph.Refresh_RecalcData2(0);
};
CParagraphContentWithParagraphLikeContent.prototype.RecalculateMinMaxContentWidth = function(MinMax)
{
	var Count = this.Content.length;
	for (var Pos = 0; Pos < Count; Pos++)
	{
		this.Content[Pos].RecalculateMinMaxContentWidth(MinMax);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.Get_Range_VisibleWidth = function(RangeW, _CurLine, _CurRange)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Get_Range_VisibleWidth(RangeW, _CurLine, _CurRange);
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Shift_Range = function(Dx, Dy, _CurLine, _CurRange, _CurPage)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Shift_Range(Dx, Dy, _CurLine, _CurRange, _CurPage);
    }
};
//----------------------------------------------------------------------------------------------------------------------
// Функции отрисовки
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.Draw_HighLights = function(PDSH)
{
    var CurLine  = PDSH.Line - this.StartLine;
    var CurRange = ( 0 === CurLine ? PDSH.Range - this.StartRange : PDSH.Range );

    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        this.Content[CurPos].Draw_HighLights( PDSH );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Draw_Elements = function(PDSE)
{
	let textAlpha;
	let placeholderAlpha = this.IsPlaceHolder() && this.IsForm && this.IsForm();
	if (placeholderAlpha)
	{
		textAlpha = PDSE.Graphics.getTextGlobalAlpha();
		PDSE.Graphics.setTextGlobalAlpha(0.5);
	}

	var CurLine  = PDSE.Line - this.StartLine;
	var CurRange = (0 === CurLine ? PDSE.Range - this.StartRange : PDSE.Range);

	var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
	var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

	for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
	{
		this.Content[CurPos].Draw_Elements(PDSE);
	}

	if (placeholderAlpha)
		PDSE.Graphics.setTextGlobalAlpha(textAlpha);
};
CParagraphContentWithParagraphLikeContent.prototype.Draw_Lines = function(PDSL)
{
	var CurLine  = PDSL.Line - this.StartLine;
	var CurRange = ( 0 === CurLine ? PDSL.Range - this.StartRange : PDSL.Range );

	var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
	var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

	var nCurDepth = PDSL.CurDepth;
	for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
	{
		PDSL.CurPos.Update(CurPos, nCurDepth);
		PDSL.CurDepth = nCurDepth + 1;

		this.Content[CurPos].Draw_Lines(PDSL);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.SkipDraw = function(PDS)
{
	var CurLine  = PDS.Line - this.StartLine;
	var CurRange = (0 === CurLine ? PDS.Range - this.StartRange : PDS.Range);

	var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
	var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

	for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
	{
		this.Content[CurPos].SkipDraw(PDS);
	}
};
//----------------------------------------------------------------------------------------------------------------------
// Функции для работы с курсором
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.IsCursorPlaceable = function()
{
    return true;
};
CParagraphContentWithParagraphLikeContent.prototype.CanPlaceCursorInside = function()
{
	return true;
};
CParagraphContentWithParagraphLikeContent.prototype.IsCursorAtBegin = function()
{
	if (this.IsPlaceHolder())
		return true;

	return this.Cursor_Is_Start();
};
CParagraphContentWithParagraphLikeContent.prototype.IsCursorAtEnd = function()
{
	if (this.IsPlaceHolder())
		return true;

	return this.Cursor_Is_End();
};
CParagraphContentWithParagraphLikeContent.prototype.Cursor_Is_Start = function()
{
    var CurPos = 0;
    while ( CurPos < this.State.ContentPos && CurPos < this.Content.length - 1 )
    {
        if ( true === this.Content[CurPos].Is_Empty() )
            CurPos++;
        else
            return false;
    }

    return this.Content[CurPos].Cursor_Is_Start();
};
CParagraphContentWithParagraphLikeContent.prototype.Cursor_Is_NeededCorrectPos = function()
{
    return false;
};
CParagraphContentWithParagraphLikeContent.prototype.Cursor_Is_End = function()
{
    var CurPos = this.Content.length - 1;
    while ( CurPos > this.State.ContentPos && CurPos > 0 )
    {
        if ( true === this.Content[CurPos].Is_Empty() )
            CurPos--;
        else
            return false;
    }

    return this.Content[CurPos].Cursor_Is_End();
};
CParagraphContentWithParagraphLikeContent.prototype.IsStartPos = function(contentPos, depth)
{
	if (depth >= contentPos.Depth)
		return true;
	
	let pos = contentPos.Get(depth);
	if (!this.Content[pos])
		return false;
	
	if (pos !== 0)
		return false;
	
	return this.Content[pos].IsStartPos(contentPos, depth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.IsEndPos = function(contentPos, depth)
{
	if (depth >= contentPos.Depth)
		return true;
	
	let pos = contentPos.Get(depth);
	if (!this.Content[pos])
		return true;
	
	if (pos !== this.Content.length - 1)
		return false;
	
	return this.Content[pos].IsEndPos(contentPos, depth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.MoveCursorToStartPos = function()
{
    this.State.ContentPos = 0;

    if ( this.Content.length > 0 )
    {
        this.Content[0].MoveCursorToStartPos();
    }
};
CParagraphContentWithParagraphLikeContent.prototype.MoveCursorToEndPos = function(SelectFromEnd)
{
    var ContentLen = this.Content.length;

    if ( ContentLen > 0 )
    {
        this.State.ContentPos = ContentLen - 1;
        this.Content[ContentLen - 1].MoveCursorToEndPos( SelectFromEnd );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.getParagraphContentPosByXY = function(searchState)
{
	let rangePos = this.getRangePos(searchState.line, searchState.range);
	let startPos = rangePos[0];
	let endPos   = rangePos[1];
	for (let pos = startPos; pos <= endPos; ++pos)
	{
		this.Content[pos].getParagraphContentPosByXY(searchState);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.Get_ParaContentPos = function(bSelection, bStart, ContentPos, bUseCorrection)
{
	var Pos = ( true === bSelection ? ( true === bStart ? this.State.Selection.StartPos : this.State.Selection.EndPos ) : this.State.ContentPos );
	ContentPos.Add(Pos);

	if (Pos < 0 || Pos >= this.Content.length)
		return;

	this.Content[Pos].Get_ParaContentPos(bSelection, bStart, ContentPos, bUseCorrection);
};
CParagraphContentWithParagraphLikeContent.prototype.Set_ParaContentPos = function(ContentPos, Depth)
{
    var Pos = ContentPos.Get(Depth);

    if ( Pos >= this.Content.length )
        Pos = this.Content.length - 1;

    if ( Pos < 0 )
        Pos = 0;

    this.State.ContentPos = Pos;

    this.Content[Pos].Set_ParaContentPos( ContentPos, Depth + 1 );
};
CParagraphContentWithParagraphLikeContent.prototype.Get_PosByElement = function(Class, ContentPos, Depth, UseRange, Range, Line)
{
    if ( this === Class )
        return true;

    if (this.Content.length <= 0)
    	return false;

    var StartPos = 0;
    var EndPos   = this.Content.length - 1;

    if ( true === UseRange )
    {
        var CurLine  = Line - this.StartLine;
        var CurRange = ( 0 === CurLine ? Range - this.StartRange : Range );

        if (CurLine >= 0 && CurLine < this.protected_GetLinesCount() && CurRange >= 0 && CurRange < this.protected_GetRangesCount(CurLine))
        {
            StartPos = Math.min(this.Content.length - 1, Math.max(0, this.protected_GetRangeStartPos(CurLine, CurRange)));
            EndPos   = Math.min(this.Content.length - 1, Math.max(0, this.protected_GetRangeEndPos(CurLine, CurRange)));
        }
    }

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        var Element = this.Content[CurPos];

        ContentPos.Update( CurPos, Depth );

        if ( true === Element.Get_PosByElement(Class, ContentPos, Depth + 1, true, CurRange, CurLine) )
            return true;
    }

    return false;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_ElementByPos = function(ContentPos, Depth)
{
    if (Depth >= ContentPos.Depth)
        return this;

    var CurPos = ContentPos.Get(Depth);
    if (!this.Content[CurPos])
    	return null;

    return this.Content[CurPos].Get_ElementByPos(ContentPos, Depth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.ConvertParaContentPosToRangePos = function(oContentPos, nDepth)
{
	var nRangePos = 0;

	var nCurPos = oContentPos ? Math.max(0, Math.min(this.Content.length - 1, oContentPos.Get(nDepth))) : this.Content.length - 1;
	for (var nPos = 0; nPos < nCurPos; ++nPos)
	{
		if (this.Content[nPos] instanceof ParaRun)
			nRangePos++;

		nRangePos += this.Content[nPos].ConvertParaContentPosToRangePos(null);
	}

	if (this.Content[nCurPos])
	{
		if (this.Content[nPos] instanceof ParaRun)
			nRangePos++;

		nRangePos += this.Content[nCurPos].ConvertParaContentPosToRangePos(oContentPos, nDepth + 1);
	}
		
	return nRangePos;
};
CParagraphContentWithParagraphLikeContent.prototype.GetPosByDrawing = function(Id, ContentPos, Depth)
{
    var Count = this.Content.length;
    for ( var CurPos = 0; CurPos < Count; CurPos++ )
    {
        var Element = this.Content[CurPos];

        ContentPos.Update( CurPos, Depth );

        if ( true === Element.GetPosByDrawing(Id, ContentPos, Depth + 1) )
            return true;
    }

    return false;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_RunElementByPos = function(ContentPos, Depth)
{
    if ( undefined !== ContentPos )
    {
        var Pos = ContentPos.Get(Depth);

        return this.Content[Pos].Get_RunElementByPos( ContentPos, Depth + 1 );
    }
    else
    {
        var Count = this.Content.length;
        if ( Count <= 0 )
            return null;

        var Pos = 0;
        var Element = this.Content[Pos];

        while ( null === Element && Pos < Count - 1 )
            Element = this.Content[++Pos];

        return Element;
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Get_LastRunInRange = function(_CurLine, _CurRange)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    if (CurLine < this.protected_GetLinesCount() && CurRange < this.protected_GetRangesCount(CurLine))
    {
        var LastItem = this.Content[this.protected_GetRangeEndPos(CurLine, CurRange)];
        if ( undefined !== LastItem )
            return LastItem.Get_LastRunInRange(_CurLine, _CurRange);
    }

    return null;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_LeftPos = function(SearchPos, ContentPos, Depth, UseContentPos)
{
	if (this.Content.length <= 0)
		return false;

	var CurPos = ( true === UseContentPos ? ContentPos.Get(Depth) : this.Content.length - 1 );

	SearchPos.Pos.Update(CurPos, Depth);
	this.Content[CurPos].Get_LeftPos(SearchPos, ContentPos, Depth + 1, UseContentPos);

	if (true === SearchPos.Found)
		return true;

	CurPos--;

	if (CurPos >= 0 && this.Content[CurPos + 1].IsStopCursorOnEntryExit())
	{
		SearchPos.Pos.Update(CurPos, Depth);
		this.Content[CurPos].Get_EndPos(false, SearchPos.Pos, Depth + 1);
		SearchPos.Found = true;
		return true;
	}

	while (CurPos >= 0)
	{
		SearchPos.Pos.Update(CurPos, Depth);
		this.Content[CurPos].Get_LeftPos(SearchPos, ContentPos, Depth + 1, false);

		if (true === SearchPos.Found)
			return true;

		CurPos--;
	}

	return false;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_RightPos = function(SearchPos, ContentPos, Depth, UseContentPos, StepEnd)
{
	if (this.Content.length <= 0)
		return false;

	var CurPos = ( true === UseContentPos ? ContentPos.Get(Depth) : 0 );

	SearchPos.Pos.Update(CurPos, Depth);
	this.Content[CurPos].Get_RightPos(SearchPos, ContentPos, Depth + 1, UseContentPos, StepEnd);

	if (true === SearchPos.Found)
		return true;

	CurPos++;

	var Count = this.Content.length;
	if (CurPos < Count && this.Content[CurPos - 1].IsStopCursorOnEntryExit())
	{
		SearchPos.Pos.Update(CurPos, Depth);
		this.Content[CurPos].Get_StartPos(SearchPos.Pos, Depth + 1);
		SearchPos.Found = true;
		return true;
	}

	while (CurPos < this.Content.length)
	{
		SearchPos.Pos.Update(CurPos, Depth);
		this.Content[CurPos].Get_RightPos(SearchPos, ContentPos, Depth + 1, false, StepEnd);

		if (true === SearchPos.Found)
			return true;

		CurPos++;
	}

	return false;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_WordStartPos = function(SearchPos, ContentPos, Depth, UseContentPos)
{
	var CurPos = ( true === UseContentPos ? ContentPos.Get(Depth) : this.Content.length - 1 );

	this.Content[CurPos].Get_WordStartPos(SearchPos, ContentPos, Depth + 1, UseContentPos);

	if (true === SearchPos.UpdatePos)
		SearchPos.Pos.Update2(CurPos, Depth);

	if (true === SearchPos.Found)
		return;

	CurPos--;

	if (SearchPos.Shift && CurPos >= 0 && this.Content[CurPos].IsStopCursorOnEntryExit())
	{
		SearchPos.Found = true;
		return;
	}

	if (CurPos >= 0 && this.Content[CurPos + 1].IsStopCursorOnEntryExit())
	{
		this.Content[CurPos].Get_EndPos(false, SearchPos.Pos, Depth + 1);
		SearchPos.Pos.Update2(CurPos, Depth);
		SearchPos.Found = true;
		return;
	}

	while (CurPos >= 0)
	{
		var OldUpdatePos = SearchPos.UpdatePos;

		this.Content[CurPos].Get_WordStartPos(SearchPos, ContentPos, Depth + 1, false);

		if (true === SearchPos.UpdatePos)
			SearchPos.Pos.Update2(CurPos, Depth);
		else
			SearchPos.UpdatePos = OldUpdatePos;

		if (true === SearchPos.Found)
			return;

		CurPos--;

		if (SearchPos.Shift && CurPos >= 0 && this.Content[CurPos].IsStopCursorOnEntryExit())
		{
			SearchPos.Found = true;
			return;
		}

		if (CurPos >= 0 && this.Content[CurPos + 1].IsStopCursorOnEntryExit())
		{
			this.Content[CurPos].Get_EndPos(false, SearchPos.Pos, Depth + 1);
			SearchPos.Pos.Update2(CurPos, Depth);
			SearchPos.Found = true;
			return;
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.Get_WordEndPos = function(SearchPos, ContentPos, Depth, UseContentPos, StepEnd)
{
	var CurPos = ( true === UseContentPos ? ContentPos.Get(Depth) : 0 );

	this.Content[CurPos].Get_WordEndPos(SearchPos, ContentPos, Depth + 1, UseContentPos, StepEnd);

	if (true === SearchPos.UpdatePos)
		SearchPos.Pos.Update(CurPos, Depth);

	if (true === SearchPos.Found)
		return;

	CurPos++;

	var Count = this.Content.length;

	if (SearchPos.Shift && CurPos < Count && this.Content[CurPos].IsStopCursorOnEntryExit())
	{
		SearchPos.Found = true;
		return;
	}

	if (CurPos < Count && this.Content[CurPos - 1].IsStopCursorOnEntryExit())
	{
		this.Content[CurPos].Get_StartPos(SearchPos.Pos, Depth + 1);
		SearchPos.Pos.Update(CurPos, Depth);
		SearchPos.Found     = true;
		SearchPos.UpdatePos = true;
		return;
	}

	while (CurPos < Count)
	{
		var OldUpdatePos = SearchPos.UpdatePos;

		this.Content[CurPos].Get_WordEndPos(SearchPos, ContentPos, Depth + 1, false, StepEnd);

		if (true === SearchPos.UpdatePos)
			SearchPos.Pos.Update(CurPos, Depth);
		else
			SearchPos.UpdatePos = OldUpdatePos;

		if (true === SearchPos.Found)
			return;

		CurPos++;

		if (SearchPos.Shift && CurPos < Count && this.Content[CurPos].IsStopCursorOnEntryExit())
		{
			SearchPos.Found = true;
			return;
		}

		if (CurPos < Count && this.Content[CurPos - 1].IsStopCursorOnEntryExit())
		{
			this.Content[CurPos].Get_StartPos(SearchPos.Pos, Depth + 1);
			SearchPos.Pos.Update(CurPos, Depth);
			SearchPos.Found     = true;
			SearchPos.UpdatePos = true;
			return;
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.Get_EndRangePos = function(nCurLine, nCurRange, oSearchPos, nDepth)
{
	var _nCurLine  = nCurLine - this.StartLine;
	var _nCurRange = (0 === _nCurLine ? nCurRange - this.StartRange : nCurRange);

	var nStartPos = Math.max(0, Math.min(this.Content.length - 1, this.protected_GetRangeStartPos(_nCurLine, _nCurRange)));
	var nEndPos   = Math.min(this.Content.length - 1, Math.max(0, this.protected_GetRangeEndPos(_nCurLine, _nCurRange)));

	var bResult = false;
	for (var nPos = nEndPos; nPos >= nStartPos; --nPos)
	{
		if (this.Content[nPos].Get_EndRangePos(nCurLine, nCurRange, oSearchPos, nDepth + 1))
		{
			oSearchPos.Pos.Update(nPos, nDepth);
			bResult = true;
			break;
		}
	}

	return bResult;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_StartRangePos = function(nCurLine, nCurRange, oSearchPos, nDepth)
{
	var _nCurLine  = nCurLine - this.StartLine;
	var _nCurRange = ( 0 === _nCurLine ? nCurRange - this.StartRange : nCurRange );

	var nStartPos = Math.max(0, Math.min(this.Content.length - 1, this.protected_GetRangeStartPos(_nCurLine, _nCurRange)));
	var nEndPos   = Math.min(this.Content.length - 1, Math.max(0, this.protected_GetRangeEndPos(_nCurLine, _nCurRange)));

	var bResult = false;
	for (var nPos = nStartPos; nPos <= nEndPos; ++nPos)
	{
		if (this.Content[nPos].Get_StartRangePos(nCurLine, nCurRange, oSearchPos, nDepth + 1))
		{
			oSearchPos.Pos.Update(nPos, nDepth);
			bResult = true;
			break;
		}
	}

	return bResult;
};
CParagraphContentWithParagraphLikeContent.prototype.Get_StartRangePos2 = function(_CurLine, _CurRange, ContentPos, Depth)
{
    var CurLine  = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var Pos = this.protected_GetRangeStartPos(CurLine, CurRange);

    ContentPos.Update( Pos, Depth );

    this.Content[Pos].Get_StartRangePos2( _CurLine, _CurRange, ContentPos, Depth + 1 );
};
CParagraphContentWithParagraphLikeContent.prototype.Get_EndRangePos2 = function(_CurLine, _CurRange, ContentPos, Depth)
{
	var CurLine  = _CurLine - this.StartLine;
	var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

	var Pos = this.protected_GetRangeEndPos(CurLine, CurRange);
	ContentPos.Update(Pos, Depth);
	this.Content[Pos].Get_EndRangePos2(_CurLine, _CurRange, ContentPos, Depth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.Get_StartPos = function(ContentPos, Depth)
{
    if ( this.Content.length > 0 )
    {
        ContentPos.Update( 0, Depth );

        this.Content[0].Get_StartPos( ContentPos, Depth + 1 );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.Get_EndPos = function(BehindEnd, ContentPos, Depth)
{
    var ContentLen = this.Content.length;
    if ( ContentLen > 0 )
    {
        ContentPos.Update( ContentLen - 1, Depth );

        this.Content[ContentLen - 1].Get_EndPos( BehindEnd, ContentPos, Depth + 1 );
    }
};
//----------------------------------------------------------------------------------------------------------------------
// Функции для работы с селектом
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.Set_SelectionContentPos = function(StartContentPos, EndContentPos, Depth, StartFlag, EndFlag)
{
	if (this.Content.length <= 0)
		return;
	
	if (!this.CanPlaceCursorInside())
	{
		if (this.Paragraph && this.Paragraph.GetSelectDirection() > 0)
			this.SelectAll(1);
		else
			this.SelectAll(-1);
		return;
	}

    var Selection = this.Selection;

    var OldStartPos = Selection.StartPos;
    var OldEndPos   = Selection.EndPos;

    if ( OldStartPos > OldEndPos )
    {
        OldStartPos = Selection.EndPos;
        OldEndPos   = Selection.StartPos;
    }

    var StartPos = 0;
    switch (StartFlag)
    {
        case  1: StartPos = 0; break;
        case -1: StartPos = this.Content.length - 1; break;
        case  0: StartPos = StartContentPos.Get(Depth); break;
    }

    var EndPos = 0;
    switch (EndFlag)
    {
        case  1: EndPos = 0; break;
        case -1: EndPos = this.Content.length - 1; break;
        case  0: EndPos = EndContentPos.Get(Depth); break;
    }

    // Удалим отметки о старом селекте
    if ( OldStartPos < StartPos && OldStartPos < EndPos )
    {
        var TempBegin = Math.max(0, OldStartPos);
        var TempEnd   = Math.min(this.Content.length - 1, Math.min(StartPos, EndPos) - 1);
        for (var CurPos = TempBegin; CurPos <= TempEnd; ++CurPos)
        {
            this.Content[CurPos].RemoveSelection();
        }
    }

    if ( OldEndPos > StartPos && OldEndPos > EndPos )
    {
        var TempBegin = Math.max(0, Math.max(StartPos, EndPos) + 1);
        var TempEnd   = Math.min(OldEndPos, this.Content.length - 1);
        for (var CurPos = TempBegin; CurPos <= TempEnd; ++CurPos)
        {
            this.Content[CurPos].RemoveSelection();
        }
    }

    // Выставим метки нового селекта

    Selection.Use      = true;
    Selection.StartPos = StartPos;
    Selection.EndPos   = EndPos;

    if ( StartPos != EndPos )
    {
        this.Content[StartPos].Set_SelectionContentPos( StartContentPos, null, Depth + 1, StartFlag, StartPos > EndPos ? 1 : -1 );
        this.Content[EndPos].Set_SelectionContentPos( null, EndContentPos, Depth + 1, StartPos > EndPos ? -1 : 1, EndFlag );

        var _StartPos = StartPos;
        var _EndPos   = EndPos;
        var Direction = 1;

        if ( _StartPos > _EndPos )
        {
            _StartPos = EndPos;
            _EndPos   = StartPos;
            Direction = -1;
        }

        for ( var CurPos = _StartPos + 1; CurPos < _EndPos; CurPos++ )
        {
            this.Content[CurPos].SelectAll( Direction );
        }
    }
    else
    {
        this.Content[StartPos].Set_SelectionContentPos( StartContentPos, EndContentPos, Depth + 1, StartFlag, EndFlag );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.SetContentSelection = function(StartDocPos, EndDocPos, Depth, StartFlag, EndFlag)
{
	if (this.Content.length <= 0)
		return;

    if ((0 === StartFlag && (!StartDocPos[Depth] || this !== StartDocPos[Depth].Class)) || (0 === EndFlag && (!EndDocPos[Depth] || this !== EndDocPos[Depth].Class)))
        return;

    var StartPos = 0, EndPos = 0;
    switch (StartFlag)
    {
        case 0 : StartPos = StartDocPos[Depth].Position; break;
        case 1 : StartPos = 0; break;
        case -1: StartPos = this.Content.length - 1; break;
    }

    switch (EndFlag)
    {
        case 0 : EndPos = EndDocPos[Depth].Position; break;
        case 1 : EndPos = 0; break;
        case -1: EndPos = this.Content.length - 1; break;
    }

    var _StartDocPos = StartDocPos, _StartFlag = StartFlag;
    if (null !== StartDocPos && true === StartDocPos[Depth].Deleted)
    {
        if (StartPos < this.Content.length)
        {
            _StartDocPos = null;
            _StartFlag = 1;
        }
        else if (StartPos > 0)
        {
            StartPos--;
            _StartDocPos = null;
            _StartFlag = -1;
        }
        else
        {
            // Такого не должно быть
            return;
        }
    }

    var _EndDocPos = EndDocPos, _EndFlag = EndFlag;
    if (null !== EndDocPos && true === EndDocPos[Depth].Deleted)
    {
        if (EndPos < this.Content.length)
        {
            _EndDocPos = null;
            _EndFlag = 1;
        }
        else if (EndPos > 0)
        {
            EndPos--;
            _EndDocPos = null;
            _EndFlag = -1;
        }
        else
        {
            // Такого не должно быть
            return;
        }
    }

    this.Selection.Use      = true;
    this.Selection.StartPos = Math.max(0, Math.min(this.Content.length - 1, StartPos));
    this.Selection.EndPos   = Math.max(0, Math.min(this.Content.length - 1, EndPos));

    if (StartPos !== EndPos)
    {
        if (this.Content[StartPos] && this.Content[StartPos].SetContentSelection)
            this.Content[StartPos].SetContentSelection(_StartDocPos, null, Depth + 1, _StartFlag, StartPos > EndPos ? 1 : -1);

        if (this.Content[EndPos] && this.Content[EndPos].SetContentSelection)
            this.Content[EndPos].SetContentSelection(null, _EndDocPos, Depth + 1, StartPos > EndPos ? -1 : 1, _EndFlag);

        var _StartPos = StartPos;
        var _EndPos = EndPos;
        var Direction = 1;

        if (_StartPos > _EndPos)
        {
            _StartPos = EndPos;
            _EndPos = StartPos;
            Direction = -1;
        }

        for (var CurPos = _StartPos + 1; CurPos < _EndPos; CurPos++)
        {
            this.Content[CurPos].SelectAll(Direction);
        }
    }
    else
    {
        if (this.Content[StartPos] && this.Content[StartPos].SetContentSelection)
            this.Content[StartPos].SetContentSelection(_StartDocPos, _EndDocPos, Depth + 1, _StartFlag, _EndFlag);
    }
};
CParagraphContentWithParagraphLikeContent.prototype.SetContentPosition = function(DocPos, Depth, Flag)
{
	if (this.Content.length <= 0)
		return;

    if (0 === Flag && (!DocPos[Depth] || this !== DocPos[Depth].Class))
        return;

    var Pos = 0;
    switch (Flag)
    {
        case 0 : Pos = DocPos[Depth].Position; break;
        case 1 : Pos = 0; break;
        case -1: Pos = this.Content.length - 1; break;
    }

    var _DocPos = DocPos, _Flag = Flag;
    if (null !== DocPos && true === DocPos[Depth].Deleted)
    {
        if (Pos < this.Content.length)
        {
            _DocPos = null;
            _Flag = 1;
        }
        else if (Pos > 0)
        {
            Pos--;
            _DocPos = null;
            _Flag = -1;
        }
        else
        {
            // Такого не должно быть
            return;
        }
    }

    this.State.ContentPos = Math.max(0, Math.min(this.Content.length - 1, Pos));

    // TODO: Как только в CMathContent CurPos перейдет на стандартное this.State.ContentPos убрать эту проверку
    if (this.CurPos)
        this.CurPos = this.State.ContentPos;

    if (this.Content[Pos] && this.Content[Pos].SetContentPosition)
        this.Content[Pos].SetContentPosition(_DocPos, Depth + 1, _Flag);
    else
        this.Content[Pos].MoveCursorToStartPos();
};
CParagraphContentWithParagraphLikeContent.prototype.RemoveSelection = function()
{
    var Selection = this.Selection;

    if ( true === Selection.Use )
    {
        var StartPos = Selection.StartPos;
        var EndPos   = Selection.EndPos;

        if ( StartPos > EndPos )
        {
            StartPos = Selection.EndPos;
            EndPos   = Selection.StartPos;
        }

        StartPos = Math.max( 0, StartPos );
        EndPos   = Math.min( this.Content.length - 1, EndPos );

        for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
        {
            this.Content[CurPos].RemoveSelection();
        }
    }

    Selection.Use      = false;
    Selection.StartPos = 0;
    Selection.EndPos   = 0;
};
CParagraphContentWithParagraphLikeContent.prototype.SelectAll = function(Direction)
{
    var ContentLen = this.Content.length;

    var Selection = this.Selection;

    Selection.Use = true;

    if ( -1 === Direction )
    {
        Selection.StartPos = ContentLen - 1;
        Selection.EndPos   = 0;
    }
    else
    {
        Selection.StartPos = 0;
        Selection.EndPos   = ContentLen - 1;
    }

    for ( var CurPos = 0; CurPos < ContentLen; CurPos++ )
    {
        this.Content[CurPos].SelectAll( Direction );
    }
};
CParagraphContentWithParagraphLikeContent.prototype.drawSelectionInRange = function(line, range, drawState)
{
	let rangeInfo  = this.getRangePos(line, range);
	let rangeStart = rangeInfo[0];
	let rangeEnd   = rangeInfo[1];
	for (let pos = rangeStart; pos <= rangeEnd; ++pos)
	{
		this.Content[pos].drawSelectionInRange(line, range, drawState);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.IsSelectionEmpty = function(CheckEnd)
{
	if (this.Content.length <= 0)
		return true;

    var StartPos = this.State.Selection.StartPos;
    var EndPos   = this.State.Selection.EndPos;

    if ( StartPos > EndPos )
    {
        StartPos = this.State.Selection.EndPos;
        EndPos   = this.State.Selection.StartPos;
    }

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
    {
        if ( false === this.Content[CurPos].IsSelectionEmpty(CheckEnd) )
            return false;
    }

    return true;
};
CParagraphContentWithParagraphLikeContent.prototype.Selection_CheckParaEnd = function()
{
    // Сюда не должен попадать ParaEnd
    return false;
};
CParagraphContentWithParagraphLikeContent.prototype.Selection_CheckParaContentPos = function(ContentPos, Depth, bStart, bEnd)
{
    var CurPos = ContentPos.Get(Depth);

    if (this.Selection.StartPos <= CurPos && CurPos <= this.Selection.EndPos)
        return this.Content[CurPos].Selection_CheckParaContentPos(ContentPos, Depth + 1, bStart && this.Selection.StartPos === CurPos, bEnd && CurPos === this.Selection.EndPos);
    else if (this.Selection.EndPos <= CurPos && CurPos <= this.Selection.StartPos)
        return this.Content[CurPos].Selection_CheckParaContentPos(ContentPos, Depth + 1, bStart && this.Selection.EndPos === CurPos, bEnd && CurPos === this.Selection.StartPos);

    return false;
};
CParagraphContentWithParagraphLikeContent.prototype.IsSelectedAll = function(Props)
{
    var Selection = this.State.Selection;

    if ( false === Selection.Use && true !== this.Is_Empty( Props ) )
        return false;

    var StartPos = Selection.StartPos;
    var EndPos   = Selection.EndPos;

    if ( EndPos < StartPos )
    {
        StartPos = Selection.EndPos;
        EndPos   = Selection.StartPos;
    }

    for ( var Pos = 0; Pos <= StartPos; Pos++ )
    {
        if ( false === this.Content[Pos].IsSelectedAll( Props ) )
            return false;
    }

    var Count = this.Content.length;
    for ( var Pos = EndPos; Pos < Count; Pos++ )
    {
        if ( false === this.Content[Pos].IsSelectedAll( Props ) )
            return false;
    }

    return true;
};
CParagraphContentWithParagraphLikeContent.prototype.IsSelectedFromStart = function()
{
	if (!this.Selection.Use && !this.IsEmpty())
		return false;

	var nStartPos = this.Selection.StartPos < this.Selection.EndPos ? this.Selection.StartPos : this.Selection.EndPos;
	return this.Content[nStartPos].IsSelectedFromStart();
};
CParagraphContentWithParagraphLikeContent.prototype.IsSelectedToEnd = function()
{
	if (!this.Selection.Use && !this.IsEmpty())
		return false;

	var nEndPos = this.Selection.StartPos < this.Selection.EndPos ? this.Selection.EndPos : this.Selection.StartPos;
	return this.Content[nEndPos].IsSelectedToEnd();
};

CParagraphContentWithParagraphLikeContent.prototype.SkipAnchorsAtSelectionStart = function(nDirection)
{
	if (false === this.Selection.Use || true === this.IsEmpty({SkipAnchor : true}))
		return true;

	var oSelection = this.State.Selection;
	var nStartPos  = Math.min(oSelection.StartPos, oSelection.EndPos);
	var nEndPos    = Math.max(oSelection.StartPos, oSelection.EndPos);

	for (var nPos = 0; nPos < nStartPos; ++nPos)
	{
		if (true !== this.Content[nPos].IsEmpty({SkipAnchor : true}))
			return false;
	}

	for (var nPos = nStartPos; nPos <= nEndPos; ++nPos)
	{
		if (true === this.Content[nPos].SkipAnchorsAtSelectionStart(nDirection))
		{
			if (1 === nDirection)
				this.Selection.StartPos = nPos + 1;
			else
				this.Selection.EndPos = nPos + 1;

			this.Content[nPos].RemoveSelection();
		}
		else
		{
			return false;
		}
	}

	if (nEndPos < this.Content.length - 1)
		return false;

	return true;
};
CParagraphContentWithParagraphLikeContent.prototype.IsSelectionUse = function()
{
    return this.State.Selection.Use;
};
//----------------------------------------------------------------------------------------------------------------------
// SpellCheck
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.RestartSpellCheck = function()
{
    for (let nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
    {
        this.Content[nIndex].RestartSpellCheck();
    }
};
/**
 * @param oSpellCheckerEngine {AscWord.CParagraphSpellCheckerCollector}
 * @param nDepth {number}
 */
CParagraphContentWithParagraphLikeContent.prototype.CheckSpelling = function(oSpellCheckerEngine, nDepth)
{
	if (oSpellCheckerEngine.IsExceedLimit())
		return;

	var nStartPos = 0;
	if (oSpellCheckerEngine.IsFindStart())
		nStartPos = oSpellCheckerEngine.GetPos(nDepth);

    for (var nPos = nStartPos, nCount = this.Content.length; nPos < nCount; ++nPos)
    {
    	var oItem = this.Content[nPos];

    	oSpellCheckerEngine.UpdatePos(nPos, nDepth);
        oItem.CheckSpelling(oSpellCheckerEngine, nDepth + 1);

        if (oSpellCheckerEngine.IsExceedLimit())
        	return;
    }
};
//----------------------------------------------------------------------------------------------------------------------
// Search and Replace
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.Search = function(oParaSearch)
{
	this.SearchMarks = [];
	
	for (var nPos = 0, nContentLen = this.Content.length; nPos < nContentLen; ++nPos)
	{
		this.Content[nPos].Search(oParaSearch);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.AddSearchResult = function(oSearchResult, isStart, oContentPos, nDepth)
{
	oSearchResult.RegisterClass(isStart, this);
	this.SearchMarks.push(new AscCommonWord.CParagraphSearchMark(oSearchResult, isStart, nDepth));
	this.Content[oContentPos.Get(nDepth)].AddSearchResult(oSearchResult, isStart, oContentPos, nDepth + 1);
};
CParagraphContentWithParagraphLikeContent.prototype.ClearSearchResults = function()
{
	this.SearchMarks = [];
};
CParagraphContentWithParagraphLikeContent.prototype.RemoveSearchResult = function(oSearchResult)
{
	for (var nIndex = 0, nMarksCount = this.SearchMarks.length; nIndex < nMarksCount; ++nIndex)
	{
		var oMark = this.SearchMarks[nIndex];
		if (oSearchResult === oMark.SearchResult)
		{
			this.SearchMarks.splice(nIndex, 1);
			nIndex--;
			nMarksCount--;
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetSearchElementId = function(bNext, bUseContentPos, ContentPos, Depth)
{
    // Определим позицию, начиная с которой мы будем искать ближайший найденный элемент
    var StartPos = 0;

    if ( true === bUseContentPos )
    {
        StartPos = ContentPos.Get( Depth );
    }
    else
    {
        if ( true === bNext )
        {
            StartPos = 0;
        }
        else
        {
            StartPos = this.Content.length - 1;
        }
    }

    // Производим поиск ближайшего элемента
    if ( true === bNext )
    {
        var ContentLen = this.Content.length;

        for ( var CurPos = StartPos; CurPos < ContentLen; CurPos++ )
        {
            var ElementId = this.Content[CurPos].GetSearchElementId( true, bUseContentPos && CurPos === StartPos ? true : false, ContentPos, Depth + 1 );
            if ( null !== ElementId )
                return ElementId;
        }
    }
    else
    {
        var ContentLen = this.Content.length;

        for ( var CurPos = StartPos; CurPos >= 0; CurPos-- )
        {
            var ElementId = this.Content[CurPos].GetSearchElementId( false, bUseContentPos && CurPos === StartPos ? true : false, ContentPos, Depth + 1 );
            if ( null !== ElementId )
                return ElementId;
        }
    }

    return null;
};
//----------------------------------------------------------------------------------------------------------------------
// Разное
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.SetReviewType = function(ReviewType, RemovePrChange)
{
    for (var Index = 0, Count = this.Content.length; Index < Count; Index++)
    {
        var Element = this.Content[Index];
        if (para_Run === Element.Type)
        {
            Element.SetReviewType(ReviewType);

            if (true === RemovePrChange)
                Element.RemovePrChange();
        }
        else if (Element.SetReviewType)
            Element.SetReviewType(ReviewType);
    }
};
CParagraphContentWithParagraphLikeContent.prototype.SetReviewTypeWithInfo = function(ReviewType, ReviewInfo)
{
    for (var Index = 0, Count = this.Content.length; Index < Count; Index++)
    {
        var Element = this.Content[Index];
        if (Element && Element.SetReviewTypeWithInfo)
            Element.SetReviewTypeWithInfo(ReviewType, ReviewInfo);
    }
};
CParagraphContentWithParagraphLikeContent.prototype.CheckRevisionsChanges = function(Checker, ContentPos, Depth)
{
    for (var CurPos = 0, Count = this.Content.length; CurPos < Count; CurPos++)
    {
        ContentPos.Update(CurPos, Depth);
        this.Content[CurPos].CheckRevisionsChanges(Checker, ContentPos, Depth + 1);
    }
};
CParagraphContentWithParagraphLikeContent.prototype.AcceptRevisionChanges = function(Type, bAll)
{
    if (true === this.Selection.Use || true === bAll)
    {
        var StartPos = this.Selection.StartPos;
        var EndPos   = this.Selection.EndPos;
        if (StartPos > EndPos)
        {
            StartPos = this.Selection.EndPos;
            EndPos   = this.Selection.StartPos;
        }

        if (true === bAll)
        {
            StartPos = 0;
            EndPos   = this.Content.length - 1;
        }

        // Начинаем с конца, потому что при выполнении данной функции, количество элементов может изменяться
        if (this.Content[EndPos].AcceptRevisionChanges)
            this.Content[EndPos].AcceptRevisionChanges(Type, bAll);

        if (StartPos < EndPos)
        {
            for (var CurPos = EndPos - 1; CurPos > StartPos; CurPos--)
            {
                var Element = this.Content[CurPos];
                var ReviewType = Element.GetReviewType ? Element.GetReviewType() : reviewtype_Common;

                var isGoInside = false;
                if (reviewtype_Add === ReviewType)
                {
                    if (undefined === Type || c_oAscRevisionsChangeType.TextAdd === Type)
                        Element.SetReviewType(reviewtype_Common);

                    isGoInside = true;
                }
                else if (reviewtype_Remove === ReviewType)
                {
                    if (undefined === Type || c_oAscRevisionsChangeType.TextRem === Type)
                        this.Remove_FromContent(CurPos, 1, true);
                }
                else if (reviewtype_Common === ReviewType)
                {
                    isGoInside = true;
                }

                if (true === isGoInside && Element.AcceptRevisionChanges)
                    Element.AcceptRevisionChanges(Type, true);
            }

            if (this.Content[StartPos].AcceptRevisionChanges)
                this.Content[StartPos].AcceptRevisionChanges(Type, bAll);
        }

        this.Correct_Content();
    }
};
CParagraphContentWithParagraphLikeContent.prototype.RejectRevisionChanges = function(Type, bAll)
{
    if (true === this.Selection.Use || true === bAll)
    {
        var StartPos = this.Selection.StartPos;
        var EndPos   = this.Selection.EndPos;
        if (StartPos > EndPos)
        {
            StartPos = this.Selection.EndPos;
            EndPos   = this.Selection.StartPos;
        }

        if (true === bAll)
        {
            StartPos = 0;
            EndPos   = this.Content.length - 1;
        }

        // Начинаем с конца, потому что при выполнении данной функции, количество элементов может изменяться
        if (this.Content[EndPos].RejectRevisionChanges)
            this.Content[EndPos].RejectRevisionChanges(Type, bAll);

        if (StartPos < EndPos)
        {
            for (var CurPos = EndPos - 1; CurPos > StartPos; CurPos--)
            {
                var Element = this.Content[CurPos];
                var ReviewType = Element.GetReviewType ? Element.GetReviewType() : reviewtype_Common;

                var isGoInside = false;
                if (reviewtype_Remove === ReviewType)
                {
                    if (undefined === Type || c_oAscRevisionsChangeType.TextRem === Type)
                        Element.SetReviewType(reviewtype_Common);

                    isGoInside = true;
                }
                else if (reviewtype_Add === ReviewType)
                {
                    if (undefined === Type || c_oAscRevisionsChangeType.TextAdd === Type)
                        this.Remove_FromContent(CurPos, 1, true);
                }
                else if (reviewtype_Common === ReviewType)
                {
                    isGoInside = true;
                }

                if (true === isGoInside && Element.RejectRevisionChanges)
                    Element.RejectRevisionChanges(Type, true);
            }

            if (this.Content[StartPos].RejectRevisionChanges)
                this.Content[StartPos].RejectRevisionChanges(Type, bAll);
        }

        this.Correct_Content();
    }
};
CParagraphContentWithParagraphLikeContent.prototype.private_CheckUpdateBookmarks = function(Items)
{
	if (!Items)
		return;

	for (var nIndex = 0, nCount = Items.length; nIndex < nCount; ++nIndex)
	{
		var oItem = Items[nIndex];
		if (oItem && para_Bookmark === oItem.Type)
		{
			var oLogicDocument = this.Paragraph && this.Paragraph.LogicDocument ? this.Paragraph.LogicDocument : editor.WordControl.m_oLogicDocument;
			oLogicDocument.GetBookmarksManager().SetNeedUpdate(true);
			return;
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetFootnotesList = function(oEngine)
{
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		if (this.Content[nIndex].GetFootnotesList)
			this.Content[nIndex].GetFootnotesList(oEngine);

		if (oEngine.IsRangeFull())
			return;
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GotoFootnoteRef = function(isNext, isCurrent, isStepOver, isStepFootnote, isStepEndnote)
{
	var nPos = 0;

	if (true === isCurrent)
	{
		if (true === this.Selection.Use)
			nPos = Math.min(this.Selection.StartPos, this.Selection.EndPos);
		else
			nPos = this.State.ContentPos;
	}
	else
	{
		if (true === isNext)
			nPos = 0;
		else
			nPos = this.Content.length - 1;
	}

	if (true === isNext)
	{
		for (var nIndex = nPos, nCount = this.Content.length - 1; nIndex < nCount; ++nIndex)
		{
			var nRes = this.Content[nIndex].GotoFootnoteRef ? this.Content[nIndex].GotoFootnoteRef(true, true === isCurrent && nPos === nIndex, isStepOver, isStepFootnote, isStepEndnote) : 0;

			if (nRes > 0)
				isStepOver = true;
			else  if (-1 === nRes)
				return true;
		}
	}
	else
	{
		for (var nIndex = nPos; nIndex >= 0; --nIndex)
		{
			var nRes = this.Content[nIndex].GotoFootnoteRef ? this.Content[nIndex].GotoFootnoteRef(true, true === isCurrent && nPos === nIndex, isStepOver, isStepFootnote, isStepEndnote) : 0;

			if (nRes > 0)
				isStepOver = true;
			else  if (-1 === nRes)
				return true;
		}
	}

	return false;
};
CParagraphContentWithParagraphLikeContent.prototype.GetFootnoteRefsInRange = function(arrFootnotes, _CurLine, _CurRange)
{
	var CurLine = _CurLine - this.StartLine;
	var CurRange = (0 === CurLine ? _CurRange - this.StartRange : _CurRange);

	var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
	var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

	for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
	{
		if (this.Content[CurPos].GetFootnoteRefsInRange)
			this.Content[CurPos].GetFootnoteRefsInRange(arrFootnotes, _CurLine, _CurRange);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetAllContentControls = function(arrContentControls)
{
	if (!arrContentControls)
		arrContentControls = [];

	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		if (this.Content[nIndex].GetAllContentControls)
			this.Content[nIndex].GetAllContentControls(arrContentControls);
	}

	return arrContentControls;
};
CParagraphContentWithParagraphLikeContent.prototype.GetSelectedContentControls = function(arrContentControls)
{
	if (true === this.Selection.Use)
	{
		var StartPos = this.Selection.StartPos;
		var EndPos   = this.Selection.EndPos;
		if (StartPos > EndPos)
		{
			StartPos = this.Selection.EndPos;
			EndPos   = this.Selection.StartPos;
		}

		for (var Index = StartPos; Index <= EndPos; ++Index)
		{
			if (this.Content[Index].GetSelectedContentControls)
				this.Content[Index].GetSelectedContentControls(arrContentControls);
		}
	}
	else
	{
		if (this.Content[this.State.ContentPos].GetSelectedContentControls)
			this.Content[this.State.ContentPos].GetSelectedContentControls(arrContentControls);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.CreateRunWithText = function(sValue)
{
	var oRun = new ParaRun();
	oRun.AddText(sValue);
	oRun.Set_Pr(this.Get_FirstTextPr());
	return oRun;
};
CParagraphContentWithParagraphLikeContent.prototype.ReplaceAllWithText = function(sValue)
{
	var oRun = this.CreateRunWithText(sValue);
	oRun.Apply_TextPr(this.Get_TextPr(), undefined, true);
	this.Remove_FromContent(0, this.Content.length);
	this.Add_ToContent(0, oRun);
	this.MoveCursorToStartPos();
};
CParagraphContentWithParagraphLikeContent.prototype.FindNextFillingForm = function(isNext, isCurrent, isStart)
{
	var nCurPos = this.Selection.Use === true ? this.Selection.EndPos : this.State.ContentPos;

	var nStartPos = 0, nEndPos = 0;
	if (isCurrent)
	{
		if (isStart)
		{
			nStartPos = nCurPos;
			nEndPos   = isNext ? this.Content.length - 1 : 0;
		}
		else
		{
			nStartPos = isNext ? 0 : this.Content.length - 1;
			nEndPos   = nCurPos;
		}
	}
	else
	{
		if (isNext)
		{
			nStartPos = 0;
			nEndPos   = this.Content.length - 1;
		}
		else
		{
			nStartPos = this.Content.length - 1;
			nEndPos   = 0;
		}
	}

	if (isNext)
	{
		for (var nIndex = nStartPos; nIndex <= nEndPos; ++nIndex)
		{
			if (this.Content[nIndex].FindNextFillingForm)
			{
				var oRes = this.Content[nIndex].FindNextFillingForm(true, isCurrent && nIndex === nCurPos, isStart);
				if (oRes)
					return oRes;
			}
		}
	}
	else
	{
		for (var nIndex = nStartPos; nIndex >= nEndPos; --nIndex)
		{
			if (this.Content[nIndex].FindNextFillingForm)
			{
				var oRes = this.Content[nIndex].FindNextFillingForm(false, isCurrent && nIndex === nCurPos, isStart);
				if (oRes)
					return oRes;
			}
		}
	}

	return null;
};
CParagraphContentWithParagraphLikeContent.prototype.IsEmpty = function(oPr)
{
	return this.Is_Empty(oPr);
};
CParagraphContentWithParagraphLikeContent.prototype.AddContentControl = function()
{
	if (true === this.IsSelectionUse())
	{
		if (this.Selection.StartPos === this.Selection.EndPos && para_Run !== this.Content[this.Selection.StartPos].Type)
		{
			if (this.Content[this.Selection.StartPos].AddContentControl)
				return this.Content[this.Selection.StartPos].AddContentControl();

			return null;
		}
		else
		{
			var nStartPos = this.Selection.StartPos;
			var nEndPos   = this.Selection.EndPos;
			if (nEndPos < nStartPos)
			{
				nStartPos = this.Selection.EndPos;
				nEndPos   = this.Selection.StartPos;
			}

			for (var nIndex = nStartPos; nIndex <= nEndPos; ++nIndex)
			{
				if (para_Run !== this.Content[nIndex].Type)
				{
					// TODO: Вывести сообщение, что в данном месте нельзя добавить Plain text content control
					return null;
				}
			}

			var oContentControl = new CInlineLevelSdt();
			oContentControl.SetPlaceholder(c_oAscDefaultPlaceholderName.Text);
			oContentControl.SetDefaultTextPr(this.GetDirectTextPr());

			var oNewRun = this.Content[nEndPos].Split_Run(Math.max(this.Content[nEndPos].Selection.StartPos, this.Content[nEndPos].Selection.EndPos));
			this.Add_ToContent(nEndPos + 1, oNewRun);

			oNewRun = this.Content[nStartPos].Split_Run(Math.min(this.Content[nStartPos].Selection.StartPos, this.Content[nStartPos].Selection.EndPos));
			this.Add_ToContent(nStartPos + 1, oNewRun);

			oContentControl.ReplacePlaceHolderWithContent();
			for (var nIndex = nEndPos + 1; nIndex >= nStartPos + 1; --nIndex)
			{
				oContentControl.Add_ToContent(0, this.Content[nIndex]);
				this.Remove_FromContent(nIndex, 1);
			}
			if (oContentControl.IsEmpty())
				oContentControl.ReplaceContentWithPlaceHolder();

			this.Add_ToContent(nStartPos + 1, oContentControl);
			this.Selection.StartPos = nStartPos + 1;
			this.Selection.EndPos   = nStartPos + 1;
			oContentControl.SelectAll(1);

			return oContentControl;
		}
	}
	else
	{
		var oContentControl = new CInlineLevelSdt();
		oContentControl.SetDefaultTextPr(this.GetDirectTextPr());
		oContentControl.SetPlaceholder(c_oAscDefaultPlaceholderName.Text);
		oContentControl.ReplaceContentWithPlaceHolder(false);
		this.Add(oContentControl);
		return oContentControl;
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetElement = function(nPos)
{
	if (nPos < 0 || nPos >= this.Content.length)
		return null;

	return this.Content[nPos];
};
CParagraphContentWithParagraphLikeContent.prototype.GetElementsCount = function()
{
	return this.Content.length;
};
CParagraphContentWithParagraphLikeContent.prototype.PreDelete = function()
{
	if (this.Paragraph && this.Paragraph.isPreventedPreDelete())
		return;
	
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		if (this.Content[nIndex] && this.Content[nIndex].PreDelete)
			this.Content[nIndex].PreDelete(true);
	}

	this.RemoveSelection();
};
CParagraphContentWithParagraphLikeContent.prototype.GetCurrentPermRanges = function(permRanges, isCurrent)
{
	let endPos = isCurrent ? Math.min(this.State.ContentPos, this.Content.length - 1) : this.Content.length - 1;
	for (let pos = 0; pos <= endPos; ++pos)
	{
		this.Content[pos].GetCurrentPermRanges(permRanges, isCurrent && pos === endPos);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.CorrectPosToPermRanges = function(state, paraPos, depth, isCurrent)
{
	if (state.isForward())
	{
		let startPos = isCurrent ? paraPos.Get(depth) : 0;
		for (let pos = startPos; pos < this.Content.length; ++pos)
		{
			state.setPos(pos, depth);
			this.Content[pos].CorrectPosToPermRanges(state, paraPos, depth + 1, isCurrent && pos === startPos);
			
			if (state.isStopped())
				break;
		}
	}
	else
	{
		let startPos = isCurrent ? paraPos.Get(depth) : this.Content.length - 1;
		for (let pos = startPos; pos >= 0; --pos)
		{
			state.setPos(pos, depth);
			this.Content[pos].CorrectPosToPermRanges(state, paraPos, depth + 1, isCurrent && pos === startPos);
			
			if (state.isStopped())
				break;
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetCurrentComplexFields = function(arrComplexFields, isCurrent, isFieldPos)
{
	var nEndPos = isCurrent ? this.State.ContentPos : this.Content.length - 1;
	for (var nIndex = 0; nIndex <= nEndPos; ++nIndex)
	{
		if (this.Content[nIndex] && this.Content[nIndex].GetCurrentComplexFields)
			this.Content[nIndex].GetCurrentComplexFields(arrComplexFields, isCurrent && nIndex === nEndPos, isFieldPos);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetDirectTextPr = function()
{
	if (true === this.Selection.Use)
	{
		var StartPos = this.Selection.StartPos;
		var EndPos   = this.Selection.EndPos;

		if (StartPos > EndPos)
		{
			StartPos = this.Selection.EndPos;
			EndPos   = this.Selection.StartPos;
		}

		while (true === this.Content[StartPos].IsSelectionEmpty() && StartPos < EndPos)
			StartPos++;

		return this.Content[StartPos].GetDirectTextPr();
	}
	else
	{
		return this.Content[this.State.ContentPos].GetDirectTextPr();
	}
};
CParagraphContentWithParagraphLikeContent.prototype.GetAllAnnotationMarks = function(marks)
{
	if (!marks)
		marks = [];
	
	for (let i = 0; i < this.Content.length; ++i)
	{
		this.Content[i].GetAllAnnotationMarks(marks);
	}
	
	return marks;
};
CParagraphContentWithParagraphLikeContent.prototype.GetAllFields = function(isUseSelection, arrFields)
{
	if (!arrFields)
		arrFields = [];

	var nStartPos = isUseSelection ?
		(this.Selection.StartPos < this.Selection.EndPos ? this.Selection.StartPos : this.Selection.EndPos)
		: 0;

	var nEndPos = isUseSelection ?
		(this.Selection.StartPos < this.Selection.EndPos ? this.Selection.EndPos : this.Selection.StartPos)
		: this.Content.length - 1;

	for (var nIndex = nStartPos; nIndex <= nEndPos; ++nIndex)
	{
		this.Content[nIndex].GetAllFields(isUseSelection, arrFields);
	}

	return arrFields;
};
CParagraphContentWithParagraphLikeContent.prototype.CanAddComment = function()
{
	if (!this.Selection.Use)
		return true;

	var nStartPos = this.Selection.StartPos <= this.Selection.EndPos ? this.Selection.StartPos : this.Selection.EndPos;
	var nEndPos   = this.Selection.StartPos <= this.Selection.EndPos ? this.Selection.EndPos : this.Selection.StartPos;

	for (var nPos = nStartPos; nPos <= nEndPos; ++nPos)
	{
		if (this.Content[nPos].CanAddComment && !this.Content[nPos].CanAddComment())
			return false;
	}

	return true;
};
CParagraphContentWithParagraphLikeContent.prototype.RemoveElement = function(element)
{
	for (let i = 0, count = this.Content.length; i < count; ++i)
	{
		let item = this.Content[i];
		if (item === element)
		{
			this.RemoveFromContent(i, 1);
			return true;
		}
		else if (item.RemoveElement(element))
		{
			return true;
		}
	}
	return false;
};
CParagraphContentWithParagraphLikeContent.prototype.CheckRunContent = function(fCheck, oStartPos, oEndPos, nDepth, oCurrentPos, isForward)
{
	if (undefined === isForward)
		isForward = true;
	
	let nStartPos = oStartPos && oStartPos.GetDepth() >= nDepth ? oStartPos.Get(nDepth) : 0;
	let nEndPos   = oEndPos && oEndPos.GetDepth() >= nDepth ? oEndPos.Get(nDepth) : this.Content.length - 1;
	
	if (isForward)
	{
		for (var nPos = nStartPos; nPos <= nEndPos; ++nPos)
		{
			let _s = oStartPos && nPos === nStartPos ? oStartPos : null;
			let _e = oEndPos && nPos === nEndPos ? oEndPos : null;
			
			if (oCurrentPos)
				oCurrentPos.Update(nPos, nDepth);
			
			if (this.Content[nPos].CheckRunContent(fCheck, _s, _e, nDepth + 1, oCurrentPos, isForward))
				return true;
		}
	}
	else
	{
		for (var nPos = nEndPos; nPos >= nStartPos; --nPos)
		{
			let _s = oStartPos && nPos === nStartPos ? oStartPos : null;
			let _e = oEndPos && nPos === nEndPos ? oEndPos : null;
			
			if (oCurrentPos)
				oCurrentPos.Update(nPos, nDepth);
			
			if (this.Content[nPos].CheckRunContent(fCheck, _s, _e, nDepth + 1, oCurrentPos, isForward))
				return true;
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.ProcessComplexFields = function(oComplexFields)
{
	for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		this.Content[nPos].ProcessComplexFields(oComplexFields);
	}
};
CParagraphContentWithParagraphLikeContent.prototype.CorrectContentPos = function()
{
	if (this.IsSelectionUse())
		return;

	var nCount = this.Content.length;
	var nCurPos = Math.min(Math.max(0, this.State.ContentPos), nCount - 1);

	// Ищем элемент, в котором может стоять курсор
	while (nCurPos > 0 && !this.Content[nCurPos].IsCursorPlaceable())
	{
		nCurPos--;
		this.Content[nCurPos].MoveCursorToEndPos();
	}

	while (nCurPos < nCount && !this.Content[nCurPos].IsCursorPlaceable())
	{
		nCurPos++;
		this.Content[nCurPos].MoveCursorToStartPos(false);
	}

	// Если курсор находится в начале или конце гиперссылки, тогда выводим его из гиперссылки
	while (nCurPos > 0 && para_Run !== this.Content[nCurPos].Type && para_Math !== this.Content[nCurPos].Type && para_Field !== this.Content[nCurPos].Type && para_InlineLevelSdt !== this.Content[nCurPos].Type && true === this.Content[nCurPos].Cursor_Is_Start())
	{
		if (!this.Content[nCurPos - 1].IsCursorPlaceable())
			break;

		nCurPos--;
		this.Content[nCurPos].MoveCursorToEndPos();
	}

	while (nCurPos < nCount && para_Run !== this.Content[nCurPos].Type && para_Math !== this.Content[nCurPos].Type && para_Field !== this.Content[nCurPos].Type && para_InlineLevelSdt !== this.Content[nCurPos].Type && true === this.Content[nCurPos].Cursor_Is_End())
	{
		if (!this.Content[nCurPos + 1].IsCursorPlaceable())
			break;

		nCurPos++;
		this.Content[nCurPos].MoveCursorToStartPos(false);
	}

	this.State.ContentPos = nCurPos;

	this.Content[this.State.ContentPos].CorrectContentPos();
};
CParagraphContentWithParagraphLikeContent.prototype.GetFirstRun = function()
{
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		var oRun = this.Content[nIndex].GetFirstRun();
		if (oRun)
			return oRun;
	}

	return null;
};
CParagraphContentWithParagraphLikeContent.prototype.GetFirstRunNonEmpty = function()
{
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		var oRun = this.Content[nIndex].GetFirstRun();
		if (oRun&& oRun.GetElementsCount() > 0)
			return oRun;
	}

	return null;
};
CParagraphContentWithParagraphLikeContent.prototype.MakeSingleRunElement = function(isClearRun)
{
	if (this.Content.length !== 1 || para_Run !== this.Content[0].Type)
	{
		var oRun = new ParaRun(this.GetParagraph(), false);

		if (true !== isClearRun)
		{
			// У нас при открытии ран делится маскимально по 255 элементов внутри каждого рана, поэтому
			// в формах, где должен быть только 1 ран после открытия их может быть несколько. Объединяем здесь
			// все раны в один общий ран, чтобы исправить данную ситуцию

			var oParagraph = this.GetParagraph();
			var oCurrentRun = null;
			if (oParagraph)
			{
				var oCurPos = oParagraph.Get_ParaContentPos(false, false, false);
				oCurPos.DecreaseDepth(1);
				oCurrentRun = oParagraph.GetClassByPos(oCurPos);
				if (!oCurrentRun || !(oCurrentRun instanceof ParaRun))
					oCurrentRun = null;
			}

			var nNewCurPos = 0;
			var isFirst    = true;
			this.CheckRunContent(function(_oRun)
			{
				if (_oRun === oCurrentRun)
					nNewCurPos = _oRun.State.ContentPos + oRun.Content.length;

				var arrContentToInsert = [];
				for (var nPos = 0, nCount = _oRun.Content.length; nPos < nCount; ++nPos)
				{
					arrContentToInsert.push(_oRun.Content[nPos].Copy());
				}

				oRun.ConcatToContent(arrContentToInsert);

				if (isFirst && arrContentToInsert.length > 0)
				{
					oRun.SetPr(_oRun.GetDirectTextPr().Copy());
					isFirst = false;
				}
			});

			oRun.State.ContentPos = nNewCurPos;
		}

		if (this.Content.length > 0)
			this.RemoveFromContent(0, this.Content.length, true);

		this.AddToContent(0, oRun, true);
	}

	var oRun = this.Content[0];

	if (false !== isClearRun)
		oRun.ClearContent();

	return oRun;
};
CParagraphContentWithParagraphLikeContent.prototype.ClearContent = function()
{
	if (this.Content.length <= 0)
		return;

	this.RemoveFromContent(0, this.Content.length, true);
};
CParagraphContentWithParagraphLikeContent.prototype.GetFirstRunElementPos = function(nType, oStartPos, oEndPos, nDepth)
{
	for (var nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		oStartPos.Update(nPos, nDepth);
		oEndPos.Update(nPos, nDepth);

		if (this.Content[nPos].GetFirstRunElementPos(nType, oStartPos, oEndPos, nDepth + 1))
			return true;
	}

	return false;
};
CParagraphContentWithParagraphLikeContent.prototype.SetIsRecalculated = function(isRecalculated)
{
	if (!isRecalculated && this.GetParagraph())
		this.GetParagraph().SetIsRecalculated(false);
};
CParagraphContentWithParagraphLikeContent.prototype.CalculateTextToTable = function(oEngine)
{
	for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; ++nIndex)
	{
		if (this.Content[nIndex].IsSolid())
			continue;

		this.Content[nIndex].CalculateTextToTable(oEngine);
	}
};

//----------------------------------------------------------------------------------------------------------------------
// Функции, которые должны быть реализованы в классах наследниках
//----------------------------------------------------------------------------------------------------------------------
CParagraphContentWithParagraphLikeContent.prototype.Add = function(Item)
{
	if (undefined !== Item.Parent)
		Item.Parent = this;

	switch (Item.Type)
	{
		case para_Run:
		case para_Hyperlink:
		case para_InlineLevelSdt:
		case para_Field:
		{
			var TextPr = this.Get_FirstTextPr();
			Item.SelectAll();
			Item.Apply_TextPr(TextPr);
			Item.RemoveSelection();

			var CurPos = this.State.ContentPos;
			var CurItem = this.Content[CurPos];
			if (para_Run === CurItem.Type)
			{
				var NewRun = CurItem.Split2(CurItem.State.ContentPos);
				this.Add_ToContent(CurPos + 1, Item);
				this.Add_ToContent(CurPos + 2, NewRun);

				this.State.ContentPos = CurPos + 2;
				this.Content[this.State.ContentPos].MoveCursorToStartPos();
			}
			else
			{
				CurItem.Add(Item);
			}

			break;
		}
		case para_Math :
		{
			var ContentPos = new AscWord.CParagraphContentPos();
			this.Get_ParaContentPos(false, false, ContentPos);
			var CurPos = ContentPos.Get(0);

			// Ран формула делит на части, а в остальные элементы добавляется целиком
			if (para_Run === this.Content[CurPos].Type)
			{
				// Разделяем текущий элемент (возвращается правая часть)
				var NewElement = this.Content[CurPos].Split(ContentPos, 1);

				if (null !== NewElement)
					this.Add_ToContent(CurPos + 1, NewElement, true);
				
				let paraMath = null;
				if (Item instanceof ParaMath)
				{
					paraMath = Item;
				}
				else if (Item instanceof AscCommonWord.MathMenu)
				{
					let textPr = Item.GetTextPr();
					paraMath = new ParaMath();
					paraMath.Root.Load_FromMenu(Item.Menu, this.GetParagraph(), textPr.Copy(), Item.GetText());
					paraMath.Root.Correct_Content(true);
					paraMath.ApplyTextPr(textPr.Copy(), undefined, true);
				}
				
				if (paraMath)
				{
					this.AddToContent(CurPos + 1, paraMath, true);
					this.State.ContentPos = CurPos + 1;
					this.Content[this.State.ContentPos].MoveCursorToEndPos(false);
				}
			}
			else
			{
				this.Content[CurPos].Add(Item);
			}

			break;
		}
		default:
		{
			this.Content[this.State.ContentPos].Add(Item);
			break;
		}
	}
};
CParagraphContentWithParagraphLikeContent.prototype.Undo = function(Data){};
CParagraphContentWithParagraphLikeContent.prototype.Redo = function(Data){};
CParagraphContentWithParagraphLikeContent.prototype.Save_Changes = function(Data, Writer){};
CParagraphContentWithParagraphLikeContent.prototype.Load_Changes = function(Reader){};
CParagraphContentWithParagraphLikeContent.prototype.Write_ToBinary2 = function(Writer){};
CParagraphContentWithParagraphLikeContent.prototype.Read_FromBinary2 = function(Reader){};

// TODO: Сделать и перенести в коммоны для изменений
/**
 * Универсальный метод для проверки лока для простых изменений внутри параграфа
 */
function private_ParagraphContentChangesCheckLock(lockData)
{
	let obj = this.Class;
	if (!this.IsContentChange() && lockData && lockData.isFillingForm())
		return lockData.lock();
	
	let isForm = false;
	let isCC   = false;
	while (obj)
	{
		if (obj.Lock)
			obj.Lock.Check(obj.Get_Id());
		
		isForm = isForm || (obj instanceof AscWord.CInlineLevelSdt && obj.IsForm());
		isCC   = isCC || obj instanceof AscWord.CInlineLevelSdt;
		
		if (!(obj instanceof AscWord.Paragraph) && obj.GetParent)
			obj = obj.GetParent()
		else
			obj = null;
	}
	
	if (this.IsContentChange())
	{
		if (isForm && lockData && !lockData.isSkipFormCheck())
			lockData.lock();

		if (!isCC && lockData && lockData.isFillingForm())
			lockData.lock();
	}
}
//--------------------------------------------------------export----------------------------------------------------
AscWord.ParagraphContentBase                     = CParagraphContentBase;
AscWord.ParagraphContentWithParagraphLikeContent = CParagraphContentWithParagraphLikeContent;