1586 lines
48 KiB
JavaScript
1586 lines
48 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";
|
||
|
||
var type_Unknown = 0x00;
|
||
|
||
/**
|
||
* Базовый класс для элементов содержимого документа (Paragraph, CTable, CBlockLevelSdt)
|
||
* @param oParent - ссылка на базовый класс
|
||
* @constructor
|
||
*/
|
||
function CDocumentContentElementBase(oParent)
|
||
{
|
||
this.Id = AscCommon.g_oIdCounter.Get_NewId();
|
||
|
||
this.Parent = oParent;
|
||
this.Prev = null;
|
||
this.Next = null;
|
||
this.Index = -1; // перед тем как пользоваться этим параметром нужно у родительского класса вызывать this.Parent.Update_ContentIndexing();
|
||
|
||
this.Recalculated = false; // Данный параметр управляет тем, были ли у нас произведены изменения с элементом с момента последнего пересчета
|
||
|
||
this.X = 0;
|
||
this.Y = 0;
|
||
this.XLimit = 0;
|
||
this.YLimit = 0;
|
||
this.PageNum = 0;
|
||
this.ColumnNum = 0;
|
||
this.ColumnsCount = 0;
|
||
this.SectionNum = 0;
|
||
this.Sections = [];
|
||
this.UseXLimit = true;
|
||
this.UseYLimit = true;
|
||
}
|
||
|
||
CDocumentContentElementBase.prototype.Get_Type = function()
|
||
{
|
||
return this.GetType();
|
||
};
|
||
CDocumentContentElementBase.prototype.GetType = function()
|
||
{
|
||
return type_Unknown;
|
||
};
|
||
/**
|
||
* Является ли данный элемент параграфом
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsParagraph = function()
|
||
{
|
||
return (this.GetType() === type_Paragraph);
|
||
};
|
||
/**
|
||
* Является ли данный элемент таблицей
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsTable = function()
|
||
{
|
||
return (this.GetType() === type_Table);
|
||
};
|
||
/**
|
||
* Является ли данный элемент блочным контейнером
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsBlockLevelSdt = function()
|
||
{
|
||
return (this.GetType() === type_BlockLevelSdt);
|
||
};
|
||
CDocumentContentElementBase.prototype.Is_Inline = function()
|
||
{
|
||
return true;
|
||
};
|
||
CDocumentContentElementBase.prototype.Set_DocumentIndex = function(nIndex)
|
||
{
|
||
this.Index = nIndex;
|
||
};
|
||
CDocumentContentElementBase.prototype.Set_DocumentNext = function(oElement)
|
||
{
|
||
this.Next = oElement;
|
||
};
|
||
CDocumentContentElementBase.prototype.Set_DocumentPrev = function(oElement)
|
||
{
|
||
this.Prev = oElement;
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_DocumentNext = function()
|
||
{
|
||
return this.Next;
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_DocumentPrev = function()
|
||
{
|
||
return this.Prev;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetNextDocumentElement = function()
|
||
{
|
||
var oNext = this.Get_DocumentNext();
|
||
if (!oNext && this.Parent && this.Parent.GetNextDocumentElement)
|
||
return this.Parent.GetNextDocumentElement();
|
||
|
||
return oNext;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetPrevDocumentElement = function()
|
||
{
|
||
var oPrev = this.Get_DocumentPrev();
|
||
if (!oPrev && this.Parent && this.Parent.GetPrevDocumentElement)
|
||
return this.Parent.GetPrevDocumentElement();
|
||
|
||
return oPrev;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetNextParagraphInDocument = function()
|
||
{
|
||
let next = this.GetNextDocumentElement();
|
||
return next ? next.GetFirstParagraph() : null;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetPrevParagraphInDocument = function()
|
||
{
|
||
let prev = this.GetPrevDocumentElement();
|
||
return prev ? prev.GetLastParagraph() : null;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetParent = function()
|
||
{
|
||
return this.Parent;
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParent = function(oParent)
|
||
{
|
||
this.Parent = oParent;
|
||
};
|
||
CDocumentContentElementBase.prototype.Set_Parent = function(oParent)
|
||
{
|
||
this.Parent = oParent;
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_Parent = function()
|
||
{
|
||
return this.Parent;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetId = function()
|
||
{
|
||
return this.Id;
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_Id = function()
|
||
{
|
||
return this.GetId();
|
||
};
|
||
CDocumentContentElementBase.prototype.Reset = function(X, Y, XLimit, YLimit, pageAbs, ColumnAbs, ColumnsCount, sectionAbs, sectPr)
|
||
{
|
||
this.X = X;
|
||
this.Y = Y;
|
||
this.XLimit = XLimit;
|
||
this.YLimit = YLimit;
|
||
this.PageNum = pageAbs;
|
||
this.ColumnNum = ColumnAbs ? ColumnAbs : 0;
|
||
this.ColumnsCount = ColumnsCount ? ColumnsCount : 1;
|
||
this.SectionNum = sectionAbs;
|
||
this.ResetSection(X, Y, XLimit, YLimit, pageAbs, sectionAbs, sectPr);
|
||
};
|
||
CDocumentContentElementBase.prototype.ResetSection = function(X, Y, XLimit, YLimit, pageAbs, sectionAbs, sectPr)
|
||
{
|
||
if (undefined === sectionAbs || undefined === sectPr)
|
||
{
|
||
sectPr = null;
|
||
sectionAbs = this.SectionNum;
|
||
}
|
||
|
||
if (sectionAbs < this.SectionNum)
|
||
{
|
||
// This should never happen
|
||
this.SectionNum = sectionAbs;
|
||
}
|
||
|
||
this.Sections.length = sectionAbs - this.SectionNum;
|
||
|
||
let startPage = this.Sections.length ? this.Sections[this.Sections.length - 1].endPage + 1 : 0;
|
||
let startColumn = this.Sections.length ? 0 : this.GetStartColumn();
|
||
let columnCount = sectPr ? sectPr.GetColumnCount() : (this.Sections.length ? 1 : this.GetColumnCount());
|
||
this.Sections.push(new AscWord.DocumentElementSection(X, Y, XLimit, YLimit, pageAbs, startPage, startPage, sectPr, startColumn, columnCount, this.Sections.length));
|
||
};
|
||
CDocumentContentElementBase.prototype.GetElementSectionByPage = function(curPage)
|
||
{
|
||
if (!this.Sections.length)
|
||
return null;
|
||
else if (1 === this.Sections.length)
|
||
return this.Sections[0];
|
||
|
||
for (let i = 0; i < this.Sections.length; ++i)
|
||
{
|
||
if (this.Sections[i].GetEndPage() >= curPage)
|
||
return this.Sections[i];
|
||
}
|
||
return this.Sections[this.Sections.length - 1];
|
||
};
|
||
CDocumentContentElementBase.prototype.GetElementSectionBySectionNumber = function(sectionNumber)
|
||
{
|
||
let sectNum = Math.max(0, Math.min(this.Sections.length - 1, sectionNumber - this.SectionNum));
|
||
return this.Sections[sectNum];
|
||
};
|
||
CDocumentContentElementBase.prototype.GetPageContentFrame = function(curPage)
|
||
{
|
||
let section = this.GetElementSectionByPage(curPage);
|
||
if (0 === curPage || !section)
|
||
{
|
||
return {
|
||
X : this.X,
|
||
Y : this.Y,
|
||
XLimit : this.XLimit,
|
||
YLimit : this.YLimit
|
||
}
|
||
}
|
||
else if (curPage === section.GetStartPage())
|
||
{
|
||
return section.GetContentFrame();
|
||
}
|
||
|
||
let columnCount = section.GetColumnCount();
|
||
let startColumn = section === this.Sections[0] ? this.ColumnNum : 0;
|
||
|
||
curPage -= section.GetStartPage();
|
||
|
||
let column = (startColumn + curPage) - ((startColumn + curPage) / columnCount | 0) * columnCount;
|
||
let page = section.GetParentStartPage() + ((startColumn + curPage) / columnCount | 0);
|
||
|
||
return this.Parent.GetColumnContentFrame(page, column, section.GetSectPr());
|
||
};
|
||
CDocumentContentElementBase.prototype.SetUseXLimit = function(isUse)
|
||
{
|
||
this.UseXLimit = isUse;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsUseXLimit = function()
|
||
{
|
||
return this.UseXLimit;
|
||
};
|
||
CDocumentContentElementBase.prototype.SetUseYLimit = function(isUse)
|
||
{
|
||
this.UseYLimit = isUse;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsUseYLimit = function()
|
||
{
|
||
return this.UseYLimit;
|
||
};
|
||
CDocumentContentElementBase.prototype.Recalculate_Page = function(CurPage)
|
||
{
|
||
return recalcresult_NextElement;
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_PageBounds = function(CurPage)
|
||
{
|
||
return new CDocumentBounds(this.X, this.Y, this.XLimit, this.YLimit);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetContentBounds = function(CurPage)
|
||
{
|
||
return new CDocumentBounds(this.X, this.Y, this.XLimit, this.YLimit);
|
||
};
|
||
CDocumentContentElementBase.prototype.IsEmptyPage = function(nCurPage)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.Reset_RecalculateCache = function()
|
||
{
|
||
};
|
||
/**
|
||
* @param iPage {number} relative page index
|
||
* @returns {recalcresult}
|
||
*/
|
||
CDocumentContentElementBase.prototype.RecalculateKeepNext = function(iPage)
|
||
{
|
||
if (!(this.Parent instanceof CDocument))
|
||
return recalcresult_NextElement;
|
||
|
||
// Такая настройка срабатывает в единственном случае:
|
||
// У предыдущего параграфа выставлена данная настройка, а текущий параграф сразу начинается с новой страницы
|
||
// ( при этом у него не выставлен флаг "начать с новой страницы", иначе будет зацикливание здесь ).
|
||
if (1 === iPage && this.IsEmptyPage(0))
|
||
{
|
||
// Если у предыдущего параграфа стоит настройка "не отрывать от следующего".
|
||
// И сам параграф не разбит на несколько страниц и не начинается с новой страницы,
|
||
// тогда мы должны пересчитать предыдущую страницу, с учетом того, что предыдущий параграф
|
||
// надо начать с новой страницы.
|
||
let curr = this.Get_DocumentPrev();
|
||
while (curr && curr.IsParagraph() && !curr.Get_SectionPr())
|
||
{
|
||
let currKeepNext = curr.Get_CompiledPr2(false).ParaPr.KeepNext;
|
||
if (!currKeepNext || curr.getPageCount() > 1 || !curr.IsInline() || curr.Check_PageBreak())
|
||
break;
|
||
|
||
let prev = curr.Get_DocumentPrev();
|
||
if (!prev || (prev.IsParagraph() && prev.Get_SectionPr()))
|
||
break;
|
||
|
||
if (!prev.IsParagraph() || !prev.Get_CompiledPr2(false).ParaPr.KeepNext)
|
||
{
|
||
if (this.Parent.RecalcInfo.Can_RecalcObject())
|
||
{
|
||
this.Parent.RecalcInfo.Set_KeepNext(curr, this);
|
||
return recalcresult_PrevPage | recalcresultflags_Column;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
curr = prev;
|
||
}
|
||
}
|
||
|
||
if (this.Parent.RecalcInfo.Check_KeepNextEnd(this))
|
||
{
|
||
// Дошли до сюда, значит уже пересчитали данную ситуацию.
|
||
// Делаем Reset здесь, потому что Reset надо делать в том же месте, гды мы запросили пересчет заново.
|
||
this.Parent.RecalcInfo.Reset();
|
||
}
|
||
|
||
return recalcresult_NextElement;
|
||
};
|
||
CDocumentContentElementBase.prototype.Write_ToBinary2 = function(Writer)
|
||
{
|
||
Writer.WriteLong(AscDFH.historyitem_type_Unknown);
|
||
};
|
||
CDocumentContentElementBase.prototype.Read_FromBinary2 = function(Reader)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_PagesCount = function()
|
||
{
|
||
return 0;
|
||
};
|
||
CDocumentContentElementBase.prototype.Document_CreateFontMap = function(FontMap)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.Document_CreateFontCharMap = function(FontCharMap)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.Document_Get_AllFontNames = function(AllFonts)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.IsInText = function(X, Y, CurPage)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsInDrawing = function(X, Y, CurPage)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsTableBorder = function(X, Y, CurPage)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.UpdateCursorType = function(X, Y, CurPage)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.Selection_SetStart = function(X, Y, CurPage, MouseEvent, isTableBorder)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.Selection_SetEnd = function(X, Y, CurPage, MouseEvent, isTableBorder)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.IsSelectionEmpty = function(isCheckHidden)
|
||
{
|
||
return true;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetSelectedElementsInfo = function(oInfo)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.Document_UpdateRulersState = function(CurPage)
|
||
{
|
||
this.Content.Document_UpdateRulersState(CurPage);
|
||
};
|
||
CDocumentContentElementBase.prototype.IsSelectionUse = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsSelectionToEnd = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.RemoveSelection = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetSelectionUse = function(isUse)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetSelectionToBeginEnd = function(isSelectionStart, isElementStart)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SelectAll = function(nDirection)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetCalculatedTextPr = function()
|
||
{
|
||
var oTextPr = new CTextPr();
|
||
oTextPr.InitDefault();
|
||
return oTextPr;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetCalculatedParaPr = function()
|
||
{
|
||
var oParaPr = new CParaPr();
|
||
oParaPr.InitDefault();
|
||
return oParaPr;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetDirectParaPr = function()
|
||
{
|
||
return new CParaPr();
|
||
};
|
||
CDocumentContentElementBase.prototype.GetDirectTextPr = function()
|
||
{
|
||
return new CTextPr();
|
||
};
|
||
CDocumentContentElementBase.prototype.DrawSelectionOnPage = function(CurPage, clipInfo)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.StopSelection = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetSelectionBounds = function()
|
||
{
|
||
return {
|
||
Start : null,
|
||
End : null,
|
||
Direction : 0
|
||
};
|
||
};
|
||
CDocumentContentElementBase.prototype.RecalculateCurPos = function(bUpdateX, bUpdateY, isUpdateTarget)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.Can_CopyCut = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.CanCopyCut = function()
|
||
{
|
||
return this.Can_CopyCut();
|
||
};
|
||
CDocumentContentElementBase.prototype.CheckPosInSelection = function(X, Y, CurPage, NearPos)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_NearestPos = function(CurPage, X, Y, bAnchor, Drawing)
|
||
{
|
||
return {
|
||
X : 0,
|
||
Y : 0,
|
||
Height : 0,
|
||
PageNum : 0,
|
||
Internal : {Line : 0, Page : 0, Range : 0},
|
||
Transform : null,
|
||
Paragraph : null,
|
||
ContentPos : null,
|
||
SearchPos : null
|
||
};
|
||
};
|
||
CDocumentContentElementBase.prototype.GetNearestPos = function(CurPage, X, Y, bAnchor, Drawing)
|
||
{
|
||
return this.Get_NearestPos(CurPage, X, Y, bAnchor, Drawing);
|
||
};
|
||
CDocumentContentElementBase.prototype.CanUpdateTarget = function(CurPage)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorLeftWithSelectionFromEnd = function(Word)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorLeft = function(AddToSelect, Word)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorRight = function(AddToSelect, Word)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorRightWithSelectionFromStart = function(Word)
|
||
{
|
||
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorToStartPos = function(AddToSelect)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorToEndPos = function(AddToSelect, StartSelectFromEnd)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorUp = function(AddToSelect)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorUpToLastRow = function(X, Y, AddToSelect)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorDown = function(AddToSelect)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorDownToFirstRow = function(X, Y, AddToSelect)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorToEndOfLine = function(AddToSelect)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorToStartOfLine = function(AddToSelect)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorToXY = function(X, Y, bLine, bDontChangeRealPos, CurPage)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MoveCursorToCell = function(bNext)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsCursorAtBegin = function()
|
||
{
|
||
return true;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsCursorAtEnd = function()
|
||
{
|
||
return true;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetSelectionState = function()
|
||
{
|
||
return [];
|
||
};
|
||
CDocumentContentElementBase.prototype.SetSelectionState = function(State, StateIndex)
|
||
{
|
||
|
||
};
|
||
CDocumentContentElementBase.prototype.AddNewParagraph = function()
|
||
{
|
||
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_SelectionState2 = function()
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.Set_SelectionState2 = function(State)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.IsStartFromNewPage = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllParagraphs = function(Props, ParaArray)
|
||
{
|
||
return [];
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllTables = function(oProps, arrTables)
|
||
{
|
||
return [];
|
||
};
|
||
CDocumentContentElementBase.prototype.SetContentSelection = function(StartDocPos, EndDocPos, Depth, StartFlag, EndFlag)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetContentPosition = function(bSelection, bStart, PosArray)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetContentPosition = function(DocPos, Depth, Flag)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetNumberingInfo = function(oNumberingEngine)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.AddInlineImage = function(W, H, Img, GraphicObject, bFlow)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.AddImages = function(aImages)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.AddOleObject = function(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.AddSignatureLine = function(oSignatureDrawing)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.AddTextArt = function(nStyle)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.AddInlineTable = function(nCols, nRows, nMode)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.Remove = function(nCount, bOnlyText, bRemoveOnlySelection, bOnAddText, isWord)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetReviewType = function(ReviewType)
|
||
{
|
||
|
||
};
|
||
CDocumentContentElementBase.prototype.GetReviewType = function()
|
||
{
|
||
return reviewtype_Common;
|
||
};
|
||
CDocumentContentElementBase.prototype.Is_Empty = function()
|
||
{
|
||
return true;
|
||
};
|
||
CDocumentContentElementBase.prototype.Add = function(oParaItem)
|
||
{
|
||
// TODO: Данную функцию нужно заменить на AddToParagraph
|
||
};
|
||
CDocumentContentElementBase.prototype.PreDelete = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.ClearParagraphFormatting = function(isClearParaPr, isClearTextPr)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetCursorPosXY = function()
|
||
{
|
||
return {X : 0, Y : 0};
|
||
};
|
||
CDocumentContentElementBase.prototype.StartSelectionFromCurPos = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphPr = function(oParaPr)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphAlign = function(Align)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphDefaultTabSize = function(TabSize)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphSpacing = function(Spacing)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphTabs = function(Tabs)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphIndent = function(Ind)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphShd = function(Shd)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphStyle = function(Name)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphContextualSpacing = function(Value)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphPageBreakBefore = function(Value)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphKeepLines = function(Value)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphKeepNext = function(Value)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphWidowControl = function(Value)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphBorders = function(Borders)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetParagraphFramePr = function(FramePr, bDelete)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.IncreaseDecreaseFontSize = function(bIncrease)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.IncreaseDecreaseIndent = function(bIncrease)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetImageProps = function(oProps)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetTableProps = function(oProps)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetSelectedContent = function(oSelectedContent)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.PasteFormatting = function(oData)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetCurPosXY = function()
|
||
{
|
||
return {X : 0, Y : 0};
|
||
};
|
||
CDocumentContentElementBase.prototype.GetSelectedText = function(bClearText, oPr)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetCurrentParagraph = function(bIgnoreSelection, arrSelectedParagraphs)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetCurrentTablesStack = function(arrTables)
|
||
{
|
||
return arrTables ? arrTables : [];
|
||
};
|
||
CDocumentContentElementBase.prototype.AddTableRow = function(bBefore, nCount)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.AddTableColumn = function(bBefore, nCount)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.RemoveTableRow = function(nRowIndex)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.RemoveTableColumn = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.MergeTableCells = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.SplitTableCells = function(nColsCount, nRowsCount)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.RemoveTableCells = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.RemoveTable = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.SelectTable = function(Type)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.DistributeTableCells = function(isHorizontally)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.CanMergeTableCells = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.CanSplitTableCells = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.Document_UpdateInterfaceState = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.Document_UpdateRulersState = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetTableProps = function()
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.AddHyperlink = function(Props)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.ModifyHyperlink = function(Props)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.RemoveHyperlink = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.CanAddHyperlink = function(bCheckInHyperlink)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsCursorInHyperlink = function(bCheckEnd)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.AddComment = function(Comment, bStart, bEnd)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.CanAddComment = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetSelectionAnchorPos = function()
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.AddContentControl = function(nContentControlType)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.RecalculateMinMaxContentWidth = function(isRotated)
|
||
{
|
||
return {Min : 0, Max : 0};
|
||
};
|
||
CDocumentContentElementBase.prototype.Shift = function(CurPage, dX, dY)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.UpdateEndInfo = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.PrepareRecalculateObject = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SaveRecalculateObject = function()
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.LoadRecalculateObject = function(RecalcObj)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.SetApplyToAll = function(isApplyAll)
|
||
{
|
||
this.ApplyToAll = isApplyAll;
|
||
};
|
||
CDocumentContentElementBase.prototype.IsApplyToAll = function()
|
||
{
|
||
return this.ApplyToAll;
|
||
};
|
||
CDocumentContentElementBase.prototype.RecalculateAllTables = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllFloatElements = function(FloatObjects)
|
||
{
|
||
if (!FloatObjects)
|
||
return [];
|
||
|
||
return FloatObjects;
|
||
};
|
||
CDocumentContentElementBase.prototype.Get_FirstParagraph = function()
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.StartFromNewPage = function()
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.CollectDocumentStatistics = function(Stats)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.CompareDrawingsLogicPositions = function(CompareObject)
|
||
{
|
||
return 0;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetStyleFromFormatting = function()
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllContentControls = function(arrContentControls)
|
||
{
|
||
};
|
||
/**
|
||
* Проверяем выделен ли элемент целиком
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsSelectedAll = function()
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetLastRangeVisibleBounds = function()
|
||
{
|
||
return {
|
||
X : 0,
|
||
Y : 0,
|
||
W : 0,
|
||
H : 0,
|
||
BaseLine : 0,
|
||
XLimit : 0
|
||
};
|
||
};
|
||
CDocumentContentElementBase.prototype.FindNextFillingForm = function(isNext, isCurrent, isStart)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetRevisionsChangeElement = function(SearchEngine)
|
||
{
|
||
return null;
|
||
};
|
||
CDocumentContentElementBase.prototype.AcceptRevisionChanges = function(Type, bAll)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.RejectRevisionChanges = function(Type, bAll)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetDocumentPositionFromObject = function(arrPos)
|
||
{
|
||
if (!arrPos)
|
||
arrPos = [];
|
||
|
||
var oParent = this.GetParent();
|
||
if (oParent)
|
||
{
|
||
if (arrPos.length > 0)
|
||
{
|
||
arrPos.splice(0, 0, {Class : oParent, Position : this.GetIndex()});
|
||
arrPos = oParent.GetDocumentPositionFromObject(arrPos);
|
||
}
|
||
else
|
||
{
|
||
arrPos = oParent.GetDocumentPositionFromObject(arrPos);
|
||
arrPos.push({Class : oParent, Position : this.GetIndex()});
|
||
}
|
||
}
|
||
|
||
return arrPos;
|
||
};
|
||
/**
|
||
* Получаем массив всех конент контролов, внутри которых лежит данный класс
|
||
* @returns {Array}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetParentContentControls = function()
|
||
{
|
||
let docPos = this.GetDocumentPositionFromObject();
|
||
|
||
let contentControls = [];
|
||
for (let pos = 0, len = docPos.length; pos < len; ++pos)
|
||
{
|
||
if (docPos[pos].Class instanceof AscWord.CInlineLevelSdt)
|
||
contentControls.push(docPos[pos].Class);
|
||
else if (docPos[pos].Class instanceof AscWord.CDocumentContent && docPos[pos].Class.Parent instanceof AscWord.CBlockLevelSdt)
|
||
contentControls.push(docPos[pos].Class.Parent);
|
||
}
|
||
|
||
return contentControls;
|
||
};
|
||
/**
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsInPlaceholder = function()
|
||
{
|
||
let contentControls = this.GetParentContentControls();
|
||
for (let index = 0, count = contentControls.length; index < count; ++index)
|
||
{
|
||
if (contentControls[index].IsPlaceHolder())
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetOutlineParagraphs = function(arrOutline, oPr)
|
||
{
|
||
};
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
// Функции для работы с номерами страниц/колонок/секций
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
CDocumentContentElementBase.prototype.GetAbsoluteStartPage = function()
|
||
{
|
||
return this.GetAbsolutePage(0);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetRelativeStartPage = function()
|
||
{
|
||
return this.PageNum;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetStartColumn = function()
|
||
{
|
||
return this.ColumnNum;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetStartSection = function()
|
||
{
|
||
return this.SectionNum;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetElementPageIndex = function(page, column, columnCount, sectionIndex)
|
||
{
|
||
if (undefined === this.SectionNum || this.Sections.length <= 1)
|
||
{
|
||
let startPage = this.GetRelativeStartPage();
|
||
return column - this.GetStartColumn() + (page - startPage) * columnCount;
|
||
}
|
||
else
|
||
{
|
||
if (undefined === sectionIndex)
|
||
sectionIndex = this.SectionNum;
|
||
|
||
let section = this.Sections[sectionIndex - this.SectionNum];
|
||
if (!section)
|
||
return 0;
|
||
|
||
let parentStartPage = section.GetParentStartPage();
|
||
let startPage = section.GetStartPage();
|
||
let columnCount = section.GetColumnCount();
|
||
let startColumn = section.GetStartColumn();
|
||
|
||
return column - startColumn + (page - parentStartPage) * columnCount + startPage;
|
||
}
|
||
};
|
||
CDocumentContentElementBase.prototype.GetElementPageIndexByXY = function(x, y, page)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetColumnCount = function()
|
||
{
|
||
return this.ColumnsCount;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAbsoluteSection = function(curPage)
|
||
{
|
||
if (this.Parent instanceof AscWord.Document)
|
||
{
|
||
let elementSection = this.GetElementSectionByPage(curPage);
|
||
if (!elementSection)
|
||
return 0;
|
||
|
||
return this.SectionNum + elementSection.GetIndex();
|
||
}
|
||
|
||
if (!this.Parent || !this.Parent.GetAbsoluteSection)
|
||
return 0;
|
||
|
||
return this.Parent.GetAbsoluteSection(this.GetRelativePage(curPage));
|
||
};
|
||
CDocumentContentElementBase.prototype.GetRelativePage = function(curPage)
|
||
{
|
||
if (undefined === this.SectionNum || this.Sections.length <= 1)
|
||
{
|
||
if (!this.ColumnsCount || 0 === this.ColumnsCount)
|
||
return this.PageNum + curPage;
|
||
|
||
return this.PageNum + ((this.ColumnNum + curPage) / this.ColumnsCount | 0);
|
||
}
|
||
else
|
||
{
|
||
let elementSection = this.GetElementSectionByPage(curPage);
|
||
if (!elementSection)
|
||
return 0;
|
||
|
||
let parentStartPage = elementSection.GetParentStartPage();
|
||
let columnCount = elementSection.GetColumnCount();
|
||
let startColumn = elementSection.GetStartColumn();
|
||
let startPage = elementSection.GetStartPage();
|
||
|
||
return parentStartPage + ((startColumn + curPage - startPage) / columnCount | 0);
|
||
}
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAbsolutePage = function(CurPage)
|
||
{
|
||
return this.Parent.GetAbsolutePage(this.GetRelativePage(CurPage));
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAbsoluteColumn = function(curPage)
|
||
{
|
||
if (this.Parent instanceof AscWord.Document)
|
||
{
|
||
let elementSection = this.GetElementSectionByPage(curPage);
|
||
if (!elementSection)
|
||
return 0;
|
||
|
||
let columnCount = elementSection.GetColumnCount();
|
||
let startColumn = elementSection.GetStartColumn();
|
||
let startPage = elementSection.GetStartPage();
|
||
|
||
return (startColumn + curPage - startPage) - (((startColumn + curPage - startPage) / columnCount | 0) * columnCount);
|
||
}
|
||
|
||
return this.Parent.GetAbsoluteColumn(this.GetRelativePage(curPage));
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAbsoluteCurrentPage = function()
|
||
{
|
||
return this.GetAbsolutePage(0);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetRelativeCurrentPage = function()
|
||
{
|
||
return this.GetRelativePage(0);
|
||
};
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
CDocumentContentElementBase.prototype.GetPagesCount = function()
|
||
{
|
||
return this.Get_PagesCount();
|
||
};
|
||
CDocumentContentElementBase.prototype.getPageCount = function()
|
||
{
|
||
return this.Get_PagesCount();
|
||
};
|
||
CDocumentContentElementBase.prototype.GetIndex = function()
|
||
{
|
||
if (!this.Parent)
|
||
return -1;
|
||
|
||
this.Parent.Update_ContentIndexing();
|
||
|
||
if (this !== this.Parent.GetElement(this.Index))
|
||
this.Index = -1;
|
||
|
||
return this.Index;
|
||
};
|
||
CDocumentContentElementBase.prototype.GetTopIndex = function()
|
||
{
|
||
let docPos = this.GetDocumentPositionFromObject();
|
||
return (docPos && docPos.length > 0 ? docPos[0].Position : -1);
|
||
};
|
||
CDocumentContentElementBase.prototype.getPageBounds = function(iPage)
|
||
{
|
||
return this.Get_PageBounds(iPage);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetPageBounds = function(CurPage)
|
||
{
|
||
return this.Get_PageBounds(CurPage);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetNearestPos = function(CurPage, X, Y, bAnchor, Drawing)
|
||
{
|
||
return this.Get_NearestPos(CurPage, X, Y, bAnchor, Drawing);
|
||
};
|
||
CDocumentContentElementBase.prototype.CreateFontMap = function(oFontMap)
|
||
{
|
||
return this.Document_CreateFontMap(oFontMap);
|
||
};
|
||
CDocumentContentElementBase.prototype.CreateFontCharMap = function(oFontCharMap)
|
||
{
|
||
return this.Document_CreateFontCharMap(oFontCharMap);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllFontNames = function(FontNames)
|
||
{
|
||
return this.Document_Get_AllFontNames(FontNames);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetSelectionState2 = function()
|
||
{
|
||
return this.Get_SelectionState2();
|
||
};
|
||
CDocumentContentElementBase.prototype.SetSelectionState2 = function(State)
|
||
{
|
||
return this.Set_SelectionState2(State);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetReviewInfo = function()
|
||
{
|
||
return new AscWord.ReviewInfo();
|
||
};
|
||
CDocumentContentElementBase.prototype.SetReviewTypeWithInfo = function(nType, oInfo)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.IsEmpty = function(oProps)
|
||
{
|
||
return this.Is_Empty(oProps);
|
||
};
|
||
CDocumentContentElementBase.prototype.AddToParagraph = function(oItem)
|
||
{
|
||
return this.Add(oItem);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllDrawingObjects = function(AllDrawingObjects)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllComments = function(AllComments)
|
||
{
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllMaths = function(AllMaths)
|
||
{
|
||
};
|
||
|
||
/**
|
||
* Find all SEQ complex fields with specified type
|
||
* @param {String} sType - field type
|
||
* @param {Array} aFields - array which accumulates complex fields
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetAllSeqFieldsByType = function(sType, aFields)
|
||
{
|
||
};
|
||
|
||
CDocumentContentElementBase.prototype.UpdateBookmarks = function(oManager)
|
||
{
|
||
};
|
||
/**
|
||
* Получаем текущий TableOfContents, это может быть просто поле или поле вместе с оберткой Sdt
|
||
* @param isUnique ищем с параметром Unique = true
|
||
* @param isCheckFields Проверять ли TableOfContents, заданные через сложные поля
|
||
* @returns {CComplexField | CBlockLevelSdt | null}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetTableOfContents = function(isUnique, isCheckFields)
|
||
{
|
||
return null;
|
||
};
|
||
/**
|
||
* Get all tables of figures inside
|
||
* @param arrComplexFields
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetTablesOfFigures = function(arrComplexFields)
|
||
{
|
||
};
|
||
/**
|
||
* Проверяем у родительского класса выделен ли только один элемент
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsSelectedSingleElement = function()
|
||
{
|
||
if (this.Parent)
|
||
return this.Parent.IsSelectedSingleElement();
|
||
|
||
return false;
|
||
};
|
||
/**
|
||
* Получаем последний параграф в данном контенте, если последний элемент не параграф, то запрашиваем у него
|
||
* @returns {?Paragraph}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetLastParagraph = function()
|
||
{
|
||
return null;
|
||
};
|
||
/**
|
||
* Получаем первый параграф в данном контенте
|
||
* @returns {?Paragraph}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetFirstParagraph = function()
|
||
{
|
||
return this.Get_FirstParagraph();
|
||
};
|
||
/**
|
||
* Получаем параграф, следующий за данным элементом
|
||
* @returns {?Paragraph}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetNextParagraph = function()
|
||
{
|
||
var oNextElement = this.Get_DocumentNext();
|
||
|
||
if (oNextElement)
|
||
{
|
||
if (type_Paragraph === oNextElement.GetType())
|
||
return oNextElement;
|
||
else
|
||
return oNextElement.GetFirstParagraph();
|
||
}
|
||
|
||
if (this.Parent && this.Parent.GetNextParagraph)
|
||
return this.Parent.GetNextParagraph();
|
||
|
||
return null;
|
||
};
|
||
/**
|
||
* Получаем параграф, идущий перед данным элементом
|
||
* @returns {?Paragraph}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetPrevParagraph = function()
|
||
{
|
||
var oPrevElement = this.Get_DocumentPrev();
|
||
|
||
if (oPrevElement)
|
||
{
|
||
if (type_Paragraph === oPrevElement.GetType())
|
||
return oPrevElement;
|
||
else
|
||
return oPrevElement.GetLastParagraph();
|
||
}
|
||
|
||
if (this.Parent && this.Parent.GetPrevParagraph)
|
||
return this.Parent.GetPrevParagraph();
|
||
|
||
return null;
|
||
};
|
||
/**
|
||
* Собираем список заголовков
|
||
* @param {Paragraph[]} arrOutline
|
||
* @param {object} oPr
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetOutlineParagraphs = function(arrOutline, oPr)
|
||
{
|
||
};
|
||
/**
|
||
* Вплоть до заданного параграфа ищем последнюю похожую нумерацию
|
||
* @param oContinueEngine {CDocumentNumberingContinueEngine}
|
||
* @returns {AscWord.NumPr | null}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetSimilarNumbering = function(oContinueEngine)
|
||
{
|
||
return null;
|
||
};
|
||
/**
|
||
* Переходим к следующей ссылке на сноску
|
||
* @param isNext {boolean} - направление поиска
|
||
* @param isCurrent {boolean} - ищем начиная с текущей позиции или с края элемента
|
||
* @param isStepFootnote {boolean} - ищем сноски на странице
|
||
* @param isStepEndnote {boolean} - ищем концевые сноски
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GotoFootnoteRef = function(isNext, isCurrent, isStepFootnote, isStepEndnote)
|
||
{
|
||
return false;
|
||
};
|
||
/**
|
||
* Сообщаем, пересчитан ли данный элемент с момента внесения в него изменений
|
||
* @param {boolean} isRecalculated
|
||
*/
|
||
CDocumentContentElementBase.prototype.SetIsRecalculated = function(isRecalculated)
|
||
{
|
||
this.Recalculated = isRecalculated;
|
||
};
|
||
/**
|
||
* Узнаем рассчитан ли данный элемент
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsRecalculated = function()
|
||
{
|
||
return this.Recalculated;
|
||
};
|
||
/**
|
||
* Проверяем выделен ли сейчас какой-либо плейсхолдер, если да, то возвращаем управляющий объект
|
||
* @returns {?Object}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetPlaceHolderObject = function()
|
||
{
|
||
return null;
|
||
};
|
||
/**
|
||
* Получаем массив все полей в документе (простых и сложных)
|
||
* @param isUseSelection {boolean} ищем по селекут или вообще все
|
||
* @param arrFields - массив, который мы заполняем, если не задан, то создается новый и возвращается
|
||
* @returns {Array}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetAllFields = function(isUseSelection, arrFields)
|
||
{
|
||
return arrFields ? arrFields : [];
|
||
};
|
||
/**
|
||
* Получаем верхний элемент в документе, в котором лежит данный элемент
|
||
* @returns {?CDocumentContentElementBase}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetTopElement = function()
|
||
{
|
||
if (!this.Parent)
|
||
return null;
|
||
|
||
if (this.Parent === this.Parent.Is_TopDocument(true))
|
||
return this;
|
||
|
||
return this.Parent.GetTopElement();
|
||
};
|
||
/**
|
||
* Получаем верхний DocContent, в котором лежит данный элемент
|
||
* @returns {?CDocumentContentBase}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetTopDocumentContent = function()
|
||
{
|
||
if (!this.Parent)
|
||
return null;
|
||
|
||
return this.Parent.GetTopDocumentContent();
|
||
};
|
||
/**
|
||
* Получаем объект лока данного элемента
|
||
* @returns {AscCommon.CLock}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetLock = function()
|
||
{
|
||
return this.Lock;
|
||
};
|
||
/**
|
||
* Если мы находимся в колонтитуле возвращаем его
|
||
* @returns {?CHdrFtr}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetHdrFtr = function()
|
||
{
|
||
if (this.Parent)
|
||
return this.Parent.IsHdrFtr(true);
|
||
|
||
return null;
|
||
};
|
||
/**
|
||
* Используется ли данный элемент в содержимом документа
|
||
* @param {string} sId - идентификатор внутреннего класса
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsUseInDocument = function(sId)
|
||
{
|
||
return false;
|
||
};
|
||
/**
|
||
* Пробегаемся по все ранам с заданной функцией
|
||
* @param fCheck - функция проверки содержимого рана
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.CheckRunContent = function(fCheck)
|
||
{
|
||
return false;
|
||
};
|
||
CDocumentContentElementBase.prototype.CheckSelectedRunContent = function(fCheck)
|
||
{
|
||
return false;
|
||
};
|
||
/**
|
||
* По заданной странице получаем страницу, с которой нужно начинать расчет
|
||
* @param {number} nPageAbs
|
||
* @return {number}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetStartPageForRecalculate = function(nPageAbs)
|
||
{
|
||
return nPageAbs;
|
||
};
|
||
/**
|
||
* Проверяем выделено ли сейчас какое-либо презентационное поле, если да, то возвращаем управляющий объект
|
||
* @returns {?Object}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetPresentationField = function()
|
||
{
|
||
return null;
|
||
};
|
||
/**
|
||
* Получаем список таблицы на заданной абсолютной странице
|
||
* @param {number} nPageAbs
|
||
* @param {Array} arrTables
|
||
* @returns {Array}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetAllTablesOnPage = function(nPageAbs, arrTables){return arrTables ? arrTables : [];};
|
||
/**
|
||
* Обрабатываем сложные поля
|
||
*/
|
||
CDocumentContentElementBase.prototype.ProcessComplexFields = function() {};
|
||
/**
|
||
* Вычисляем EndInfo для всех параграфаов
|
||
*/
|
||
CDocumentContentElementBase.prototype.RecalculateEndInfo = function() {};
|
||
/**
|
||
* Получаем ссылку на глобальный класс документа
|
||
* @returns {CDocument}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetLogicDocument = function()
|
||
{
|
||
if (!this.LogicDocument && this.Parent && this.Parent.GetLogicDocument)
|
||
this.LogicDocument = this.Parent.GetLogicDocument();
|
||
|
||
return this.LogicDocument;
|
||
};
|
||
/**
|
||
* @returns {?CDrawingDocument}
|
||
*/
|
||
CDocumentContentElementBase.prototype.getDrawingDocument = function()
|
||
{
|
||
return Asc.editor.getDrawingDocument();
|
||
};
|
||
/**
|
||
* @returns {?AscWord.CDocumentSpellChecker}
|
||
*/
|
||
CDocumentContentElementBase.prototype.getSpelling = function()
|
||
{
|
||
let logicDocument = this.GetLogicDocument();
|
||
return logicDocument ? logicDocument.Spelling : null;
|
||
};
|
||
/**
|
||
* @returns {boolean}
|
||
*/
|
||
CDocumentContentElementBase.prototype.IsSpellingUse = function()
|
||
{
|
||
let oSpelling = this.getSpelling();
|
||
if(!oSpelling)
|
||
return false;
|
||
return oSpelling.Use;
|
||
};
|
||
/**
|
||
* @returns {?AscWord.CustomTextAnnotator}
|
||
*/
|
||
CDocumentContentElementBase.prototype.getCustomTextAnnotator = function()
|
||
{
|
||
let logicDocument = this.GetLogicDocument();
|
||
return logicDocument && logicDocument.IsDocumentEditor() ? logicDocument.CustomTextAnnotator : null;
|
||
};
|
||
/**
|
||
* Получаем настройки рамки для данного элемента
|
||
* @returns {?CFramePr}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetFramePr = function(){return null;};
|
||
/**
|
||
* Получаем маскимальную ширину таблицы
|
||
* @returns {{GapLeft : {number}, GapRight : {number}, GridWidth : {number}}}
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetMaxTableGridWidth = function(){return {GapLeft : 0, GapRight : 0, GridWidth : -1};};
|
||
/**
|
||
* Обновляем нумерацию строк
|
||
*/
|
||
CDocumentContentElementBase.prototype.UpdateLineNumbersInfo = function(){};
|
||
/**
|
||
* Подсчитываем на сколько элементов разбивается данный элемент с заданным сепаратором
|
||
* @param oEngine {CTextToTableEngine}
|
||
*/
|
||
CDocumentContentElementBase.prototype.CalculateTextToTable = function(oEngine){};
|
||
/**
|
||
* @param arrChanges
|
||
*/
|
||
CDocumentContentElementBase.prototype.GetSelectedReviewChanges = function(arrChanges, oTrackChanges) {return arrChanges ? arrChanges : [];};
|
||
/**
|
||
* Прокидываем наверх событие об изменении содержимого данного элемента
|
||
*/
|
||
CDocumentContentElementBase.prototype.OnContentChange = function()
|
||
{
|
||
if (this.Parent && this.Parent.OnContentChange)
|
||
this.Parent.OnContentChange();
|
||
};
|
||
/**
|
||
* Get the scale coefficient for the current element depending on the current section and the document layout
|
||
* @returns {number}
|
||
*/
|
||
CDocumentContentElementBase.prototype.getLayoutScaleCoefficient = function()
|
||
{
|
||
let logicDocument = this.GetLogicDocument();
|
||
if (!logicDocument || !logicDocument.IsDocumentEditor() || !this.Get_SectPr)
|
||
return 1;
|
||
|
||
let layout = logicDocument.Layout;
|
||
logicDocument.Layout = logicDocument.Layouts.Print;
|
||
|
||
let sectPr = this.Get_SectPr();
|
||
logicDocument.Layout = layout;
|
||
|
||
if (!sectPr)
|
||
return 1;
|
||
|
||
return logicDocument.GetDocumentLayout().GetScaleBySection(sectPr);
|
||
};
|
||
CDocumentContentElementBase.prototype.updateTrackRevisions = function()
|
||
{
|
||
AscWord.checkElementInRevision && AscWord.checkElementInRevision(this);
|
||
};
|
||
CDocumentContentElementBase.prototype.isPreventedPreDelete = function()
|
||
{
|
||
let logicDocument = this.GetLogicDocument();
|
||
return !logicDocument || !logicDocument.IsDocumentEditor() || logicDocument.isPreventedPreDelete();
|
||
};
|
||
CDocumentContentElementBase.prototype.isWholeElementInPermRange = function()
|
||
{
|
||
// TODO: В таблицах GetNextDocumentElement/GetPrevDocumentElement не работает, надо проверить не баг ли это
|
||
// по логике оба варианта должны выдавать одинаковый результат
|
||
|
||
// let prevPara = this.GetPrevParagraphInDocument();
|
||
// let nextPara = this.GetNextParagraphInDocument();
|
||
//
|
||
// let startRanges = prevPara ? prevPara.GetEndInfo().GetPermRanges() : [];
|
||
// let endRanges = nextPara ? nextPara.GetEndInfoByPage(-1).GetPermRanges() : [];
|
||
|
||
let startPara = this.GetFirstParagraph();
|
||
let endPara = this.GetLastParagraph();
|
||
|
||
if (!startPara
|
||
|| !endPara
|
||
|| !startPara.IsRecalculated()
|
||
|| !endPara.IsRecalculated())
|
||
return false;
|
||
|
||
let startInfo = startPara.GetEndInfoByPage(-1);
|
||
let endInfo = endPara.GetEndInfo();
|
||
|
||
let startRanges = startInfo ? startInfo.GetPermRanges() : [];
|
||
let endRanges = endInfo ? endInfo.GetPermRanges() : [];
|
||
|
||
return AscWord.PermRangesManager.isInPermRange(startRanges, endRanges);
|
||
};
|
||
CDocumentContentElementBase.prototype.GetAllSectPrParagraphs = function(paragraphs)
|
||
{
|
||
return paragraphs ? paragraphs : [];
|
||
};
|
||
CDocumentContentElementBase.prototype.GetParentTables = function()
|
||
{
|
||
let tables = [];
|
||
|
||
let docPos = this.GetDocumentPositionFromObject();
|
||
for (let i = 0, count = docPos.length; i < count; ++i)
|
||
{
|
||
if (docPos[i].Class instanceof AscWord.Table)
|
||
tables.push(docPos[i].Class);
|
||
}
|
||
return tables;
|
||
};
|
||
/**
|
||
* Отличие данной функции от Get_SectionPr в том, что здесь возвращаются настройки секции, к которой
|
||
* принадлежит данный элемент, а там конкретно настройки секции, которые лежат в данном параграфе (если это параграф).
|
||
* @returns {null|AscWord.SectPr}
|
||
*/
|
||
CDocumentContentElementBase.prototype.Get_SectPr = function()
|
||
{
|
||
let logicDocument = this.GetLogicDocument();
|
||
if (!logicDocument || !logicDocument.IsDocumentEditor())
|
||
return null;
|
||
|
||
let sectPr = logicDocument.GetSections().GetSectPrByElement(this);
|
||
return logicDocument.Layout.CheckSectPr(sectPr);
|
||
};
|
||
|
||
//--------------------------------------------------------export--------------------------------------------------------
|
||
window['AscCommonWord'] = window['AscCommonWord'] || {};
|
||
window['AscCommonWord'].CDocumentContentElementBase = CDocumentContentElementBase;
|
||
window['AscCommonWord'].type_Unknown = type_Unknown;
|