/*
 * (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 fldchartype_Begin    = 0;
var fldchartype_Separate = 1;
var fldchartype_End      = 2;

function ParaFieldChar(Type, LogicDocument)
{
	AscWord.CRunElementBase.call(this);
	
	this.LogicDocument = LogicDocument;
	this.Use           = true;
	this.CharType      = undefined === Type ? fldchartype_Begin : Type;
	this.ComplexField  = (this.CharType === fldchartype_Begin) ? new CComplexField(LogicDocument) : null;
	this.fldData       = null;
	this.ffData        = null;
	this.Run           = null;
	this.X             = 0;
	this.Y             = 0;
	this.PageAbs       = 0;
	
	this.showFieldCode = false;

	this.numText  = null;
	this.textPr   = null;
	this.checkBox = null;
	this.hidden   = false;
	
	this.graphemes = [];
	this.widths    = [];
	this.ascent    = 0;
	this.descent   = 0;
}
ParaFieldChar.prototype = Object.create(AscWord.CRunElementBase.prototype);
ParaFieldChar.prototype.constructor = ParaFieldChar;
ParaFieldChar.prototype.Type = para_FieldChar;
ParaFieldChar.prototype.IsFieldChar = function()
{
	return true;
};
ParaFieldChar.prototype.Init = function(Type, LogicDocument)
{
	this.CharType = Type;

	this.LogicDocument = LogicDocument;
	this.ComplexField  = (this.CharType === fldchartype_Begin) ? new CComplexField(this.LogicDocument) : null;
};
ParaFieldChar.prototype.Copy = function()
{
	let oChar = new ParaFieldChar(this.CharType, this.LogicDocument);

	let oComplexField = this.GetComplexField();
	if (oComplexField && oComplexField.IsUpdate())
	{
		oChar.SetComplexField(oComplexField);
		oComplexField.ReplaceChar(oChar);
	}
	//todo fldData
	oChar.ffData = this.ffData ? this.ffData.Copy() : null;

	return oChar;
};
ParaFieldChar.prototype.Measure = function(Context, textPr, sectPr)
{
	if (!this.IsEnd())
		return;
	
	this.textPr = textPr;
	this.sectPr = sectPr;
	this.format = Asc.c_oAscNumberingFormat.UpperRoman;
	
	this.private_UpdateWidth();
};
ParaFieldChar.prototype.Draw = function(x, y, context)
{
	if (!this.IsVisual())
		return;
	
	if (this.numText)
	{
		let fontSize = this.textPr.FontSize * this.textPr.getFontCoef();
		for (let index = 0; index < this.graphemes.length; ++index)
		{
			AscFonts.DrawGrapheme(this.graphemes[index], context, x, y, fontSize);
			x += this.widths[index] * fontSize;
		}
	}
	else if (this.checkBox)
	{
		let shift = 0.75 * g_dKoef_pt_to_mm;
		let penW  = 0.75 * g_dKoef_pt_to_mm;
		
		let width   = this.GetWidth();
		let ascent  = this.ascent / AscWord.TEXTWIDTH_DIVIDER;
		let descent = this.descent / AscWord.TEXTWIDTH_DIVIDER;
		
		let y0 = y - ascent + shift;
		let y1 = y + descent - shift;
		let x0 = x + shift;
		let x1 = x + width - shift;
		
		context.drawHorLineExt(c_oAscLineDrawingRule.Top, y0, x0, x1, penW, 0, 0);
		context.drawHorLineExt(c_oAscLineDrawingRule.Bottom, y1, x0, x1, penW, 0, 0);
		context.drawVerLine(c_oAscLineDrawingRule.Left, x0, y0, y1, penW);
		context.drawVerLine(c_oAscLineDrawingRule.Right, x1, y0, y1, penW);
		
		let ffData  = this.ComplexField.GetBeginChar().GetFFData();
		if (ffData && ffData.isCheckBoxChecked())
		{
			context.p_width(0.5 * g_dKoef_pt_to_mm * 1000);
			let penW_2 = penW / 2;
			context._m(x0 + penW_2, y0 + penW_2);
			context._l(x1 - penW_2, y1 - penW_2);
			context.ds();
			
			context._m(x1 - penW_2, y0 + penW_2);
			context._l(x0 + penW_2, y1 - penW_2);
			context.ds();
		}
	}
};
ParaFieldChar.prototype.IsBegin = function()
{
	return (this.CharType === fldchartype_Begin ? true : false);
};
ParaFieldChar.prototype.IsEnd = function()
{
	return (this.CharType === fldchartype_End ? true : false);
};
ParaFieldChar.prototype.IsSeparate = function()
{
	return (this.CharType === fldchartype_Separate ? true : false);
};
ParaFieldChar.prototype.IsUse = function()
{
	return this.Use;
};
ParaFieldChar.prototype.SetUse = function(isUse)
{
	this.Use = isUse;
};
ParaFieldChar.prototype.GetComplexField = function()
{
	return this.ComplexField;
};
ParaFieldChar.prototype.SetComplexField = function(oComplexField)
{
	this.ComplexField = oComplexField;
};
ParaFieldChar.prototype.Write_ToBinary = function(writer)
{
	// Long : Type
	// Long : CharType
	writer.WriteLong(this.Type);
	writer.WriteLong(this.CharType);
	
	if (this.ffData)
	{
		writer.WriteBool(true);
		this.ffData.toBinary(writer);
	}
	else
	{
		writer.WriteBool(false);
	}
	
	//todo fldData
};
ParaFieldChar.prototype.Read_FromBinary = function(reader)
{
	// Long : CharType
	
	let charType = reader.GetLong();
	
	this.Init(charType, editor.WordControl.m_oLogicDocument);
	
	if (reader.GetBool())
		this.ffData = AscWord.FFData.fromBinary(reader);
	
	//todo fldData
};
ParaFieldChar.prototype.SetParent = function(oParent)
{
	this.Run = oParent;
};
ParaFieldChar.prototype.SetRun = function(oRun)
{
	this.Run = oRun;
};
ParaFieldChar.prototype.GetRun = function()
{
	return this.Run;
};
ParaFieldChar.prototype.GetParagraph = function()
{
	return this.Run ? this.Run.GetParagraph() : null;
};
ParaFieldChar.prototype.SetXY = function(X, Y)
{
	this.X = X;
	this.Y = Y;
};
ParaFieldChar.prototype.GetXY = function()
{
	return {X : this.X, Y : this.Y};
};
ParaFieldChar.prototype.SetPage = function(nPage)
{
	this.PageAbs = nPage;
};
ParaFieldChar.prototype.GetPage = function()
{
	return this.PageAbs;
};
ParaFieldChar.prototype.GetTopDocumentContent = function()
{
	if (!this.Run)
		return null;

	var oParagraph = this.Run.GetParagraph();
	if (!oParagraph)
		return null;

	return oParagraph.Parent.GetTopDocumentContent();
};
/**
 * Специальная функция для работы с полями PAGE NUMPAGES в колонтитулах
 * @param value {number}
 * @param numFormat {Asc.c_oAscNumberingFormat}
 */
ParaFieldChar.prototype.SetNumValue = function(value, numFormat)
{
	if (null === value)
	{
		this.numText = null;
		return;
	}
	
	this.numText = AscCommon.IntToNumberFormat(value, numFormat, {lang: this.textPr && this.textPr.Lang, isFromField: true, isSkipFractPart: true});
	this.private_UpdateWidth();
};
ParaFieldChar.prototype.SetHiddenValue = function(isHidden)
{
	this.hidden = isHidden;
};
ParaFieldChar.prototype.IsHiddenValue = function()
{
	return this.hidden;
};
/**
 * Специальная функция для работы с полями FORUMULA в колонтитулах
 * @param value {number|string}
 */
