Yajbir Singh
823 lines
25 KiB
JavaScript
823 lines
25 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2024
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
// Import
|
|
var History = AscCommon.History;
|
|
|
|
/**
|
|
*
|
|
* @param FieldType
|
|
* @param Arguments
|
|
* @param Switches
|
|
* @constructor
|
|
* @extends {CParagraphContentWithParagraphLikeContent}
|
|
*/
|
|
function ParaField(FieldType, Arguments, Switches)
|
|
{
|
|
CParagraphContentWithParagraphLikeContent.call(this);
|
|
|
|
this.Id = AscCommon.g_oIdCounter.Get_NewId();
|
|
|
|
this.Type = para_Field;
|
|
|
|
this.Istruction = null;
|
|
this.FieldType = (undefined === FieldType ? AscWord.fieldtype_UNKNOWN : FieldType);
|
|
this.Arguments = (undefined === Arguments ? [] : Arguments);
|
|
this.Switches = (undefined === Switches ? [] : Switches);
|
|
|
|
this.TemplateContent = this.Content;
|
|
|
|
this.Bounds = {};
|
|
|
|
this.FormFieldName = "";
|
|
this.FormFieldDefaultText = "";
|
|
|
|
// Добавляем данный класс в таблицу Id (обязательно в конце конструктора)
|
|
AscCommon.g_oTableId.Add( this, this.Id );
|
|
}
|
|
|
|
ParaField.prototype = Object.create(CParagraphContentWithParagraphLikeContent.prototype);
|
|
ParaField.prototype.constructor = ParaField;
|
|
|
|
ParaField.prototype.Get_Id = function()
|
|
{
|
|
return this.Id;
|
|
};
|
|
ParaField.prototype.Copy = function(Selected, oPr)
|
|
{
|
|
let newField = CParagraphContentWithParagraphLikeContent.prototype.Copy.apply(this, arguments);
|
|
|
|
if (oPr && oPr.SkipFldSimple)
|
|
{
|
|
let newItems = this.Content.slice();
|
|
this.RemoveAll();
|
|
return newItems;
|
|
}
|
|
else
|
|
{
|
|
// TODO: Сделать функциями с иторией
|
|
newField.FieldType = this.FieldType;
|
|
newField.Arguments = this.Arguments;
|
|
newField.Switches = this.Switches;
|
|
|
|
if (editor)
|
|
editor.WordControl.m_oLogicDocument.Register_Field(newField);
|
|
|
|
return newField;
|
|
}
|
|
};
|
|
ParaField.prototype.GetSelectedElementsInfo = function(Info, ContentPos, Depth)
|
|
{
|
|
Info.SetField(this);
|
|
CParagraphContentWithParagraphLikeContent.prototype.GetSelectedElementsInfo.apply(this, arguments);
|
|
};
|
|
ParaField.prototype.Get_Bounds = function()
|
|
{
|
|
var oParagraph = this.GetParagraph();
|
|
if (!oParagraph)
|
|
return [];
|
|
|
|
var arrBounds = [];
|
|
for (var Place in this.Bounds)
|
|
{
|
|
this.Bounds[Place].PageIndex = oParagraph.GetAbsolutePage(this.Bounds[Place].PageInternal);
|
|
arrBounds.push(this.Bounds[Place]);
|
|
}
|
|
|
|
return arrBounds;
|
|
};
|
|
ParaField.prototype.Add_ToContent = function(Pos, Item, UpdatePosition)
|
|
{
|
|
History.Add(new CChangesParaFieldAddItem(this, Pos, [Item]));
|
|
CParagraphContentWithParagraphLikeContent.prototype.Add_ToContent.apply(this, arguments);
|
|
};
|
|
ParaField.prototype.Remove_FromContent = function(Pos, Count, UpdatePosition)
|
|
{
|
|
if (Count <= 0)
|
|
return;
|
|
|
|
// Получим массив удаляемых элементов
|
|
var DeletedItems = this.Content.slice(Pos, Pos + Count);
|
|
History.Add(new CChangesParaFieldRemoveItem(this, Pos, DeletedItems));
|
|
|
|
CParagraphContentWithParagraphLikeContent.prototype.Remove_FromContent.apply(this, arguments);
|
|
};
|
|
ParaField.prototype.Add = function(Item)
|
|
{
|
|
if (para_Field === Item.Type)
|
|
{
|
|
// Вместо добавления самого элемента добавляем его содержимое
|
|
var Count = Item.Content.length;
|
|
|
|
if (Count > 0)
|
|
{
|
|
var CurPos = this.State.ContentPos;
|
|
var CurItem = this.Content[CurPos];
|
|
|
|
var CurContentPos = new AscWord.CParagraphContentPos();
|
|
CurItem.Get_ParaContentPos(false, false, CurContentPos);
|
|
|
|
var NewItem = CurItem.Split(CurContentPos, 0);
|
|
for (var Index = 0; Index < Count; Index++)
|
|
{
|
|
this.Add_ToContent(CurPos + Index + 1, Item.Content[Index], false);
|
|
}
|
|
this.Add_ToContent(CurPos + Count + 1, NewItem, false);
|
|
this.State.ContentPos = CurPos + Count;
|
|
this.Content[this.State.ContentPos].MoveCursorToEndPos();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CParagraphContentWithParagraphLikeContent.prototype.Add.apply(this, arguments);
|
|
}
|
|
};
|
|
ParaField.prototype.Split = function (ContentPos, Depth)
|
|
{
|
|
// Не даем разделять поле
|
|
return null;
|
|
};
|
|
ParaField.prototype.CanSplit = function()
|
|
{
|
|
return false;
|
|
};
|
|
ParaField.prototype.Recalculate_Range_Spaces = function(PRSA, _CurLine, _CurRange, _CurPage)
|
|
{
|
|
var CurLine = _CurLine - this.StartLine;
|
|
var CurRange = (0 === _CurLine ? _CurRange - this.StartRange : _CurRange);
|
|
|
|
if (0 === CurLine && 0 === CurRange && true !== PRSA.RecalcFast)
|
|
this.Bounds = {};
|
|
|
|
var X0 = PRSA.X;
|
|
var Y0 = PRSA.Y0;
|
|
var Y1 = PRSA.Y1;
|
|
|
|
CParagraphContentWithParagraphLikeContent.prototype.Recalculate_Range_Spaces.apply(this, arguments);
|
|
|
|
var X1 = PRSA.X;
|
|
|
|
this.Bounds[((CurLine << 16) & 0xFFFF0000) | (CurRange & 0x0000FFFF)] = {
|
|
X0 : X0,
|
|
X1 : X1,
|
|
Y0 : Y0,
|
|
Y1 : Y1,
|
|
PageIndex : PRSA.Paragraph.GetAbsolutePage(_CurPage),
|
|
PageInternal : _CurPage
|
|
};
|
|
};
|
|
ParaField.prototype.Draw_HighLights = function(PDSH)
|
|
{
|
|
var X0 = PDSH.X;
|
|
var Y0 = PDSH.Y0;
|
|
var Y1 = PDSH.Y1;
|
|
|
|
CParagraphContentWithParagraphLikeContent.prototype.Draw_HighLights.apply(this, arguments);
|
|
|
|
var X1 = PDSH.X;
|
|
|
|
if (Math.abs(X0 - X1) > 0.001 && (true === PDSH.DrawMMFields || AscWord.fieldtype_FORMTEXT === this.Get_FieldType()))
|
|
{
|
|
PDSH.MMFields.Add(Y0, Y1, X0, X1, 0, 0, 0, 0 );
|
|
}
|
|
};
|
|
ParaField.prototype.Get_LeftPos = function(SearchPos, ContentPos, Depth, UseContentPos)
|
|
{
|
|
if (false === UseContentPos && this.Content.length > 0)
|
|
{
|
|
// При переходе в новый контент встаем в его конец
|
|
var CurPos = this.Content.length - 1;
|
|
this.Content[CurPos].Get_EndPos(false, SearchPos.Pos, Depth + 1);
|
|
SearchPos.Pos.Update(CurPos, Depth);
|
|
SearchPos.Found = true;
|
|
return true;
|
|
}
|
|
|
|
CParagraphContentWithParagraphLikeContent.prototype.Get_LeftPos.call(this, SearchPos, ContentPos, Depth, UseContentPos);
|
|
};
|
|
ParaField.prototype.Get_RightPos = function(SearchPos, ContentPos, Depth, UseContentPos, StepEnd)
|
|
{
|
|
if (false === UseContentPos && this.Content.length > 0)
|
|
{
|
|
// При переходе в новый контент встаем в его начало
|
|
this.Content[0].Get_StartPos(SearchPos.Pos, Depth + 1);
|
|
SearchPos.Pos.Update(0, Depth);
|
|
SearchPos.Found = true;
|
|
return true;
|
|
}
|
|
|
|
CParagraphContentWithParagraphLikeContent.prototype.Get_RightPos.call(this, SearchPos, ContentPos, Depth, UseContentPos, StepEnd);
|
|
};
|
|
ParaField.prototype.Remove = function(nDirection, bOnAddText)
|
|
{
|
|
CParagraphContentWithParagraphLikeContent.prototype.Remove.call(this, nDirection, bOnAddText);
|
|
|
|
if (this.Is_Empty() && !bOnAddText && AscWord.fieldtype_FORMTEXT === this.Get_FieldType() && this.Paragraph && this.Paragraph.LogicDocument && true === this.Paragraph.LogicDocument.IsFillingFormMode())
|
|
{
|
|
var sDefaultText = this.FormFieldDefaultText == "" ? " " : this.FormFieldDefaultText;
|
|
this.SetValue(sDefaultText);
|
|
}
|
|
};
|
|
ParaField.prototype.Shift_Range = function(Dx, Dy, _CurLine, _CurRange, _CurPage)
|
|
{
|
|
CParagraphContentWithParagraphLikeContent.prototype.Shift_Range.call(this, Dx, Dy, _CurLine, _CurRange, _CurPage);
|
|
|
|
var CurLine = _CurLine - this.StartLine;
|
|
var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );
|
|
|
|
var oRangeBounds = this.Bounds[((CurLine << 16) & 0xFFFF0000) | (CurRange & 0x0000FFFF)];
|
|
if (oRangeBounds)
|
|
{
|
|
oRangeBounds.X0 += Dx;
|
|
oRangeBounds.X1 += Dx;
|
|
oRangeBounds.Y0 += Dy;
|
|
oRangeBounds.Y1 += Dy;
|
|
}
|
|
};
|
|
ParaField.prototype.Get_LeftPos = function(SearchPos, ContentPos, Depth, UseContentPos)
|
|
{
|
|
var bResult = CParagraphContentWithParagraphLikeContent.prototype.Get_LeftPos.call(this, SearchPos, ContentPos, Depth, UseContentPos);
|
|
|
|
if (true !== bResult && this.Paragraph && this.Paragraph.LogicDocument && true === this.Paragraph.LogicDocument.IsFillingFormMode())
|
|
{
|
|
this.Get_StartPos(SearchPos.Pos, Depth);
|
|
SearchPos.Found = true;
|
|
return true;
|
|
}
|
|
|
|
return bResult;
|
|
};
|
|
ParaField.prototype.Get_RightPos = function(SearchPos, ContentPos, Depth, UseContentPos, StepEnd)
|
|
{
|
|
var bResult = CParagraphContentWithParagraphLikeContent.prototype.Get_RightPos.call(this, SearchPos, ContentPos, Depth, UseContentPos, StepEnd);
|
|
|
|
if (true !== bResult && this.Paragraph && this.Paragraph.LogicDocument && true === this.Paragraph.LogicDocument.IsFillingFormMode())
|
|
{
|
|
this.Get_EndPos(false, SearchPos.Pos, Depth);
|
|
SearchPos.Found = true;
|
|
return true;
|
|
}
|
|
|
|
return bResult;
|
|
};
|
|
ParaField.prototype.Get_WordStartPos = function(SearchPos, ContentPos, Depth, UseContentPos)
|
|
{
|
|
CParagraphContentWithParagraphLikeContent.prototype.Get_WordStartPos.call(this, SearchPos, ContentPos, Depth, UseContentPos);
|
|
|
|
if (true !== SearchPos.Found && this.Paragraph && this.Paragraph.LogicDocument && true === this.Paragraph.LogicDocument.IsFillingFormMode())
|
|
{
|
|
this.Get_StartPos(SearchPos.Pos, Depth);
|
|
SearchPos.UpdatePos = true;
|
|
SearchPos.Found = true;
|
|
}
|
|
};
|
|
ParaField.prototype.Get_WordEndPos = function(SearchPos, ContentPos, Depth, UseContentPos, StepEnd)
|
|
{
|
|
CParagraphContentWithParagraphLikeContent.prototype.Get_WordEndPos.call(this, SearchPos, ContentPos, Depth, UseContentPos, StepEnd);
|
|
|
|
if (true !== SearchPos.Found && this.Paragraph && this.Paragraph.LogicDocument && true === this.Paragraph.LogicDocument.IsFillingFormMode())
|
|
{
|
|
this.Get_EndPos(false, SearchPos.Pos, Depth);
|
|
SearchPos.UpdatePos = true;
|
|
SearchPos.Found = true;
|
|
}
|
|
};
|
|
ParaField.prototype.SetCurrent = function(isCurrent)
|
|
{
|
|
};
|
|
ParaField.prototype.IsCurrent = function()
|
|
{
|
|
return false;
|
|
};
|
|
ParaField.prototype.SelectField = function()
|
|
{
|
|
this.SelectThisElement();
|
|
};
|
|
ParaField.prototype.GetAllFields = function(isUseSelection, arrFields)
|
|
{
|
|
arrFields.push(this);
|
|
return CParagraphContentWithParagraphLikeContent.prototype.GetAllFields.apply(this, arguments);
|
|
};
|
|
ParaField.prototype.GetAllSeqFieldsByType = function(sType, aFields)
|
|
{
|
|
if (this.FieldType === AscWord.fieldtype_SEQ
|
|
&& this.Arguments.length
|
|
&& this.Arguments[0].toLowerCase
|
|
&& sType.toLowerCase
|
|
&& this.Arguments[0].toLowerCase() === sType.toLowerCase())
|
|
{
|
|
aFields.push(this);
|
|
}
|
|
};
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// Работа с данными поля
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
ParaField.prototype.Get_Argument = function(Index)
|
|
{
|
|
return this.Arguments[Index];
|
|
};
|
|
ParaField.prototype.Get_FieldType = function()
|
|
{
|
|
return this.FieldType;
|
|
};
|
|
ParaField.prototype.GetFieldType = function()
|
|
{
|
|
return this.FieldType;
|
|
};
|
|
ParaField.prototype.Map_MailMerge = function(_Value)
|
|
{
|
|
// Пока у нас в Value может быть только текст, в будущем планируется, чтобы могли быть картинки.
|
|
var Value = _Value;
|
|
if (undefined === Value || null === Value)
|
|
Value = "";
|
|
|
|
History.TurnOff();
|
|
|
|
var oRun = this.private_GetMappedRun(Value);
|
|
|
|
// Подменяем содержимое поля
|
|
this.Content = [];
|
|
this.Content[0] = oRun;
|
|
|
|
this.MoveCursorToStartPos();
|
|
|
|
History.TurnOn();
|
|
};
|
|
ParaField.prototype.Restore_StandardTemplate = function()
|
|
{
|
|
// В любом случае сначала восстанавливаем исходное содержимое.
|
|
this.Restore_Template();
|
|
|
|
if (AscWord.fieldtype_MERGEFIELD === this.FieldType && true === AscCommon.CollaborativeEditing.Is_SingleUser() && 1 === this.Arguments.length)
|
|
{
|
|
var oRun = this.private_GetMappedRun("«" + this.Arguments[0] + "»");
|
|
this.Remove_FromContent(0, this.Content.length);
|
|
this.Add_ToContent(0, oRun);
|
|
this.MoveCursorToStartPos();
|
|
|
|
this.TemplateContent = this.Content;
|
|
}
|
|
};
|
|
ParaField.prototype.Restore_Template = function()
|
|
{
|
|
// Восстанавливаем содержимое поля.
|
|
this.Content = this.TemplateContent;
|
|
this.MoveCursorToStartPos();
|
|
};
|
|
ParaField.prototype.Is_NeedRestoreTemplate = function()
|
|
{
|
|
if (1 !== this.TemplateContent.length)
|
|
return true;
|
|
|
|
var oRun = this.TemplateContent[0];
|
|
if (AscWord.fieldtype_MERGEFIELD === this.FieldType)
|
|
{
|
|
var sStandardText = "«" + this.Arguments[0] + "»";
|
|
|
|
var oRunText = new CParagraphGetText();
|
|
oRun.Get_Text(oRunText);
|
|
|
|
if (sStandardText === oRunText.Text)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
ParaField.prototype.Replace_MailMerge = function(_Value)
|
|
{
|
|
// Пока у нас в Value может быть только текст, в будущем планируется, чтобы могли быть картинки.
|
|
var Value = _Value;
|
|
if (undefined === Value || null === Value)
|
|
Value = "";
|
|
|
|
var Paragraph = this.Paragraph;
|
|
|
|
if (!Paragraph)
|
|
return false;
|
|
|
|
// Получим ран, на который мы подменяем поле
|
|
var oRun = this.private_GetMappedRun(Value);
|
|
|
|
// Ищем расположение данного поля в параграфе
|
|
var ParaContentPos = Paragraph.Get_PosByElement(this);
|
|
|
|
if (null === ParaContentPos)
|
|
return false;
|
|
|
|
var Depth = ParaContentPos.GetDepth();
|
|
var FieldPos = ParaContentPos.Get(Depth);
|
|
|
|
if (Depth < 0)
|
|
return false;
|
|
|
|
ParaContentPos.DecreaseDepth(1);
|
|
var FieldContainer = Paragraph.Get_ElementByPos(ParaContentPos);
|
|
if (!FieldContainer || !FieldContainer.Content || FieldContainer.Content[FieldPos] !== this)
|
|
return false;
|
|
|
|
FieldContainer.Remove_FromContent(FieldPos, 1);
|
|
FieldContainer.Add_ToContent(FieldPos, oRun);
|
|
|
|
return true;
|
|
};
|
|
ParaField.prototype.private_GetMappedRun = function(sValue)
|
|
{
|
|
return this.CreateRunWithText(sValue);
|
|
};
|
|
ParaField.prototype.SetFormFieldName = function(sName)
|
|
{
|
|
History.Add(new CChangesParaFieldFormFieldName(this, this.FormFieldName, sName));
|
|
this.FormFieldName = sName;
|
|
};
|
|
ParaField.prototype.GetFormFieldName = function()
|
|
{
|
|
return this.FormFieldName;
|
|
};
|
|
ParaField.prototype.SetFormFieldDefaultText = function(sText)
|
|
{
|
|
History.Add(new CChangesParaFieldFormFieldDefaultText(this, this.FormFieldDefaultText, sText));
|
|
this.FormFieldDefaultText = sText;
|
|
};
|
|
ParaField.prototype.GetValue = function()
|
|
{
|
|
var oText = new CParagraphGetText();
|
|
oText.SetBreakOnNonText(false);
|
|
|
|
this.Get_Text(oText);
|
|
|
|
return oText.Text;
|
|
};
|
|
ParaField.prototype.SetValue = function(sValue)
|
|
{
|
|
this.ReplaceAllWithText(sValue);
|
|
};
|
|
ParaField.prototype.IsFillingForm = function()
|
|
{
|
|
if (AscWord.fieldtype_FORMTEXT === this.Get_FieldType())
|
|
return true;
|
|
|
|
return false;
|
|
};
|
|
ParaField.prototype.FindNextFillingForm = function(isNext, isCurrent, isStart)
|
|
{
|
|
var oParagraph = this.GetParagraph();
|
|
if (!oParagraph)
|
|
return null;
|
|
|
|
var oLogicDocument = oParagraph.GetLogicDocument();
|
|
if (!oLogicDocument)
|
|
return null;
|
|
|
|
if (!this.IsFillingForm() || oLogicDocument.IsFillingOFormMode())
|
|
return CParagraphContentWithParagraphLikeContent.prototype.FindNextFillingForm.apply(this, arguments);
|
|
|
|
if (isCurrent && true === this.IsSelectedAll())
|
|
{
|
|
if (isNext)
|
|
return CParagraphContentWithParagraphLikeContent.prototype.FindNextFillingForm.apply(this, arguments);
|
|
|
|
return null;
|
|
}
|
|
|
|
if (!isCurrent && isNext)
|
|
return this;
|
|
|
|
var oRes = CParagraphContentWithParagraphLikeContent.prototype.FindNextFillingForm.apply(this, arguments);
|
|
if (!oRes && !isNext)
|
|
return this;
|
|
|
|
return null;
|
|
};
|
|
ParaField.prototype.Update = function(isCreateHistoryPoint, isRecalculate)
|
|
{
|
|
if (!this.Paragraph && !this.Paragraph.Parent)
|
|
return;
|
|
|
|
var sReplaceString = null;
|
|
if (this.FieldType === AscWord.fieldtype_SEQ)
|
|
{
|
|
var oInstruction = new CFieldInstructionSEQ();
|
|
oInstruction.ComplexField = this;
|
|
oInstruction.ParentContent = this.Paragraph.Parent;
|
|
oInstruction.Id = this.Arguments[0];
|
|
sReplaceString = oInstruction.GetText();
|
|
}
|
|
else if (this.FieldType === AscWord.fieldtype_STYLEREF)
|
|
{
|
|
var oInstruction = new CFieldInstructionSTYLEREF();
|
|
oInstruction.ComplexField = this;
|
|
oInstruction.ParentContent = this.Paragraph.Parent;
|
|
oInstruction.ParentParagraph = this.Paragraph;
|
|
oInstruction.StyleName = this.Arguments[0];
|
|
sReplaceString = oInstruction.GetText();
|
|
}
|
|
|
|
if (sReplaceString)
|
|
{
|
|
var oRun = this.private_GetMappedRun(sReplaceString);
|
|
this.Remove_FromContent(0, this.Content.length);
|
|
this.Add_ToContent(0, oRun);
|
|
}
|
|
};
|
|
ParaField.prototype.GetInstructionLine = function()
|
|
{
|
|
let Instr = "";
|
|
let name;
|
|
switch (this.FieldType)
|
|
{
|
|
case AscWord.fieldtype_MERGEFIELD :
|
|
{
|
|
name = "MERGEFIELD";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_PAGE :
|
|
{
|
|
name = "PAGE";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_NUMPAGES :
|
|
{
|
|
name = "NUMPAGES";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_FORMTEXT :
|
|
{
|
|
name = "FORMTEXT";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_TOC :
|
|
{
|
|
name = "TOC";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_PAGEREF :
|
|
{
|
|
name = "PAGEREF";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_ASK :
|
|
{
|
|
name = "ASK";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_REF :
|
|
{
|
|
name = "REF";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_HYPERLINK :
|
|
{
|
|
name = "HYPERLINK";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_TIME :
|
|
{
|
|
name = "TIME";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_DATE :
|
|
{
|
|
name = "DATE";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_FORMULA :
|
|
{
|
|
name = "FORMULA";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_SEQ :
|
|
{
|
|
name = "SEQ";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_STYLEREF :
|
|
{
|
|
name = "STYLEREF";
|
|
break;
|
|
}
|
|
case AscWord.fieldtype_NOTEREF :
|
|
{
|
|
name = "NOTEREF";
|
|
break;
|
|
}
|
|
}
|
|
if (name)
|
|
{
|
|
Instr += name;
|
|
for (let i = 0; i < this.Arguments.length; ++i)
|
|
{
|
|
let argument = this.Arguments[i];
|
|
argument = argument.replace(/(\\|")/g, "\\$1");
|
|
if (-1 != argument.indexOf(' '))
|
|
{
|
|
argument = "\"" + argument + "\"";
|
|
}
|
|
Instr += " " + argument;
|
|
}
|
|
Instr += this.Switches.join(" ")
|
|
}
|
|
return Instr;
|
|
};
|
|
ParaField.prototype.GetInstruction = function()
|
|
{
|
|
let instructionLine = this.GetInstructionLine();
|
|
let parser = new CFieldInstructionParser();
|
|
let instruction = parser.GetInstructionClass(instructionLine);
|
|
instruction.SetInstructionLine(instructionLine);
|
|
return instruction;
|
|
};
|
|
ParaField.prototype.ReplaceWithComplexField = function()
|
|
{
|
|
let oParent = this.GetParent();
|
|
let nPosInParent = this.GetPosInParent(oParent);
|
|
let oParagraph = this.GetParagraph();
|
|
let oLogicDocument = oParagraph ? oParagraph.GetLogicDocument() : null;
|
|
if (!oLogicDocument || !oParent || -1 === nPosInParent)
|
|
return null;
|
|
|
|
let oBeginChar = new ParaFieldChar(fldchartype_Begin, oLogicDocument);
|
|
let oSeparateChar = new ParaFieldChar(fldchartype_Separate, oLogicDocument);
|
|
let oEndChar = new ParaFieldChar(fldchartype_End, oLogicDocument);
|
|
|
|
let sInstruction = this.GetInstructionLine();
|
|
|
|
let oRun = this.CreateRunWithText("");
|
|
oRun.AddToContent(-1, oBeginChar);
|
|
oRun.AddInstrText(sInstruction);
|
|
oRun.AddToContent(-1, oSeparateChar);
|
|
oRun.AddToContent(-1, oEndChar);
|
|
|
|
oParent.RemoveFromContent(nPosInParent, 1);
|
|
oParent.AddToContent(nPosInParent, oRun);
|
|
|
|
oBeginChar.SetRun(oRun);
|
|
oSeparateChar.SetRun(oRun);
|
|
oEndChar.SetRun(oRun);
|
|
|
|
var oComplexField = oBeginChar.GetComplexField();
|
|
oComplexField.SetBeginChar(oBeginChar);
|
|
oComplexField.SetInstructionLine(sInstruction);
|
|
oComplexField.SetSeparateChar(oSeparateChar);
|
|
oComplexField.SetEndChar(oEndChar);
|
|
oComplexField.Update(false);
|
|
return oComplexField;
|
|
};
|
|
ParaField.prototype.GetRunWithPageField = function(paragraph)
|
|
{
|
|
let res = null;
|
|
if (AscWord.fieldtype_PAGENUM == this.FieldType || AscWord.fieldtype_PAGECOUNT == this.FieldType) {
|
|
res = new ParaRun(paragraph);
|
|
let run = this.GetFirstRunNonEmpty();
|
|
let rPr = run && run.Get_FirstTextPr();
|
|
if (rPr) {
|
|
res.Set_Pr(rPr);
|
|
}
|
|
if (AscWord.fieldtype_PAGENUM == this.FieldType) {
|
|
res.AddToContentToEnd(new AscWord.CRunPageNum());
|
|
} else {
|
|
var pageCount = parseInt(this.GetSelectedText(true));
|
|
res.AddToContentToEnd(new AscWord.CRunPagesCount(isNaN(pageCount) ? undefined : pageCount));
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
ParaField.prototype.IsValid = function()
|
|
{
|
|
return true;
|
|
};
|
|
ParaField.prototype.CheckType = function(type)
|
|
{
|
|
return this.FieldType === type;
|
|
};
|
|
ParaField.prototype.IsAddin = function()
|
|
{
|
|
return this.CheckType(AscWord.fieldtype_ADDIN);
|
|
};
|
|
ParaField.prototype.IsFormCheckBox = function()
|
|
{
|
|
return this.CheckType(AscWord.fieldtype_FORMCHECKBOX);
|
|
};
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
// Функции совместного редактирования
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
ParaField.prototype.Write_ToBinary2 = function(Writer)
|
|
{
|
|
Writer.WriteLong(AscDFH.historyitem_type_Field);
|
|
|
|
// String : Id
|
|
// Long : FieldType
|
|
// Long : Количество аргументов
|
|
// Array of Strings : массив аргументов
|
|
// Long : Количество переключателей
|
|
// Array of Strings : массив переключателей
|
|
// Long : Количество элементов
|
|
// Array of Strings : массив с Id элементов
|
|
|
|
Writer.WriteString2(this.Id);
|
|
Writer.WriteLong(this.FieldType);
|
|
|
|
var ArgsCount = this.Arguments.length;
|
|
Writer.WriteLong(ArgsCount);
|
|
for (var Index = 0; Index < ArgsCount; Index++)
|
|
Writer.WriteString2(this.Arguments[Index]);
|
|
|
|
var SwitchesCount = this.Switches.length;
|
|
Writer.WriteLong(SwitchesCount);
|
|
for (var Index = 0; Index < SwitchesCount; Index++)
|
|
Writer.WriteString2(this.Switches[Index]);
|
|
|
|
var Count = this.Content.length;
|
|
Writer.WriteLong(Count);
|
|
for (var Index = 0; Index < Count; Index++)
|
|
Writer.WriteString2(this.Content[Index].Get_Id());
|
|
};
|
|
ParaField.prototype.Read_FromBinary2 = function(Reader)
|
|
{
|
|
// String : Id
|
|
// Long : FieldType
|
|
// Long : Количество аргументов
|
|
// Array of Strings : массив аргументов
|
|
// Long : Количество переключателей
|
|
// Array of Strings : массив переключателей
|
|
// Long : Количество элементов
|
|
// Array of Strings : массив с Id элементов
|
|
|
|
this.Id = Reader.GetString2();
|
|
this.FieldType = Reader.GetLong();
|
|
|
|
var Count = Reader.GetLong();
|
|
this.Arguments = [];
|
|
for (var Index = 0; Index < Count; Index++)
|
|
this.Arguments.push(Reader.GetString2());
|
|
|
|
Count = Reader.GetLong();
|
|
this.Switches = [];
|
|
for (var Index = 0; Index < Count; Index++)
|
|
this.Switches.push(Reader.GetString2());
|
|
|
|
Count = Reader.GetLong();
|
|
this.Content = [];
|
|
for (var Index = 0; Index < Count; Index++)
|
|
{
|
|
var Element = AscCommon.g_oTableId.Get_ById(Reader.GetString2());
|
|
if (null !== Element)
|
|
this.Content.push(Element);
|
|
}
|
|
|
|
this.TemplateContent = this.Content;
|
|
|
|
if (editor)
|
|
editor.WordControl.m_oLogicDocument.Register_Field(this);
|
|
};
|
|
//----------------------------------------------------------------------------------------------------------------------
|
|
ParaField.prototype.IsStopCursorOnEntryExit = function()
|
|
{
|
|
return true;
|
|
};
|
|
ParaField.prototype.CheckSpelling = function(oCollector, nDepth)
|
|
{
|
|
if (oCollector.IsExceedLimit())
|
|
return;
|
|
|
|
oCollector.FlushWord();
|
|
};
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
window['AscCommonWord'] = window['AscCommonWord'] || {};
|
|
window['AscCommonWord'].ParaField = ParaField;
|
|
|
|
window['AscWord'].CSimpleField = ParaField;
|
|
window['AscWord'].FldSimple = ParaField;
|