ParaFieldChar.prototype.SetFormulaValue = function(value)
{
	if (null === value)
	{
		this.numText = null;
		return;
	}
	
	this.numText = "" + value;
	this.private_UpdateWidth();
};
ParaFieldChar.prototype.GetFFData = function()
{
	return this.ffData;
};
ParaFieldChar.prototype.SetFormCheckBox = function()
{
	this.checkBox = true;
	this.private_UpdateWidth();
};
ParaFieldChar.prototype.GetNumFormat = function()
{
	let numFormat = Asc.c_oAscNumberingFormat.Decimal;
	let cf = this.ComplexField;
	let instruction = cf.IsValid() ? cf.GetInstruction() : null;
	if (instruction && instruction.haveNumericFormat())
		numFormat = instruction.getNumericFormat();
	
	return numFormat;
};
ParaFieldChar.prototype.UpdatePageCount = function(pageCount)
{
	let cf = this.ComplexField;
	if (!cf)
		return;
	
	let instruction = cf.GetInstruction();
	if (!instruction)
		return;
	
	let fieldType = instruction.GetType();
	if (fieldType === AscWord.fieldtype_FORMULA)
	{
		let value =  parseInt(cf.CalculateValue());
		if (isNaN(value))
			value = 0;
		
		this.SetFormulaValue(value);
	}
	else if (fieldType === AscWord.fieldtype_NUMPAGES)
	{
		this.SetNumValue(pageCount, this.GetNumFormat());
	}
};
ParaFieldChar.prototype.private_UpdateWidth = function()
{
	let totalWidth = 0;
	
	if (this.numText)
	{
		AscWord.stringShaper.Shape(this.numText.codePointsArray(), this.textPr);
		
		this.graphemes = AscWord.stringShaper.GetGraphemes();
		this.widths    = AscWord.stringShaper.GetWidths();
		
		for (let index = 0; index < this.widths.length; ++index)
		{
			totalWidth += this.widths[index];
		}
		let fontSize = this.textPr.FontSize * this.textPr.getFontCoef();
		totalWidth   = (totalWidth * fontSize * AscWord.TEXTWIDTH_DIVIDER) | 0;
	}
	else if (this.checkBox)
	{
		let fontSize = this.textPr.FontSize * this.textPr.getFontCoef();
		let ffData = this.ComplexField.GetBeginChar().GetFFData();
		if (ffData && !ffData.isCheckBoxAutoSize())
			fontSize = ffData.getCheckBoxSize();
		
		let textPr = this.textPr.Copy();
		textPr.FontSize = fontSize;
		
		AscCommon.g_oTextMeasurer.SetTextPr(textPr);
		AscCommon.g_oTextMeasurer.SetFontSlot(AscWord.fontslot_ASCII, 1);
		
		let textHeight = AscCommon.g_oTextMeasurer.GetHeight();
		totalWidth = (textHeight * AscWord.TEXTWIDTH_DIVIDER) | 0;
		
		// Для совместимости при работе с RecalcObject
		this.graphemes = [];
		this.widths    = [];
		this.ascent    = (AscCommon.g_oTextMeasurer.GetAscender() * AscWord.TEXTWIDTH_DIVIDER) | 0;
		this.descent   = (-AscCommon.g_oTextMeasurer.GetDescender() * AscWord.TEXTWIDTH_DIVIDER) | 0;
	}
	
	this.Width        = totalWidth;
	this.WidthVisible = totalWidth;
};
ParaFieldChar.prototype.IsNumValue = function()
{
	return (this.IsEnd() && null !== this.numText);
};
ParaFieldChar.prototype.IsVisual = function()
{
	return (this.IsEnd() && (null !== this.numText || null !== this.checkBox));
};
ParaFieldChar.prototype.IsFormField = function()
{
	return !!(this.checkBox);
};
ParaFieldChar.prototype.IsNeedSaveRecalculateObject = function()
{
	return this.IsVisual();
};
ParaFieldChar.prototype.SaveRecalculateObject = function(isCopy)
{
	return new FieldCharRecalculateObject(this.Type, this.numText, this.checkBox, this.graphemes, this.widths, this.Width, this.ascent, this.descent, isCopy);
};
ParaFieldChar.prototype.LoadRecalculateObject = function(recalcObj)
{
	this.numText      = recalcObj.numText;
	this.checkBox     = recalcObj.checkBox;
	this.graphemes    = recalcObj.graphemes;
	this.widths       = recalcObj.widths;
	this.Width        = recalcObj.width;
	this.WidthVisible = this.Width;
	this.ascent       = recalcObj.ascent;
	this.descent      = recalcObj.descent;
};
ParaFieldChar.prototype.PrepareRecalculateObject = function()
{
	this.graphemes = [];
	this.widths    = [];
	this.checkBox  = null;
	this.numText   = null;
};
ParaFieldChar.prototype.IsValid = function()
{
	var oRun = this.GetRun();
	return (oRun && oRun.IsUseInDocument() && -1 !== oRun.GetElementPosition(this));
};
ParaFieldChar.prototype.PreDelete = function()
{
	if (this.LogicDocument && this.ComplexField)
		this.LogicDocument.ValidateComplexField(this.ComplexField);
};
ParaFieldChar.prototype.FindNextFillingForm = function(isNext, isCurrent, isStart)
{
	if (!this.ComplexField
		|| !this.ComplexField.IsFormField()
		|| !this.ComplexField.IsFormFieldEnabled())
		return null;
	
	if (isNext)
		return (this.IsBegin() && (!isCurrent || isNext) ? this.ComplexField : null);
	else
		return (this.IsEnd() && (!isCurrent || isNext) ? this.ComplexField : null);
};
ParaFieldChar.prototype.IsShowFieldCode = function()
{
	return this.showFieldCode;
};
ParaFieldChar.prototype.SetShowFieldCode = function(isShow)
{
	this.showFieldCode = isShow;
};
ParaFieldChar.prototype.MoveCursorToChar = function(isBefore)
{
	let run = this.GetRun();
	if (!run)
		return;
	let inRunPos = run.GetElementPosition(this);
	if (-1 === inRunPos)
		return;
	
	if (this.LogicDocument)
		this.LogicDocument.RemoveSelection();
	
	if (false === isBefore)
		inRunPos += 1
	
	run.Make_ThisElementCurrent(false);
	run.SetCursorPosition(inRunPos);
};

/**
 * @constructor
 */
function FieldCharRecalculateObject(type, numText, checkBox, graphemes, widths, totalWidth, ascent, descent, isCopy)
{
	this.type      = type;
	this.numText   = numText;
	this.checkBox  = checkBox;
	this.graphemes = graphemes && isCopy ? graphemes.slice() : graphemes;
	this.widths    = widths && isCopy ? widths.slice() : widths;
	this.width     = totalWidth;
	this.ascent    = ascent;
	this.descent   = descent;
}

/**
 * Класс представляющий символ инструкции сложного поля
 * @param {Number} nCharCode
 * @constructor
 */
function ParaInstrText(nCharCode)
{
	AscWord.CRunElementBase.call(this);

	this.Value        = (undefined !== nCharCode ? nCharCode : 0x00);
	this.Width        = 0x00000000 | 0;
	this.WidthVisible = 0x00000000 | 0;
	this.Run          = null;
	this.Replacement  = null; // Используется, когда InstrText идет в неположенном месте и должно восприниматься как обычный текст
}
ParaInstrText.prototype = Object.create(AscWord.CRunElementBase.prototype);
ParaInstrText.prototype.constructor = ParaInstrText;
ParaInstrText.prototype.Type = para_InstrText;
ParaInstrText.prototype.IsInstrText = function()
{
	return true;
};
ParaInstrText.prototype.Copy = function()
{
	return new ParaInstrText(this.Value);
};
ParaInstrText.prototype.Measure = function(Context, TextPr)
{
};
ParaInstrText.prototype.Draw = function(X, Y, Context)
{
};
ParaInstrText.prototype.Write_ToBinary = function(Writer)
{
	// Long : Type
	// Long : Value
	Writer.WriteLong(this.Type);
	Writer.WriteLong(this.Value);
};
ParaInstrText.prototype.Read_FromBinary = function(Reader)
{
	// Long : Value
	this.Value = Reader.GetLong();
};
ParaInstrText.prototype.SetParent = function(oParent)
{
	this.Run = oParent;
};
ParaInstrText.prototype.SetRun = function(oRun)
{
	this.Run = oRun;
};
ParaInstrText.prototype.GetRun = function()
{
	return this.Run;
};
ParaInstrText.prototype.GetValue = function()
{
	return String.fromCharCode(this.Value);
};
ParaInstrText.prototype.GetCodePoint = function()
{
	return this.Value;
};
ParaInstrText.prototype.GetCharCode = function()
{
	return this.Value;
};
ParaInstrText.prototype.SetCharCode = function(CharCode)
{
	this.Value = CharCode;
};
ParaInstrText.prototype.SetReplacementItem = function(oItem)
{
	this.Replacement = oItem;
};
ParaInstrText.prototype.GetReplacementItem = function()
{
	return this.Replacement;
};
AscWord.ParaInstrText = ParaInstrText;

function CComplexField(logicDocument)
{
	this.LogicDocument   = logicDocument;
	this.Current         = false;
	this.BeginChar       = null;
	this.EndChar         = null;
	this.SeparateChar    = null;
	this.InstructionLine = "";
	this.Instruction     = null;
	this.FieldId         = logicDocument && logicDocument.IsDocumentEditor() ? logicDocument.GetFieldsManager().GetNewComplexFieldId() : null;

	this.InstructionLineSrc = "";
	this.InstructionCF      = [];
	this.InstructionItems   = [];

	this.StartUpdate = false;
}
CComplexField.prototype.GetFieldId = function()
{
	return this.FieldId;
};
CComplexField.prototype.SetCurrent = function(isCurrent)
{
	this.Current = isCurrent;
};
CComplexField.prototype.IsCurrent = function()
{
	return this.Current;
};
CComplexField.prototype.IsUpdate = function()
{
	return (this.StartUpdate > 0);
};
CComplexField.prototype.StartCharsUpdate = function()
{
	++this.StartUpdate;
};
CComplexField.prototype.FinishCharsUpdate = function()
{
	if (this.StartUpdate > 0)
		--this.StartUpdate;
};
CComplexField.prototype.SetInstruction = function(oParaInstr)
{
	this.InstructionLine += oParaInstr.GetValue();
	this.InstructionLineSrc += oParaInstr.GetValue();
	this.InstructionItems.push(oParaInstr);
};
CComplexField.prototype.SetInstructionCF = function(oCF)
{
	this.InstructionLine += " \\& ";
	this.InstructionLineSrc +=  " \\& ";
	this.InstructionCF.push(oCF);
};
CComplexField.prototype.SetInstructionLine = function(sLine)
{
	this.InstructionLine = sLine;
};
CComplexField.prototype.GetInstructionLine = function()
{
	return this.InstructionLine;
};
CComplexField.prototype.GetBeginChar = function()
{
	return this.BeginChar;
};
CComplexField.prototype.GetEndChar = function()
{
	return this.EndChar;
};
CComplexField.prototype.GetSeparateChar = function()
{
	return this.SeparateChar;
};
CComplexField.prototype.SetBeginChar = function(oChar)
{
	oChar.SetComplexField(this);

	this.BeginChar       = oChar;
	this.SeparateChar    = null;
	this.EndChar         = null;
	this.InstructionLine = "";

	this.InstructionLineSrc = "";
	this.InstructionCF      = [];
	this.InstructionItems   = [];
};
CComplexField.prototype.SetEndChar = function(oChar)
{
	oChar.SetComplexField(this);

	this.EndChar = oChar;
};
CComplexField.prototype.SetSeparateChar = function(oChar)
{
	oChar.SetComplexField(this);

	this.SeparateChar = oChar;
	this.EndChar      = null;
};
CComplexField.prototype.ReplaceChar = function(oChar)
{
	oChar.SetComplexField(this);

	if (oChar.IsBegin())
		this.BeginChar = oChar;
	else if (oChar.IsSeparate())
		this.SeparateChar = oChar;
	else if (oChar.IsEnd())
		this.EndChar = oChar;
};
CComplexField.prototype.Update = function(isCreateHistoryPoint, isNeedRecalculate)
{
	this.private_CheckNestedComplexFields();
	this.private_UpdateInstruction();

	if (!this.Instruction || !this.IsValid())
		return false;
	
	// TODO: Нужно добавить разделитель, если его нет. Пока не обновляем такие поля
	if (!this.HaveValuePart())
		return false;

	this.SelectFieldValue();

	if (true === isCreateHistoryPoint)
	{
		if (true === this.LogicDocument.Document_Is_SelectionLocked(changestype_Paragraph_Content))
			return false;

		this.LogicDocument.StartAction();
	}

	this.StartCharsUpdate();
	switch (this.Instruction.GetType())
	{
		case AscWord.fieldtype_PAGE:
		case AscWord.fieldtype_PAGENUM:
			this.private_UpdatePAGE();
			break;
		case AscWord.fieldtype_TOC:
			this.private_UpdateTOC();
			break;
		case AscWord.fieldtype_PAGEREF:
			this.private_UpdatePAGEREF();
			break;
		case AscWord.fieldtype_NUMPAGES:
		case AscWord.fieldtype_PAGECOUNT:
			this.private_UpdateNUMPAGES();
			break;
		case AscWord.fieldtype_FORMULA:
			this.private_UpdateFORMULA();
			break;
		case AscWord.fieldtype_SEQ:
			this.private_UpdateSEQ();
			break;
		case AscWord.fieldtype_STYLEREF:
			this.private_UpdateSTYLEREF();
			break;
		case AscWord.fieldtype_TIME:
		case AscWord.fieldtype_DATE:
			this.private_UpdateTIME();
			break;
		case AscWord.fieldtype_REF:
			this.private_UpdateREF();
			break;
		case AscWord.fieldtype_NOTEREF:
			this.private_UpdateNOTEREF();
			break;
		case AscWord.fieldtype_FORMCHECKBOX:
		case AscWord.fieldtype_FORMTEXT:
		case AscWord.fieldtype_ADDIN:
			break;
	}
	this.FinishCharsUpdate();

	if (false !== isNeedRecalculate)
		this.LogicDocument.Recalculate();

	if (isCreateHistoryPoint)
	{
		this.LogicDocument.FinalizeAction();
	}
	
	return true;
};
CComplexField.prototype.CalculateValue = function()
{
	this.private_CheckNestedComplexFields();
	this.private_UpdateInstruction();

	if (!this.Instruction || !this.BeginChar || !this.EndChar || !this.SeparateChar)
		return;

	var sResult = "";
	switch (this.Instruction.GetType())
	{
		case AscWord.fieldtype_PAGE:
		case AscWord.fieldtype_PAGENUM:
			sResult = this.private_CalculatePAGE();
			break;
		case AscWord.fieldtype_TOC:
			sResult = "";
			break;
		case AscWord.fieldtype_PAGEREF:
			sResult = this.private_CalculatePAGEREF();
			break;
		case AscWord.fieldtype_NUMPAGES:
		case AscWord.fieldtype_PAGECOUNT:
			sResult = this.private_CalculateNUMPAGES();
			break;
		case AscWord.fieldtype_FORMULA:
			sResult = this.private_CalculateFORMULA();
			break;
		case AscWord.fieldtype_SEQ:
			sResult = this.private_CalculateSEQ();
			break;
		case AscWord.fieldtype_STYLEREF:
			sResult = this.private_CalculateSTYLEREF();
			break;
		case AscWord.fieldtype_TIME:
		case AscWord.fieldtype_DATE:
			sResult = this.private_CalculateTIME();
			break;
		case AscWord.fieldtype_REF:
			sResult = this.private_CalculateREF();
			break;
		case AscWord.fieldtype_NOTEREF:
			sResult = this.private_CalculateNOTEREF();
			break;
		case AscWord.fieldtype_FORMCHECKBOX:
		case AscWord.fieldtype_FORMTEXT:
		case AscWord.fieldtype_ADDIN:
			sResult = "";
			break;
	}

	return sResult;
};
CComplexField.prototype.UpdateTIME = function(ms)
{
	this.private_CheckNestedComplexFields();
	this.private_UpdateInstruction();

	if (!this.Instruction
		|| !this.BeginChar
		|| !this.EndChar
		|| !this.SeparateChar
		|| (AscWord.fieldtype_TIME !== this.Instruction.GetType() && AscWord.fieldtype_DATE !== this.Instruction.GetType()))
		return;

	this.SelectFieldValue();
	this.private_UpdateTIME(ms);
};
CComplexField.prototype.IsHaveNestedNUMPAGES = function()
{
	for (let index = 0, count = this.InstructionCF.length; index < count; ++index)
	{
		let instruction = this.InstructionCF[index].GetInstruction();
		if (instruction && AscWord.fieldtype_NUMPAGES === instruction.GetType())
			return true;
		
		if (this.InstructionCF[index].IsHaveNestedNUMPAGES())
			return true;
	}
	
	return false;
};

CComplexField.prototype.private_UpdateSEQ = function()
{
	this.LogicDocument.AddText(this.private_CalculateSEQ());
};
CComplexField.prototype.private_CalculateSEQ = function()
{
	return this.Instruction.GetText();
};
CComplexField.prototype.private_UpdateSTYLEREF = function()
{
	this.LogicDocument.AddText(this.private_CalculateSTYLEREF());
};
CComplexField.prototype.private_CalculateSTYLEREF = function()
{
	return this.Instruction.GetText();
};
CComplexField.prototype.private_InsertMessage = function(sMessage, oTextPr)
{
	var oSelectedContent = new AscCommonWord.CSelectedContent();
	var oPara = new AscWord.Paragraph();
	var oRun  = new ParaRun(oPara, false);
	if(oTextPr)
	{
		oRun.Apply_Pr(oTextPr);
	}
	oRun.AddText(sMessage);
	oPara.AddToContent(0, oRun);
	oSelectedContent.Add(new AscCommonWord.CSelectedElement(oPara, false));
	this.private_InsertContent(oSelectedContent);
};
CComplexField.prototype.private_InsertContent = function(oSelectedContent)
{
	this.SelectFieldValue();
	this.LogicDocument.ConcatParagraphsOnRemove = true;
	this.LogicDocument.Remove(1, false, false, true);
	this.LogicDocument.ConcatParagraphsOnRemove = false;

	var oRun       = this.BeginChar.GetRun();
	var oParagraph = oRun.GetParagraph();
	if (oParagraph)
	{
		var oAnchorPos = oParagraph.GetCurrentAnchorPosition();
		if (oAnchorPos && oSelectedContent.CanInsert(oAnchorPos))
		{
			oParagraph.Check_NearestPos(oAnchorPos);
			oSelectedContent.ForceInlineInsert();
			oSelectedContent.Insert(oAnchorPos);
			this.MoveCursorOutsideElement(false);
		}
	}
};
CComplexField.prototype.private_UpdateFORMULA = function()
{
	this.Instruction.Calculate(this.LogicDocument);
	if (this.Instruction.ErrStr !== null)
	{
		var oTextPr = new CTextPr();
		oTextPr.Set_FromObject({Bold : true});
		this.private_InsertMessage(this.Instruction.ErrStr, oTextPr);
	}
	else if (null !== this.Instruction.ResultStr)
	{
		
		this.private_InsertMessage(this.Instruction.GetResultString(), null);
	}
};
CComplexField.prototype.private_CalculateFORMULA = function()
{
	this.Instruction.Calculate(this.LogicDocument);
	if (null !== this.Instruction.ErrStr)
		return this.Instruction.ErrStr;

	return this.Instruction.ResultStr;
};
CComplexField.prototype.private_UpdatePAGE = function()
{
	this.LogicDocument.AddText("" + this.private_CalculatePAGE());
};
CComplexField.prototype.private_CalculatePAGE = function()
{
	var oRun       = this.BeginChar.GetRun();
	var oParagraph = oRun.GetParagraph();
	var nInRunPos  = oRun.GetElementPosition(this.BeginChar);
	var nLine      = oRun.GetLineByPosition(nInRunPos);
	var nPage      = oParagraph.getPageByLine(nLine);

	var oLogicDocument = oParagraph.LogicDocument;
	return oLogicDocument.Get_SectionPageNumInfo2(oParagraph.GetAbsolutePage(nPage)).CurPage;
};
CComplexField.prototype.private_UpdateTOC = function()
{
	this.LogicDocument.GetBookmarksManager().RemoveTOCBookmarks();

	var nTabPos = 9345 / 20 / 72 * 25.4; // Стандартное значение для A4 и обычных полей 3см и 2см
	var oSectPr = this.LogicDocument.GetCurrentSectionPr();
	if (oSectPr)
	{
		if (oSectPr.GetColumnCount() > 1)
		{
			// TODO: Сейчас забирается ширина текущей колонки. По правильному надо читать поля от текущего места
			nTabPos = Math.max(0, Math.min(oSectPr.GetColumnWidth(0), oSectPr.GetPageWidth(), oSectPr.GetContentFrameWidth()));
		}
		else
		{
			nTabPos = Math.max(0, Math.min(oSectPr.GetPageWidth(), oSectPr.GetContentFrameWidth()));
		}
	}

	var oStyles          = this.LogicDocument.Get_Styles();
	var arrOutline;
	var sCaption         = this.Instruction.GetCaption(); //flag c
	var sCaptionOnlyText = this.Instruction.GetCaptionOnlyText();//flag a
	
	var oBookmarksManager = this.LogicDocument.GetBookmarksManager();
	if (undefined === sCaption && undefined !== sCaptionOnlyText)
		sCaption = sCaptionOnlyText;
	
	var oOutlinePr = {
		OutlineStart : this.Instruction.GetHeadingRangeStart(),
		OutlineEnd   : this.Instruction.GetHeadingRangeEnd(),
		Styles       : this.Instruction.GetStylesArray()
	};
	var bTOF = false;
	var bSkipCaptionLbl = false;
	if (undefined !== sCaption)
	{
		bTOF = true;
		var aStyles = this.Instruction.GetStylesArray();
		if(aStyles.length > 0)
		{
			arrOutline = this.LogicDocument.GetOutlineParagraphs(null, oOutlinePr);
		}
		else
		{
			arrOutline = [];
			if (sCaptionOnlyText !== undefined)
				bSkipCaptionLbl = true;
			
			var aParagraphs = this.LogicDocument.GetAllCaptionParagraphs(sCaption);
			var oCurPara;
			for (var nParagraph = 0; nParagraph < aParagraphs.length; ++nParagraph)
			{
				oCurPara = aParagraphs[nParagraph];
				if (!bSkipCaptionLbl || oCurPara.CanAddRefAfterSEQ(sCaption))
					arrOutline.push({Paragraph : oCurPara, Lvl : 0});
			}
		}
	}
	else
	{
		arrOutline = this.LogicDocument.GetOutlineParagraphs(null, oOutlinePr);
	}
	var oSelectedContent = new AscCommonWord.CSelectedContent();

	var isPreserveTabs   = this.Instruction.IsPreserveTabs();
	var sSeparator       = this.Instruction.GetSeparator();

	var nForceTabLeader = this.Instruction.GetForceTabLeader();

	var oTab = new CParaTab(tab_Right, nTabPos, Asc.c_oAscTabLeader.Dot);
	var oPara, oTabs, oRun;
	if (undefined !== nForceTabLeader)
	{
		oTab = new CParaTab(tab_Right, nTabPos, nForceTabLeader);
	}
	else if ((!sSeparator || "" === sSeparator) && arrOutline.length > 0)
	{
		var arrSelectedParagraphs = this.LogicDocument.GetCurrentParagraph(false, true);
		if (arrSelectedParagraphs.length > 0)
		{
			oPara = arrSelectedParagraphs[0];
			oTabs = oPara.GetParagraphTabs();

			if (oTabs.Tabs.length > 0)
				oTab = oTabs.Tabs[oTabs.Tabs.length - 1];
		}
	}

	if (arrOutline.length > 0)
	{
		for (var nIndex = 0, nCount = arrOutline.length; nIndex < nCount; ++nIndex)
		{
			var oSrcParagraph = arrOutline[nIndex].Paragraph;
			var sBookmarkName;
			var oParaForCopy = oSrcParagraph;
			if(bSkipCaptionLbl)
			{
				sBookmarkName = oSrcParagraph.AddBookmarkForCaption(sCaption, true, true);
				if(!sBookmarkName)
				{
					sBookmarkName = oSrcParagraph.AddBookmarkForTOC();
				}
				oBookmarksManager.SelectBookmark(sBookmarkName);
				var oParaSelectedContent = this.LogicDocument.GetSelectedContent(false);
				var oElement = oParaSelectedContent.Elements[0];
				if(oElement && oElement.Element.GetType() === type_Paragraph)
				{
					oParaForCopy = oElement.Element;
				}
			}
			else
			{
				sBookmarkName = oSrcParagraph.AddBookmarkForTOC();
			}
			oPara = oParaForCopy.Copy(null, null, {
				SkipPageBreak         : true,
				SkipLineBreak         : this.Instruction.IsRemoveBreaks(),
				SkipColumnBreak       : true,
				SkipAnchors           : true,
				SkipFootnoteReference : true,
				SkipComplexFields     : true,
				SkipComments          : true,
				SkipBookmarks         : true,
				CopyReviewPr          : false
			});
			oPara.RemovePrChange();
			if(bTOF)
			{
				oPara.Style_Add(oStyles.GetDefaultTOF(), false);
			}
			else
			{
				oPara.Style_Add(oStyles.GetDefaultTOC(arrOutline[nIndex].Lvl), false);
			}
			oPara.SetOutlineLvl(undefined);

			var oClearTextPr = new CTextPr();
			oClearTextPr.Set_FromObject({
				FontSize  : null,
				Unifill   : null,
				Underline : null,
				Color     : null
			});

			// Дополнительно очищаем текстовые настройки, которые были заданы непосредственно в самом стиле
			var oSrcPStylePr = oStyles.Get_Pr(oSrcParagraph.Style_Get(), styletype_Paragraph, oSrcParagraph.Parent.Get_TableStyleForPara(), oSrcParagraph.Parent.Get_ShapeStyleForPara()).TextPr;
			var oDefaultPr   = oStyles.Get_Pr(oStyles.GetDefaultParagraph(), styletype_Paragraph, null, null).TextPr;

			if (oSrcPStylePr.Bold !== oDefaultPr.Bold)
			{
				oClearTextPr.Bold   = null;
				oClearTextPr.BoldCS = null;
			}

			if (oSrcPStylePr.Italic !== oDefaultPr.Italic)
			{
				oClearTextPr.Italic   = null;
				oClearTextPr.ItalicCS = null;
			}

			oPara.SelectAll();
			oPara.ApplyTextPr(oClearTextPr);
			oPara.RemoveSelection();



			var oContainer    = oPara,
				nContainerPos = 0;

			if (this.Instruction.IsHyperlinks())
			{
				var sHyperlinkStyleId = oStyles.GetDefaultHyperlink();

				var oHyperlink = new ParaHyperlink();
				for (var nParaPos = 0, nParaCount = oPara.Content.length - 1; nParaPos < nParaCount; ++nParaPos)
				{
					// TODO: Проверить, нужно ли проставлять этот стиль во внутренние раны
					if (oPara.Content[0] instanceof ParaRun)
						oPara.Content[0].Set_RStyle(sHyperlinkStyleId);

					oHyperlink.Add_ToContent(nParaPos, oPara.Content[0]);
					oPara.Remove_FromContent(0, 1);
				}
				oHyperlink.SetAnchor(sBookmarkName);
				oPara.Add_ToContent(0, oHyperlink);

				oContainer    = oHyperlink;
				nContainerPos = oHyperlink.Content.length;
			}
			else
			{
				// TODO: ParaEnd
				oContainer    = oPara;
				nContainerPos = oPara.Content.length - 1;
			}

			let numTabPos = null;
			if (oSrcParagraph.HaveNumbering() && oSrcParagraph.GetParent())
			{
				var oNumPr     = oSrcParagraph.GetNumPr();
				var oNumbering = this.LogicDocument.GetNumbering();
				var oNumInfo   = oSrcParagraph.GetParent().CalculateNumberingValues(oSrcParagraph, oNumPr);
				var sText      = oNumbering.GetText(oNumPr.NumId, oNumPr.Lvl, oNumInfo);
				var oNumTextPr = oSrcParagraph.GetNumberingCompiledPr();

				var oNumberingRun = new ParaRun(oPara, false);
				oNumberingRun.AddText(sText);

				if (oNumTextPr)
					oNumberingRun.Set_RFonts(oNumTextPr.RFonts);

				oContainer.Add_ToContent(0, oNumberingRun);
				nContainerPos++;

				var oNumTabRun = new ParaRun(oPara, false);

				var oNumLvl  = oNumbering.GetNum(oNumPr.NumId).GetLvl(oNumPr.Lvl);
				var nNumSuff = oNumLvl.GetSuff();

				if (Asc.c_oAscNumberingSuff.Space === nNumSuff)
				{
					oNumTabRun.Add_ToContent(0, new AscWord.CRunSpace());
					oContainer.Add_ToContent(1, oNumTabRun);
					nContainerPos++;
				}
				else if (Asc.c_oAscNumberingSuff.Tab === nNumSuff)
				{
					// Выставление родительского класса нужно для правильного расчета ширины рана с учетом того,
					// что используемые шрифты могут быть заданы в темах
					oPara.SetParent(oSrcParagraph.GetParent());
					
					numTabPos = 0;
					AscWord.ParagraphTextShaper.ShapeRun(oNumberingRun);
					for (let runItemIndex = 0; runItemIndex < oNumberingRun.GetElementsCount(); ++runItemIndex)
						numTabPos += oNumberingRun.GetElement(runItemIndex).GetWidth();
					
					oNumTabRun.Add_ToContent(0, new AscWord.CRunTab());
					oContainer.Add_ToContent(1, oNumTabRun);
					nContainerPos++;
				}
			}

			// Word добавляет табы независимо о наличия Separator и PAGEREF
			oTabs = new CParaTabs();
			oTabs.Add(oTab);

			if ((!isPreserveTabs && oPara.RemoveTabsForTOC()) || null !== numTabPos)
			{
				// В данной ситуации ворд делает следующим образом: он пробегает по параграфу и смотрит, если там есть
				// табы (в контенте, а не в свойствах), тогда он первый таб оставляет, а остальные заменяет на пробелы,
				// при этом в список табов добавляется новый левый таб без заполнителя, отступающий на 1,16 см от левого
				// поля параграфа, т.е. позиция таба зависит от стиля.

				var nFirstTabPos = 11.6;
				var sTOCStyleId  = this.LogicDocument.GetStyles().GetDefaultTOC(arrOutline[nIndex].Lvl);
				if (sTOCStyleId)
				{
					let paraPr = this.LogicDocument.GetStyles().Get_Pr(sTOCStyleId, styletype_Paragraph, null, null).ParaPr;
					if (null !== numTabPos)
						nFirstTabPos = Math.trunc((paraPr.Ind.Left + paraPr.Ind.FirstLine + numTabPos + 4.9) / 5 + 1) * 5;
					else
						nFirstTabPos = 1.6 + (paraPr.Ind.Left + paraPr.Ind.FirstLine);
				}
				
				oTabs.Add(new CParaTab(tab_Left, nFirstTabPos, Asc.c_oAscTabLeader.None));
			}

			oPara.Set_Tabs(oTabs);

			if (!(this.Instruction.IsSkipPageRefLvl(arrOutline[nIndex].Lvl)))
			{
				var oSeparatorRun = new ParaRun(oPara, false);
				if (!sSeparator || "" === sSeparator)
					oSeparatorRun.AddToContent(0, new AscWord.CRunTab());
				else
					oSeparatorRun.AddText(sSeparator.charAt(0));

				oContainer.Add_ToContent(nContainerPos, oSeparatorRun);

				var oPageRefRun = new ParaRun(oPara, false);

				oPageRefRun.AddToContent(-1, new ParaFieldChar(fldchartype_Begin, this.LogicDocument));
				oPageRefRun.AddInstrText("PAGEREF " + sBookmarkName + " \\h");
				oPageRefRun.AddToContent(-1, new ParaFieldChar(fldchartype_Separate, this.LogicDocument));
				oPageRefRun.AddText("" + this.LogicDocument.Get_SectionPageNumInfo2(oSrcParagraph.GetFirstNonEmptyPageAbsolute()).CurPage);
				oPageRefRun.AddToContent(-1, new ParaFieldChar(fldchartype_End, this.LogicDocument));
				oContainer.Add_ToContent(nContainerPos + 1, oPageRefRun);
			}

			oSelectedContent.Add(new AscCommonWord.CSelectedElement(oPara, true));
		}
	}
	else
	{
		var sReplacementText;
		if (bTOF)
		{
			sReplacementText = AscCommon.translateManager.getValue("No table of figures entries found.");
		}
		else
		{
			sReplacementText = AscCommon.translateManager.getValue("No table of contents entries found.");

			let oApi = this.LogicDocument.GetApi();
			oApi.sendEvent("asc_onError", c_oAscError.ID.ComplexFieldEmptyTOC, c_oAscError.Level.NoCritical);
		}

		oPara = new AscWord.Paragraph();
		oRun  = new ParaRun(oPara, false);
		oRun.SetBold(true);
		oRun.AddText(sReplacementText);
		oPara.AddToContent(0, oRun);
		oSelectedContent.Add(new AscCommonWord.CSelectedElement(oPara, true));
	}

	this.SelectFieldValue();
	this.LogicDocument.ConcatParagraphsOnRemove = true;
	this.LogicDocument.Remove(1, false, false, true);
	this.LogicDocument.ConcatParagraphsOnRemove = false;
	oRun = this.BeginChar.GetRun();

	let oParagraph = oRun.GetParagraph();
	let oAnchorPos = {
		Paragraph  : oParagraph,
		ContentPos : oParagraph.Get_ParaContentPos(false, false)
	};
	oParagraph.Check_NearestPos(oAnchorPos);
	oSelectedContent.Insert(oAnchorPos);
};
CComplexField.prototype.private_UpdatePAGEREF = function()
{
	var oBookmarksManager = this.LogicDocument.GetBookmarksManager();
	var oBookmark = oBookmarksManager.GetBookmarkByName(this.Instruction.GetBookmarkName());
	if(!oBookmark)
	{
		var sValue = AscCommon.translateManager.getValue("Error! Bookmark not defined.");
		this.private_InsertError(sValue);
		return;
	}
	this.LogicDocument.AddText(this.private_CalculatePAGEREF());
};
CComplexField.prototype.private_CalculatePAGEREF = function()
{
	var oBookmarksManager = this.LogicDocument.GetBookmarksManager();
	var oBookmark = oBookmarksManager.GetBookmarkByName(this.Instruction.GetBookmarkName());

	var sValue = AscCommon.translateManager.getValue("Error! Bookmark not defined.");
	if (oBookmark)
	{
		var oStartBookmark = oBookmark[0];
		var nBookmarkPage  = oStartBookmark.GetPage() + 1;
		if (this.Instruction.IsPositionRelative())
		{
			if (oStartBookmark.GetPage() === this.SeparateChar.GetPage())
			{
				var oBookmarkXY = oStartBookmark.GetXY();
				var oFieldXY    = this.SeparateChar.GetXY();

				if (Math.abs(oBookmarkXY.Y - oFieldXY.Y) < 0.001)
					sValue = oBookmarkXY.X < oFieldXY.X ? AscCommon.translateManager.getValue("above") : AscCommon.translateManager.getValue("below");
				else if (oBookmarkXY.Y < oFieldXY.Y)
					sValue = AscCommon.translateManager.getValue("above");
				else
					sValue = AscCommon.translateManager.getValue("below");
			}
			else
			{
				sValue = AscCommon.translateManager.getValue("on page ") + nBookmarkPage;
			}
		}
		else
		{
			sValue = (this.LogicDocument.Get_SectionPageNumInfo2(oStartBookmark.GetPage()).CurPage) + "";
		}
	}

	return sValue;
};
CComplexField.prototype.private_UpdateNUMPAGES = function()
{
	this.LogicDocument.AddText("" + this.private_CalculateNUMPAGES());
};
CComplexField.prototype.private_CalculateNUMPAGES = function()
{
	return this.LogicDocument.GetPagesCount();
};
CComplexField.prototype.private_UpdateTIME = function(ms)
{
	var sDate = this.private_CalculateTIME(ms);

	if (sDate)
		this.LogicDocument.AddText(sDate);
};
CComplexField.prototype.private_CalculateTIME = function(ms)
{
	var nLangId = 1033;
	var oSepChar = this.GetSeparateChar();
	if (oSepChar && oSepChar.GetRun())
	{
		var oCompiledTextPr = oSepChar.GetRun().Get_CompiledPr(false);
		nLangId = oCompiledTextPr.Lang.Val;
	}

	var sFormat = this.Instruction.GetFormat();
	var oFormat = AscCommon.oNumFormatCache.get(sFormat, AscCommon.NumFormatType.WordFieldDate);
	var sDate   = "";
	if (oFormat)
	{
		var oCultureInfo = AscCommon.g_aCultureInfos[nLangId];

		if (undefined !== ms)
		{
			var oDateTime = new Asc.cDate(ms);
			sDate         = oFormat.formatToWord(oDateTime.getExcelDate(true) + (oDateTime.getUTCHours() * 60 * 60 + oDateTime.getMinutes() * 60 + oDateTime.getSeconds()) / AscCommonExcel.c_sPerDay, 15, oCultureInfo);

		}
		else
		{
			let oDateTime = new Asc.cDate();
			sDate         = oFormat.formatToWord(oDateTime.getExcelDate(true) + (oDateTime.getHours() * 60 * 60 + oDateTime.getMinutes() * 60 + oDateTime.getSeconds()) / AscCommonExcel.c_sPerDay, 15, oCultureInfo);
		}
	}

	return sDate;
};
CComplexField.prototype.private_InsertError = function(sText)
{
	var oTextPr = new CTextPr();
	oTextPr.Set_FromObject({Bold: true});
	this.private_InsertMessage(sText, oTextPr);
};
CComplexField.prototype.private_GetREFPosValue = function()
{
	var oBookmarksManager = this.LogicDocument.GetBookmarksManager();
	var sBookmarkName = this.Instruction.GetBookmarkName();
	var oBookmark = oBookmarksManager.GetBookmarkByName(sBookmarkName);
	if(!oBookmark)
	{
		return "";
	}
	var oStartBookmark = oBookmark[0];
	var oSrcParagraph = oStartBookmark.Paragraph;
	var oRun       = this.BeginChar.GetRun();
	var oParagraph = oRun.GetParagraph();
	if(!oSrcParagraph || !oParagraph)
	{
		return "";
	}
	var oParent = oParagraph.GetParent();
	var oSrcParent = oSrcParagraph.GetParent();
	if(!oParent || !oSrcParent)
	{
		return "";
	}
	var oTopDoc = oParent.Is_TopDocument(true);
	if(oTopDoc !== oSrcParent.Is_TopDocument(true))
	{
		return "";
	}
	var sPosition = AscCommon.translateManager.getValue("above");
	oRun.Make_ThisElementCurrent(false);
	var aFieldPos = oTopDoc.GetContentPosition();
	this.LogicDocument.TurnOff_InterfaceEvents();
	oBookmarksManager.SelectBookmark(sBookmarkName);
	this.LogicDocument.TurnOn_InterfaceEvents(false);
	var aBookmarkPos = oTopDoc.GetContentPosition(true, false);
	var nIdx, nEnd, oBookmarkPos, oFieldPos;
	for(nIdx = 0, nEnd = Math.min(aFieldPos.length, aBookmarkPos.length); nIdx < nEnd; ++nIdx)
	{
		oBookmarkPos = aBookmarkPos[nIdx];
		oFieldPos = aFieldPos[nIdx];
		if(oBookmarkPos && oFieldPos
		&& oBookmarkPos.Position !== oFieldPos.Position)
		{
			if(oBookmarkPos.Position < oFieldPos.Position)
			{
				sPosition = AscCommon.translateManager.getValue("above");
			}
			else
			{
				sPosition = AscCommon.translateManager.getValue("below");
			}
			break;
		}
	}
	return sPosition;
};
CComplexField.prototype.private_UpdateREF = function()
{
	this.private_InsertContent(this.private_GetREFContent());

};
CComplexField.prototype.private_CalculateREF = function()
{
	let logicDocument = this.LogicDocument;
	
	let state = logicDocument ? logicDocument.SaveDocumentState() : null;
	
	let oSelectedContent = this.private_GetREFContent();
	oSelectedContent.GetText(null);
	
	if (state)
		logicDocument.LoadDocumentState(state);
	
	return oSelectedContent.GetText(null);
};
CComplexField.prototype.private_GetMessageContent = function(sMessage, oTextPr)
{
	var oSelectedContent = new AscCommonWord.CSelectedContent();
	var oPara = new AscWord.Paragraph();
	var oRun  = new ParaRun(oPara, false);
	
	if (this.Instruction && this.Instruction.isMergeFormat() && this.SeparateChar)
		oRun.ApplyPr(this.SeparateChar.GetRun().GetDirectTextPr());
	
	if (oTextPr)
		oRun.ApplyPr(oTextPr);

	oRun.AddText(sMessage);
	oPara.AddToContent(0, oRun);
	oSelectedContent.Add(new AscCommonWord.CSelectedElement(oPara, false));
	return oSelectedContent;
};
CComplexField.prototype.private_GetErrorContent = function(sMessage)
{
	var oTextPr = new CTextPr();
	oTextPr.Set_FromObject({Bold: true});
	return this.private_GetMessageContent(sMessage, oTextPr);
};
CComplexField.prototype.private_GetBookmarkContent = function(sBookmarkName)
{
	var oBookmarksManager = this.LogicDocument.GetBookmarksManager();
	this.LogicDocument.TurnOff_InterfaceEvents();
	oBookmarksManager.SelectBookmark(sBookmarkName);
	this.LogicDocument.TurnOn_InterfaceEvents(false);
	var oSelectedContent = this.LogicDocument.GetSelectedContent(false);
	var aElements = oSelectedContent.Elements;
	var oElement;
	
	let isMergeFormat = this.Instruction.isMergeFormat();
	let textPr        = this.GetFieldValueTextPr();
	let paraTextPr    = new AscWord.ParaTextPr(textPr);
	
	for (var nIndex = 0; nIndex < aElements.length; ++nIndex)
	{
		oElement = aElements[nIndex];
		oElement.Element = oElement.Element.Copy(null, null, {
			SkipPageBreak         : true,
			SkipColumnBreak       : true,
			SkipAnchors           : true,
			SkipFootnoteReference : true,
			SkipComplexFields     : true,
			SkipComments          : true,
			SkipBookmarks         : true,
			SkipFldSimple         : true
		});
		
		if (isMergeFormat)
		{
			oElement.Element.SetApplyToAll(true);
			oElement.Element.AddToParagraph(paraTextPr);
			oElement.Element.SetApplyToAll(false);
		}
	}
	return oSelectedContent;
};
CComplexField.prototype.private_GetREFContent = function()
{
	var sValue = AscCommon.translateManager.getValue("Error! Reference source not found.");
	if(!this.Instruction || this.Instruction.Type !== AscWord.fieldtype_REF)
	{
		return this.private_GetErrorContent(sValue);
	}
	var oBookmarksManager = this.LogicDocument.GetBookmarksManager();
	var sBookmarkName = this.Instruction.GetBookmarkName();
	var oBookmark = oBookmarksManager.GetBookmarkByName(sBookmarkName);
	if(!oBookmark)
	{
		return this.private_GetErrorContent(sValue);
	}
	var oStartBookmark = oBookmark[0];
	var oSrcParagraph = oStartBookmark.Paragraph;
	var oRun       = this.BeginChar.GetRun();
	var oParagraph = oRun.GetParagraph();
	if(!oSrcParagraph || !oParagraph)
	{
		return this.private_GetErrorContent(sValue);
	}
	var oParent = oParagraph.GetParent();
	var oSrcParent = oSrcParagraph.GetParent();
	if(!oParent || !oSrcParent)
	{
		return this.private_GetErrorContent(sValue);
	}
	var sPosition = "";
	if(this.Instruction.IsPosition())
	{
		sPosition = this.private_GetREFPosValue();
	}
	if(this.Instruction.HaveNumberFlag())
	{
		if(!oSrcParagraph.IsNumberedNumbering())
		{
			return this.private_GetMessageContent("0", null);
		}
		var oNumPr     = oSrcParagraph.GetNumPr();
		var oNumbering = this.LogicDocument.GetNumbering();
		var oNumInfo   = oSrcParagraph.GetParent().CalculateNumberingValues(oSrcParagraph, oNumPr);
		var nLvl, oParaNumInfo;
		if(this.Instruction.IsNumber())
		{
			var oParaNumPr = oParagraph.GetNumPr();
			if(oParaNumPr && oParaNumPr.NumId === oNumPr.NumId)
			{
				oParaNumInfo = oParagraph.GetParent().CalculateNumberingValues(oParagraph, oParaNumPr);
				for(nLvl = 0; nLvl <= oNumPr.Lvl && nLvl <= oParaNumPr.Lvl; ++nLvl)
				{
					if(oParaNumInfo[nLvl] !== oNumInfo[nLvl])
					{
						break;
					}
				}
				sValue = "";
				for( ;nLvl <= oNumPr.Lvl; ++nLvl)
				{
					sValue += oNumbering.GetText(oNumPr.NumId, nLvl, oNumInfo, nLvl === oNumPr.Lvl);
				}
			}
			else
			{
				sValue = oNumbering.GetText(oNumPr.NumId, oNumPr.Lvl, oNumInfo, true);
			}
		}
		else if(this.Instruction.IsNumberFullContext())
		{
			sValue = "";
			var sDelimiter = this.Instruction.GetDelimiter();
			for(nLvl = 0; nLvl <= oNumPr.Lvl; ++nLvl)
			{
				sValue += oNumbering.GetText(oNumPr.NumId, nLvl, oNumInfo, nLvl === oNumPr.Lvl);
				if(nLvl !== oNumPr.Lvl && typeof sDelimiter === "string" && sDelimiter.length > 0)
				{
					sValue += sDelimiter;
				}
			}
		}
		else if(this.Instruction.IsNumberNoContext())
		{
			sValue = oNumbering.GetText(oNumPr.NumId, oNumPr.Lvl, oNumInfo, true);
		}
		if(sPosition.length > 0)
		{
			sValue += " ";
			sValue += sPosition;
		}
		return this.private_GetMessageContent(sValue, null);
	}
	else if(this.Instruction.IsPosition() && sPosition.length > 0)
	{
		return this.private_GetMessageContent(sPosition, null);
	}
	else // bookmark content
	{
		return this.private_GetBookmarkContent(sBookmarkName);
	}
	//TODO: Apply formatting from general switches
};
CComplexField.prototype.private_GetNOTEREFContent = function()
{
	var sValue = AscCommon.translateManager.getValue("Error! Bookmark not defined.");
	if(!this.Instruction || this.Instruction.Type !== AscWord.fieldtype_NOTEREF)
	{
		return this.private_GetErrorContent(sValue);
	}
	var oBookmarksManager = this.LogicDocument.GetBookmarksManager();
	var sBookmarkName = this.Instruction.GetBookmarkName();
	var oBookmark = oBookmarksManager.GetBookmarkByName(sBookmarkName);
	if(!oBookmark)
	{
		return this.private_GetErrorContent(sValue);
	}
	//check notes in bookmarked content
	this.LogicDocument.TurnOff_InterfaceEvents();
	oBookmarksManager.SelectBookmark(sBookmarkName);
	this.LogicDocument.TurnOn_InterfaceEvents(false);
	var oSelectionInfo = this.LogicDocument.GetSelectedElementsInfo({CheckAllSelection : true});
	var aFootEndNotes = oSelectionInfo.GetFootEndNoteRefs();
	if(aFootEndNotes.length === 0)
	{
		return this.private_GetErrorContent(sValue);
	}
	var oFootEndNote = aFootEndNotes[0];
	var oStartBookmark = oBookmark[0];
	var oSrcParagraph = oStartBookmark.Paragraph;
	var oRun       = this.BeginChar.GetRun();
	var oParagraph = oRun.GetParagraph();
	if(!oSrcParagraph || !oParagraph)
	{
		return this.private_GetErrorContent(sValue);
	}
	var oSelectedContent = new AscCommonWord.CSelectedContent();
	var oTextPr;
	var oPara = new AscWord.Paragraph();
	var oParent = oParagraph.GetParent();
	var oSrcParent = oSrcParagraph.GetParent();
	if(!oParent || !oSrcParent)
	{
		return this.private_GetErrorContent(sValue);
	}
	if(this.Instruction.IsPosition() && oParent.IsHdrFtr() === oSrcParent.IsHdrFtr())
	{
		sValue = this.private_GetREFPosValue();
		if(typeof sValue === "string" && sValue.length > 0)
		{
			oRun  = new ParaRun(oPara, false);
			oRun.AddText(sValue);
			oPara.AddToContent(0, oRun);
		}
	}
	else
	{
		oRun  = new ParaRun(oPara, false);
		if(this.Instruction.IsFormatting())
		{
			oTextPr = new CTextPr();
			oTextPr.Set_FromObject({VertAlign: AscCommon.vertalign_SuperScript});
			oRun.Apply_Pr(oTextPr);
		}
		oRun.AddText(oFootEndNote.private_GetString());
		oPara.AddToContent(0, oRun);
	}
	oSelectedContent.Add(new AscCommonWord.CSelectedElement(oPara, false));
	return oSelectedContent;
};
CComplexField.prototype.private_UpdateNOTEREF = function()
{
	this.private_InsertContent(this.private_GetNOTEREFContent());
};
CComplexField.prototype.private_CalculateNOTEREF = function()
{
	var oSelectedContent = this.private_GetNOTEREFContent();
	return oSelectedContent.GetText(null);
};
CComplexField.prototype.SelectFieldValue = function()
{
	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;
	
	if (!this.SeparateChar)
	{
		let endRun = this.EndChar.GetRun();
		endRun.Make_ThisElementCurrent(false);
		endRun.SetCursorPosition(endRun.GetElementPosition(this.EndChar));
		let endPos = oDocument.GetContentPosition(false);
		oDocument.SetSelectionByContentPositions(endPos, endPos);
	}
	else
	{
		oDocument.RemoveSelection();
		
		var oRun = this.SeparateChar.GetRun();
		oRun.Make_ThisElementCurrent(false);
		oRun.SetCursorPosition(oRun.GetElementPosition(this.SeparateChar) + 1);
		var oStartPos = oDocument.GetContentPosition(false);
		
		oRun = this.EndChar.GetRun();
		oRun.Make_ThisElementCurrent(false);
		oRun.SetCursorPosition(oRun.GetElementPosition(this.EndChar));
		var oEndPos = oDocument.GetContentPosition(false);
		
		oDocument.SetSelectionByContentPositions(oStartPos, oEndPos);
	}
};
CComplexField.prototype.SelectFieldCode = function()
{
	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;

	oDocument.RemoveSelection();

	var oRun = this.BeginChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.BeginChar) + 1);
	var oStartPos = oDocument.GetContentPosition(false);
	
	let endChar = this.SeparateChar ? this.SeparateChar : this.EndChar;
	oRun = endChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(endChar));
	var oEndPos = oDocument.GetContentPosition(false);

	oDocument.SetSelectionByContentPositions(oStartPos, oEndPos);
};
CComplexField.prototype.SelectField = function()
{
	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;

	oDocument.RemoveSelection();

	var oRun = this.BeginChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.BeginChar));
	var oStartPos = oDocument.GetContentPosition(false);

	oRun = this.EndChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.EndChar) + 1);
	var oEndPos = oDocument.GetContentPosition(false);

	oDocument.RemoveSelection();
	oDocument.SetSelectionByContentPositions(oStartPos, oEndPos);
};
CComplexField.prototype.GetFieldValueText = function()
{
	let logicDocument = this.LogicDocument;
	var oDocument = this.GetTopDocumentContent();
	if (!oDocument || !this.SeparateChar)
		return "";
	
	let state = logicDocument ? logicDocument.SaveDocumentState() : null;
	oDocument.RemoveSelection();

	var oRun = this.SeparateChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.SeparateChar) + 1);
	var oStartPos = oDocument.GetContentPosition(false);

	oRun = this.EndChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.EndChar));
	var oEndPos = oDocument.GetContentPosition(false);

	oDocument.SetSelectionByContentPositions(oStartPos, oEndPos);
	let result = oDocument.GetSelectedText();
	
	if (state)
		logicDocument.LoadDocumentState(state);
	
	return result;
};
CComplexField.prototype.GetFieldValueTextPr = function(isCompiled)
{
	let fieldChar = this.SeparateChar ? this.SeparateChar : this.EndChar;
	if (isCompiled)
	{
		let run       = fieldChar.GetRun();
		let runParent = run.GetParent();
		let runPos    = run.private_GetPosInParent(runParent);
		
		let inRunPos  = run.GetElementPosition(fieldChar);
		if (inRunPos >= run.GetElementsCount() - 1
			&& runParent
			&& runParent.GetElement
			&& runParent.GetElement(runPos + 1) instanceof AscWord.CRun)
		{
			return runParent.GetElement(runPos + 1).getCompiledPr();
		}
		
		return run.getCompiledPr();
	}
	else
	{
		// TODO: Temporary. We select the first visible element in InstrText area and return its direct TextPr
		let logicDocument = this.LogicDocument;
		if (!logicDocument)
			return new AscWord.CTextPr();
		
		let state = logicDocument.SaveDocumentState();
		
		let run = fieldChar.GetRun();
		run.Make_ThisElementCurrent(false);
		run.SetCursorPosition(run.GetElementPosition(fieldChar) + 1);
		
		logicDocument.MoveCursorRight(true, false);
		let textPr = logicDocument.GetDirectTextPr();
		logicDocument.LoadDocumentState(state);
		return textPr;
	}
};
CComplexField.prototype.GetTopDocumentContent = function()
{
	if (!this.BeginChar || !this.EndChar)
		return null;
	
	let topDocument = this.BeginChar.GetTopDocumentContent();
	if (topDocument !== this.EndChar.GetTopDocumentContent())
		return null;
	
	if (this.SeparateChar && topDocument !== this.SeparateChar.GetTopDocumentContent())
		return null;
	
	return topDocument;
};
CComplexField.prototype.IsUse = function()
{
	if (!this.BeginChar)
		return false;

	return this.BeginChar.IsUse();
};
CComplexField.prototype.GetStartDocumentPosition = function()
{
	if (!this.BeginChar)
		return null;

	var oDocument = this.LogicDocument;
	var oState    = oDocument.SaveDocumentState();

	var oRun = this.BeginChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.BeginChar));
	var oDocPos = oDocument.GetContentPosition(false);

	oDocument.LoadDocumentState(oState);

	return oDocPos;
};
CComplexField.prototype.GetEndDocumentPosition = function()
{
	if (!this.EndChar)
		return null;

	var oDocument = this.LogicDocument;
	var oState    = oDocument.SaveDocumentState();

	var oRun = this.EndChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.EndChar) + 1);
	var oDocPos = oDocument.GetContentPosition(false);

	oDocument.LoadDocumentState(oState);

	return oDocPos;
};
CComplexField.prototype.IsValid = function()
{
	return (this.IsUse()
		&& this.BeginChar && this.BeginChar.IsValid()
		&& this.EndChar && this.EndChar.IsValid());
};
CComplexField.prototype.HaveValuePart = function()
{
	return (this.SeparateChar && this.SeparateChar.IsValid());
};
CComplexField.prototype.GetInstruction = function()
{
	this.private_UpdateInstruction();
	return this.Instruction;
};
CComplexField.prototype.private_UpdateInstruction = function()
{
	if ((!this.Instruction || !this.Instruction.CheckInstructionLine(this.InstructionLine)))
	{
		var oParser = new CFieldInstructionParser();
		this.Instruction = oParser.GetInstructionClass(this.InstructionLine);
		this.Instruction.SetComplexField(this);
		this.Instruction.SetInstructionLine(this.InstructionLine);
	}
};
CComplexField.prototype.private_CheckNestedComplexFields = function()
{
	var nCount = this.InstructionCF.length;
	if (nCount > 0)
	{
		this.Instruction     = null;
		this.InstructionLine = this.InstructionLineSrc;

		for (var nIndex = 0; nIndex < nCount; ++nIndex)
		{
			var sValue = this.InstructionCF[nIndex].CalculateValue();
			this.InstructionLine = this.InstructionLine.replace("\\&", sValue);
		}
	}
};
CComplexField.prototype.IsHidden = function()
{
	var oInstruction = this.GetInstruction();
	if (!oInstruction)
		return false;
	
	if (this.SeparateChar && this.SeparateChar.IsHiddenValue())
		return true;
	
	if (!this.BeginChar || !this.SeparateChar)
		return false;
	
	return (AscWord.fieldtype_ASK === oInstruction.GetType());
};
CComplexField.prototype.RemoveFieldWrap = function()
{
	if (!this.IsValid())
		return;
	
	if (!this.HaveValuePart())
		return this.RemoveField();

	this.EndChar.RemoveThisFromDocument();

	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;

	var oRun = this.BeginChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.BeginChar));
	var oStartPos = oDocument.GetContentPosition(false);

	oRun = this.SeparateChar.GetRun();
	oRun.Make_ThisElementCurrent(false);
	oRun.SetCursorPosition(oRun.GetElementPosition(this.SeparateChar) + 1);
	var oEndPos = oDocument.GetContentPosition(false);

	oDocument.SetSelectionByContentPositions(oStartPos, oEndPos);
	oDocument.Remove();
};
CComplexField.prototype.MoveCursorOutsideElement = function(isBefore)
{
	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;

	oDocument.RemoveSelection();

	if (isBefore)
	{
		var oRun = this.BeginChar.GetRun();
		oRun.Make_ThisElementCurrent(false);
		oRun.SetCursorPosition(oRun.GetElementPosition(this.BeginChar));

		if (oRun.IsCursorAtBegin())
			oRun.MoveCursorOutsideElement(true);
	}
	else
	{
		var oRun = this.EndChar.GetRun();
		oRun.Make_ThisElementCurrent(false);
		oRun.SetCursorPosition(oRun.GetElementPosition(this.EndChar) + 1);

		if (oRun.IsCursorAtEnd())
			oRun.MoveCursorOutsideElement(false);
	}
};
CComplexField.prototype.RemoveField = function()
{
	if (!this.IsValid())
		return;

	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;

	this.SelectField();
	oDocument.Remove();
};
CComplexField.prototype.RemoveFieldChars = function()
{
	if (this.BeginChar)
		this.BeginChar.RemoveThisFromDocument();

	if (this.EndChar)
		this.EndChar.RemoveThisFromDocument();

	if (this.SeparateChar)
		this.SeparateChar.RemoveThisFromDocument();
	
	for (let i = this.InstructionItems.length - 1; i >= 0; --i)
	{
		this.InstructionItems[i].RemoveThisFromDocument();
	}
};
/**
 * Выставляем свойства для данного поля
 * @param oPr (зависит от типа данного поля)
 */
CComplexField.prototype.SetPr = function(oPr)
{
	if (!this.IsValid())
		return;

	var oInstruction = this.GetInstruction();
	if (!oInstruction)
		return;

	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;

	oInstruction.SetPr(oPr);
	var sNewInstruction = oInstruction.ToString();

	this.SelectFieldCode();
	oDocument.Remove();

	var oRun      = this.BeginChar.GetRun();
	var nInRunPos = oRun.GetElementPosition(this.BeginChar) + 1;
	
	this.InstructionItems = oRun.AddInstrText(sNewInstruction, nInRunPos);
};
/**
 * Изменяем строку инструкции у поля
 * @param {string} sNewInstruction
 */
CComplexField.prototype.ChangeInstruction = function(sNewInstruction)
{
	if (!this.IsValid())
		return;

	var oDocument = this.GetTopDocumentContent();
	if (!oDocument)
		return;

	this.SelectFieldCode();
	oDocument.Remove();

	var oRun      = this.BeginChar.GetRun();
	var nInRunPos = oRun.GetElementPosition(this.BeginChar) + 1;
	let items     = oRun.AddInstrText(sNewInstruction, nInRunPos);

	this.Instruction        = null;
	this.InstructionLine    = sNewInstruction;
	this.InstructionLineSrc = sNewInstruction;
	this.InstructionCF      = [];
	this.InstructionItems   = items;
	this.private_UpdateInstruction();
};
CComplexField.prototype.CheckType = function(type)
{
	if (!this.IsValid())
		return false;
	
	let instruction = this.GetInstruction();
	if (!instruction)
		return false;
	
	// TODO: По-хорошему надо сделать мап типов, которые могут идти без разделителя, и какие не могут
	return instruction.GetType() === type;
};
CComplexField.prototype.IsAddin = function()
{
	return this.CheckType(AscWord.fieldtype_ADDIN);
};
CComplexField.prototype.IsFormField = function()
{
	if (!this.IsValid())
		return false;
	
	let instruction = this.GetInstruction();
	if (!instruction)
		return false;
	
	let type = instruction.GetType();
	return (AscWord.fieldtype_FORMCHECKBOX === type
		|| AscWord.fieldtype_FORMTEXT === type
		|| AscWord.fieldtype_FORMDROPDOWN === type);
};
CComplexField.prototype.IsFormFieldEnabled = function()
{
	if (!this.IsFormField())
		return false;
	
	let ffData = this.BeginChar.GetFFData();
	return (!ffData || ffData.isEnabled());
};
CComplexField.prototype.IsFormCheckBox = function()
{
	if (!this.CheckType(AscWord.fieldtype_FORMCHECKBOX))
		return false;
	
	let beginChar = this.GetBeginChar();
	let ffData    = beginChar ? beginChar.GetFFData() : null;
	return ffData && ffData.isCheckBox();
};
CComplexField.prototype.ToggleFormCheckBox = function()
{
	if (!this.IsFormCheckBox())
		return;
	
	let beginChar = this.GetBeginChar();
	let run     = beginChar.GetRun();
	if (!run)
		return;
	
	let inRunPos= run.GetElementPosition(beginChar);
	if (-1 === inRunPos)
		return;
	
	let newChar = beginChar.Copy();
	let ffData  = newChar.GetFFData();
	if (!ffData)
	{
		ffData = new AscWord.FFData();
		newChar.ffData = ffData;
	}
	
	if (!ffData.checkBox)
		ffData.initCheckBox();
	
	ffData.checkBox.checked = !ffData.isCheckBoxChecked();
	
	run.RemoveFromContent(inRunPos, 1);
	run.AddToContent(inRunPos, newChar);
	
	this.ReplaceChar(newChar);
};
/**
 * Получаем список связанных параграфов с данным полем (параграфы содержащие метки поля, это не обязательно будут
 * все параграфы между метками начала и конца)
 * @ returns {Array[AscWord.Paragraph]}
 */
CComplexField.prototype.GetRelatedParagraphs = function()
{
	if (!this.IsValid())
		return [];
	
	let begPara = this.BeginChar.GetParagraph();
	if (!begPara)
		return [];
	
	let result = [begPara];
	if (this.SeparateChar)
	{
		let sepPara = this.SeparateChar.GetParagraph();
		if (sepPara !== begPara)
			result.push(sepPara);
	}
	
	let endPara = this.EndChar.GetParagraph();
	if (-1 === result.indexOf(endPara))
		result.push(endPara);
	
	return result;
};
CComplexField.prototype.IsShowFieldCode = function()
{
	if (!this.IsValid())
		return false;
	
	return this.BeginChar.IsShowFieldCode();
};
CComplexField.prototype.ToggleFieldCodes = function()
{
	let isShowFieldCode = !this.BeginChar.IsShowFieldCode();
	
	this.BeginChar.SetShowFieldCode(isShowFieldCode);
	
	let logicDocument = this.LogicDocument;
	if (!logicDocument)
		return;
	
	let history    = logicDocument.GetHistory();
	let recalcData = history.getRecalcDataByElements([this.BeginChar.GetParagraph()]);
	logicDocument.RecalculateWithParams(recalcData);
	
	if (isShowFieldCode)
	{
		this.BeginChar.MoveCursorToChar(false);
	}
	else
	{
		if (this.SeparateChar)
			this.SeparateChar.MoveCursorToChar(false);
		else
			this.EndChar.MoveCursorToChar(true);
	}
};

function getRefInstruction(sBookmarkName, nType, bHyperlink, bAboveBelow, sSeparator)
{
	if (!(typeof sBookmarkName === "string" && sBookmarkName.length > 0))
	{
		return;
	}
	var sInstr  = "";
	var sSuffix = "";
	if (bHyperlink)
	{
		sSuffix += " \\h";
	}
	if (bAboveBelow && nType !== Asc.c_oAscDocumentRefenceToType.AboveBelow)
	{
		sSuffix += " \\p";
	}
	if (typeof sSeparator === "string" && sSeparator.length > 0)
	{
		sSuffix += " \\d " + sSeparator;
	}
	
	switch (nType)
	{
		case Asc.c_oAscDocumentRefenceToType.PageNum:
		{
			sInstr = " PAGEREF " + sBookmarkName;
			sInstr += sSuffix;
			break;
		}
		case Asc.c_oAscDocumentRefenceToType.Text:
		case Asc.c_oAscDocumentRefenceToType.OnlyCaptionText:
		case Asc.c_oAscDocumentRefenceToType.OnlyLabelAndNumber:
		{
			sInstr = " REF " + sBookmarkName + " ";
			sInstr += sSuffix;
			break;
		}
		case Asc.c_oAscDocumentRefenceToType.ParaNum:
		{
			sInstr = " REF " + sBookmarkName + " \\r ";
			sInstr += sSuffix;
			break;
		}
		case Asc.c_oAscDocumentRefenceToType.ParaNumNoContext:
		{
			sInstr = " REF " + sBookmarkName + " \\n ";
			sInstr += sSuffix;
			break;
		}
		case Asc.c_oAscDocumentRefenceToType.ParaNumFullContex:
		{
			sInstr = " REF " + sBookmarkName + " \\w ";
			sInstr += sSuffix;
			break;
		}
		case Asc.c_oAscDocumentRefenceToType.AboveBelow:
		{
			sInstr = " REF " + sBookmarkName + " \\p ";
			sInstr += sSuffix;
			break;
		}
	}
	
	return sInstr;
}

//--------------------------------------------------------export----------------------------------------------------
window['AscCommonWord'] = window['AscCommonWord'] || {};
window['AscCommonWord'].CComplexField = CComplexField;

window['AscWord'] = window['AscWord'] || {};
window['AscWord'].getRefInstruction = getRefInstruction;
window['AscWord'].CComplexField = CComplexField;
window['AscWord'].ComplexField = CComplexField;