3030 lines
90 KiB
JavaScript
3030 lines
90 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 hdrftr_Header = AscCommon.hdrftr_Header;
|
||
var hdrftr_Footer = AscCommon.hdrftr_Footer;
|
||
var History = AscCommon.History;
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
// Класс работающий с одним колонтитулом
|
||
//-----------------------------------------------------------------------------------
|
||
function CHeaderFooter(Parent, oLogicDocument, DrawingDocument, Type)
|
||
{
|
||
this.Id = AscCommon.g_oIdCounter.Get_NewId();
|
||
|
||
this.Parent = Parent;
|
||
this.DrawingDocument = DrawingDocument;
|
||
this.LogicDocument = oLogicDocument;
|
||
|
||
if (oLogicDocument)
|
||
{
|
||
let sStyleId = Type === hdrftr_Header ? oLogicDocument.GetStyles().Get_Default_Header() : oLogicDocument.GetStyles().Get_Default_Footer();
|
||
this.Content = new CDocumentContent(this, DrawingDocument, 0, 0, 0, 0, false, true);
|
||
this.Content.Content[0].SetParagraphStyleById(sStyleId);
|
||
}
|
||
|
||
this.Type = Type;
|
||
|
||
this.RecalcInfo = {
|
||
CurPage : -1, // Текущий выставленный номер страницы
|
||
RecalcObj : {}, // Постраничные объекты пересчета данного колонтитула
|
||
NeedRecalc : {}, // Объект с ключом - номером страницы, нужно ли пересчитывать данную страницу
|
||
PageNumInfo : {}, // Объект с ключом - номером страницы, значением - информация о нумерации
|
||
SectPr : {}, // Объект с ключом - номером страницы и полем - ссылкой на секцию
|
||
LastPage : -1, // Номер страницы, которая была пересчитана последней
|
||
RequestedPage : -1, // Страница, которую хотели сделать текущей, но не смогли, т.к. она была не пересчитана
|
||
InProgress : false // Запущен ли в данны момент пересчет данного колонтитула
|
||
};
|
||
|
||
this.PageCountElements = [];
|
||
|
||
// Добавляем данный класс в таблицу Id (обязательно в конце конструктора)
|
||
AscCommon.g_oTableId.Add( this, this.Id );
|
||
}
|
||
|
||
CHeaderFooter.prototype =
|
||
{
|
||
Get_Id : function()
|
||
{
|
||
return this.Id;
|
||
},
|
||
|
||
|
||
Get_Theme: function()
|
||
{
|
||
return this.LogicDocument.Get_Theme();
|
||
},
|
||
|
||
Get_ColorMap: function()
|
||
{
|
||
return this.LogicDocument.Get_ColorMap();
|
||
},
|
||
|
||
Copy : function(oLogicDocument, oCopyPr)
|
||
{
|
||
if (!oLogicDocument)
|
||
oLogicDocument = this.LogicDocument;
|
||
|
||
var oNewHdrFtr = new CHeaderFooter(oLogicDocument.GetHdrFtr(), oLogicDocument, oLogicDocument.GetDrawingDocument(), this.Type);
|
||
oNewHdrFtr.Content.Copy2(this.Content, oCopyPr);
|
||
return oNewHdrFtr;
|
||
},
|
||
|
||
Set_Page : function(Page_abs)
|
||
{
|
||
if (this.IsRecalculateInProgress())
|
||
return;
|
||
|
||
if (Page_abs > this.RecalcInfo.LastPage)
|
||
{
|
||
this.RecalcInfo.RequestedPage = Page_abs;
|
||
return;
|
||
}
|
||
|
||
if (Page_abs !== this.RecalcInfo.CurPage && undefined !== this.LogicDocument.Pages[Page_abs])
|
||
{
|
||
// Возможна ситуация, когда у нас колонтитул был рассчитан для заданной страницы, но на ней сейчас данный
|
||
// колонтитул не используется. Запрещаем менять у данного колонтитула текущую страницу на заданную.
|
||
var HdrFtrController = this.Parent;
|
||
var HdrFtrPage = this.Parent.Pages[Page_abs];
|
||
if ( undefined === HdrFtrPage || ( this !== HdrFtrPage.Header && this !== HdrFtrPage.Footer ) )
|
||
return;
|
||
|
||
var RecalcObj = this.RecalcInfo.RecalcObj[Page_abs];
|
||
if ( undefined !== RecalcObj )
|
||
{
|
||
this.RecalcInfo.CurPage = Page_abs;
|
||
this.Content.LoadRecalculateObject( RecalcObj );
|
||
}
|
||
}
|
||
},
|
||
|
||
SetPage : function(nPageAbs)
|
||
{
|
||
this.Set_Page(nPageAbs);
|
||
},
|
||
|
||
GetPage : function()
|
||
{
|
||
return this.RecalcInfo.CurPage;
|
||
},
|
||
|
||
Is_NeedRecalculate : function(PageAbs)
|
||
{
|
||
var PageNumInfo = this.LogicDocument.Get_SectionPageNumInfo(PageAbs);
|
||
|
||
if (true !== this.RecalcInfo.NeedRecalc[PageAbs] && true === PageNumInfo.Compare(this.RecalcInfo.PageNumInfo[PageAbs]) && undefined !== this.RecalcInfo.RecalcObj[PageAbs])
|
||
return false;
|
||
|
||
return true;
|
||
},
|
||
|
||
OnStartRecalculate : function()
|
||
{
|
||
this.RecalcInfo.InProgress = true;
|
||
},
|
||
|
||
OnEndRecalculate : function()
|
||
{
|
||
this.RecalcInfo.InProgress = false;
|
||
},
|
||
|
||
IsRecalculateInProgress : function()
|
||
{
|
||
return this.RecalcInfo.InProgress;
|
||
},
|
||
|
||
Recalculate : function(Page_abs, SectPr)
|
||
{
|
||
if (this.IsRecalculateInProgress())
|
||
return;
|
||
|
||
this.OnStartRecalculate();
|
||
|
||
// Логика пересчета колонтитулов следующая:
|
||
// 1. При пересчете страницы каждый раз пересчитывается колонтитул (всмысле заходим в функцию Recalculate,т.е. сюда)
|
||
// 2. Далее мы смотрим, нужно ли вообще пересчитывать данную страницу RecalcInfo.NeedRecalc[Page_abs] если это значение
|
||
// не false, тогда пересчитывать нужно, а если нет, тогда выходим
|
||
// 3. Если нужно пересчитывать, пересчитываем заново и смотрим, изменились ли границы пересчета и позиции плавающих
|
||
// картинок, и выставляем RecalcInfo.NeedRecalc[Page_abs] = false.
|
||
|
||
var bChanges = false;
|
||
var RecalcObj = this.RecalcInfo.RecalcObj[Page_abs];
|
||
|
||
var OldSumH = 0;
|
||
var OldBounds = null;
|
||
var OldFlowPos = [];
|
||
|
||
if ( undefined === RecalcObj )
|
||
bChanges = true;
|
||
else
|
||
{
|
||
OldSumH = RecalcObj.GetSummaryHeight();
|
||
OldBounds = RecalcObj.Get_PageBounds(0);
|
||
RecalcObj.Get_DrawingFlowPos( OldFlowPos );
|
||
}
|
||
|
||
// Пересчитаем заново данный колонтитул
|
||
this.Content.Set_StartPage( Page_abs );
|
||
this.Content.PrepareRecalculateObject();
|
||
|
||
this.Clear_PageCountElements();
|
||
this.LogicDocument.GetDrawingObjects().resetHdrFtrDrawingArrays(Page_abs);
|
||
|
||
this.RecalculateDrawingsWithFields();
|
||
|
||
var CurPage = 0;
|
||
var RecalcResult = recalcresult2_NextPage;
|
||
while (recalcresult2_End !== RecalcResult)
|
||
{
|
||
RecalcResult = this.Content.Recalculate_Page(CurPage, true);
|
||
if (RecalcResult !== recalcresult2_CurPage)
|
||
++CurPage;
|
||
}
|
||
|
||
this.RecalcInfo.RecalcObj[Page_abs] = this.Content.SaveRecalculateObject();
|
||
this.RecalcInfo.PageNumInfo[Page_abs] = this.LogicDocument.Get_SectionPageNumInfo(Page_abs);
|
||
this.RecalcInfo.SectPr[Page_abs] = SectPr;
|
||
this.RecalcInfo.NeedRecalc[Page_abs] = false;
|
||
this.RecalcInfo.LastPage = Page_abs;
|
||
|
||
// Если у нас до этого был какой-то пересчет, тогда сравним его с текущим.
|
||
// 1. Сравним границы: у верхнего колонтитула смотрим на изменение нижней границы, а нижнего - верхней
|
||
// 2. Сравним положение и размер Flow-объектов
|
||
|
||
if ( false === bChanges )
|
||
{
|
||
var NewBounds = this.Content.Get_PageBounds( 0 );
|
||
if ( ( Math.abs(NewBounds.Bottom - OldBounds.Bottom) > 0.001 && hdrftr_Header === this.Type ) || ( Math.abs(NewBounds.Top - OldBounds.Top) > 0.001 && hdrftr_Footer === this.Type ) )
|
||
bChanges = true;
|
||
}
|
||
|
||
if ( false === bChanges )
|
||
{
|
||
var NewFlowPos = [];
|
||
var AllDrawingObjects = this.Content.GetAllDrawingObjects();
|
||
var Count = AllDrawingObjects.length;
|
||
|
||
for ( var Index = 0; Index < Count; Index++ )
|
||
{
|
||
var Obj = AllDrawingObjects[Index];
|
||
if ( drawing_Anchor === Obj.Get_DrawingType() && true === Obj.Use_TextWrap() )
|
||
{
|
||
var oDistance = Obj.Get_Distance();
|
||
var FlowPos =
|
||
{
|
||
X : Obj.X - oDistance.L,
|
||
Y : Obj.Y - oDistance.T,
|
||
W : Obj.Width + oDistance.R,
|
||
H : Obj.Height + oDistance.B
|
||
};
|
||
|
||
NewFlowPos.push( FlowPos );
|
||
}
|
||
}
|
||
|
||
Count = NewFlowPos.length;
|
||
if ( Count != OldFlowPos.length )
|
||
bChanges = true;
|
||
else
|
||
{
|
||
for ( var Index = 0; Index < Count; Index++ )
|
||
{
|
||
var OldObj = OldFlowPos[Index];
|
||
var NewObj = NewFlowPos[Index];
|
||
if ( Math.abs(OldObj.X - NewObj.X) > 0.001 || Math.abs(OldObj.Y - NewObj.Y) > 0.001 || Math.abs(OldObj.H - NewObj.H) > 0.001 || Math.abs(OldObj.W - NewObj.W) > 0.001 )
|
||
{
|
||
bChanges = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if ( false === bChanges )
|
||
{
|
||
var NewSumH = this.Content.GetSummaryHeight();
|
||
if ( Math.abs( OldSumH - NewSumH ) > 0.001 )
|
||
bChanges = true;
|
||
}
|
||
|
||
// Ежели текущая страница не задана, тогда выставляем ту, которая оказалась пересчитанной первой. В противном
|
||
// случае, выставляем рассчет страницы, которая была до этого.
|
||
if (-1 === this.RecalcInfo.CurPage
|
||
|| false === this.LogicDocument.Get_SectionPageNumInfo(this.RecalcInfo.CurPage).Compare(this.RecalcInfo.PageNumInfo[this.RecalcInfo.CurPage])
|
||
|| (-1 !== this.RecalcInfo.RequestedPage && this.RecalcInfo.RequestedPage === Page_abs))
|
||
{
|
||
this.RecalcInfo.CurPage = Page_abs;
|
||
|
||
if (docpostype_HdrFtr === this.LogicDocument.GetDocPosType())
|
||
{
|
||
// Обновляем интерфейс, чтобы обновить настройки колонтитула, т.к. мы могли попасть в новую секцию
|
||
this.LogicDocument.UpdateSelection();
|
||
this.LogicDocument.UpdateInterface();
|
||
|
||
if (-1 !== this.RecalcInfo.RequestedPage && this.RecalcInfo.RequestedPage === Page_abs)
|
||
{
|
||
this.LogicDocument.NeedUpdateTarget = true;
|
||
this.RecalcInfo.RequestedPage = -1;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var RecalcObj = this.RecalcInfo.RecalcObj[this.RecalcInfo.CurPage];
|
||
this.Content.LoadRecalculateObject( RecalcObj );
|
||
}
|
||
|
||
this.OnEndRecalculate();
|
||
|
||
return bChanges;
|
||
},
|
||
|
||
RecalculateContent : function(nPageAbs)
|
||
{
|
||
if (this.IsRecalculateInProgress())
|
||
return;
|
||
|
||
this.OnStartRecalculate();
|
||
|
||
this.Content.Set_StartPage(nPageAbs);
|
||
this.Content.PrepareRecalculateObject();
|
||
|
||
var curPage = 0;
|
||
var recalcResult = recalcresult2_NextPage;
|
||
while (recalcresult2_End !== recalcResult)
|
||
{
|
||
recalcResult = this.Content.Recalculate_Page(curPage, true);
|
||
if (recalcResult === recalcresult2_NextPage)
|
||
++curPage;
|
||
}
|
||
|
||
this.OnEndRecalculate();
|
||
},
|
||
|
||
RecalculateDrawingsWithFields : function()
|
||
{
|
||
let drawings = this.Content.GetAllDrawingObjects();
|
||
for (let i = 0; i < drawings.length; ++i)
|
||
{
|
||
let graphicObj = drawings[i].GraphicObj;
|
||
let docContent = graphicObj ? graphicObj.getDocContent() : null;
|
||
if (docContent
|
||
&& AscWord.HdrFtrFieldChecker.check(docContent)
|
||
&& graphicObj.recalcText
|
||
&& graphicObj.recalculateText)
|
||
{
|
||
// fields can be in a calculated table
|
||
docContent.Reset_RecalculateCache();
|
||
graphicObj.recalcText();
|
||
graphicObj.recalculateText();
|
||
}
|
||
}
|
||
},
|
||
|
||
Reset_RecalculateCache : function()
|
||
{
|
||
this.Refresh_RecalcData2();
|
||
this.Content.Reset_RecalculateCache();
|
||
},
|
||
|
||
Get_Styles : function()
|
||
{
|
||
return this.LogicDocument.Get_Styles();
|
||
},
|
||
|
||
Get_TableStyleForPara : function()
|
||
{
|
||
return null;
|
||
},
|
||
|
||
Get_ShapeStyleForPara: function()
|
||
{
|
||
return null;
|
||
},
|
||
|
||
|
||
Get_TextBackGroundColor : function()
|
||
{
|
||
return undefined;
|
||
},
|
||
|
||
GetPageContentFrame : function()
|
||
{
|
||
return {
|
||
X : this.Content.X,
|
||
Y : 0,
|
||
XLimit : this.Content.XLimit,
|
||
YLimit : 0
|
||
};
|
||
},
|
||
|
||
Set_CurrentElement : function(bUpdateStates, PageAbs)
|
||
{
|
||
var PageIndex = -1;
|
||
|
||
if (undefined !== PageAbs && null !== PageAbs && this.Parent.Pages[PageAbs])
|
||
{
|
||
if ((this === this.Parent.Pages[PageAbs].Header || this === this.Parent.Pages[PageAbs].Footer))
|
||
PageIndex = PageAbs;
|
||
}
|
||
|
||
if (-1 === PageIndex)
|
||
{
|
||
for (var Key in this.Parent.Pages)
|
||
{
|
||
var PIndex = Key | 0;
|
||
if ((this === this.Parent.Pages[PIndex].Header || this === this.Parent.Pages[PIndex].Footer) && (-1 === PageIndex || PageIndex > PIndex))
|
||
PageIndex = PIndex;
|
||
}
|
||
}
|
||
|
||
this.Parent.CurHdrFtr = this;
|
||
this.Parent.WaitMouseDown = true;
|
||
this.Parent.CurPage = PageIndex;
|
||
|
||
if (-1 === PageIndex)
|
||
this.RecalcInfo.CurPage = -1;
|
||
|
||
var OldDocPosType = this.LogicDocument.GetDocPosType();
|
||
this.LogicDocument.SetDocPosType(docpostype_HdrFtr);
|
||
|
||
if (true === bUpdateStates && -1 !== PageIndex)
|
||
{
|
||
this.Set_Page(PageIndex);
|
||
|
||
this.LogicDocument.Document_UpdateInterfaceState();
|
||
this.LogicDocument.Document_UpdateRulersState();
|
||
this.LogicDocument.Document_UpdateSelectionState();
|
||
}
|
||
|
||
if (docpostype_HdrFtr !== OldDocPosType)
|
||
{
|
||
this.DrawingDocument.ClearCachePages();
|
||
this.DrawingDocument.FirePaint();
|
||
}
|
||
},
|
||
|
||
IsThisElementCurrent : function()
|
||
{
|
||
if (this === this.Parent.CurHdrFtr && docpostype_HdrFtr === this.LogicDocument.GetDocPosType())
|
||
return true;
|
||
|
||
return false;
|
||
},
|
||
|
||
Reset : function(X,Y, XLimit, YLimit)
|
||
{
|
||
this.Content.Reset( X, Y, XLimit, YLimit );
|
||
},
|
||
|
||
Draw : function(nPageIndex, pGraphics)
|
||
{
|
||
this.Content.Draw( nPageIndex, pGraphics );
|
||
},
|
||
|
||
OnContentReDraw : function(StartPage, EndPage)
|
||
{
|
||
this.DrawingDocument.ClearCachePages();
|
||
this.DrawingDocument.FirePaint();
|
||
},
|
||
|
||
RecalculateCurPos : function()
|
||
{
|
||
if (-1 !== this.RecalcInfo.CurPage)
|
||
return this.Content.RecalculateCurPos();
|
||
|
||
this.DrawingDocument.UpdateTarget(0, 0, this.Content.GetAbsoluteStartPage());
|
||
return null;
|
||
},
|
||
|
||
Get_NearestPos : function(X, Y, bAnchor, Drawing)
|
||
{
|
||
return this.Content.Get_NearestPos(0, X, Y, bAnchor, Drawing);
|
||
},
|
||
|
||
Get_Numbering : function()
|
||
{
|
||
return this.LogicDocument.Get_Numbering();
|
||
},
|
||
|
||
Get_Bounds : function()
|
||
{
|
||
return this.Content.Get_PageBounds(0);
|
||
},
|
||
|
||
Get_DividingLine : function(PageIndex)
|
||
{
|
||
var OldPage = this.RecalcInfo.CurPage;
|
||
|
||
this.Set_Page( PageIndex );
|
||
var Bounds = this.Get_Bounds();
|
||
|
||
if ( -1 !== OldPage )
|
||
this.Set_Page( OldPage );
|
||
|
||
if ( hdrftr_Footer === this.Type )
|
||
return Bounds.Top;
|
||
else
|
||
return Bounds.Bottom;
|
||
},
|
||
|
||
Is_PointInDrawingObjects : function(X, Y)
|
||
{
|
||
return this.Content.Is_PointInDrawingObjects( X, Y, this.Content.GetAbsoluteStartPage() );
|
||
},
|
||
|
||
Is_PointInFlowTable : function(X, Y)
|
||
{
|
||
return this.Content.Is_PointInFlowTable(X, Y, this.Content.GetAbsoluteStartPage());
|
||
},
|
||
|
||
CheckRange : function(X0, Y0, X1, Y1, _Y0, _Y1, X_lf, X_rf, bMathWrap)
|
||
{
|
||
return this.Content.CheckRange( X0, Y0, X1, Y1, _Y0, _Y1, X_lf, X_rf, 0, false, bMathWrap );
|
||
},
|
||
|
||
AddPageNum : function(nAlign)
|
||
{
|
||
var StyleId = null;
|
||
if (this.Type === hdrftr_Header)
|
||
StyleId = this.Get_Styles().Get_Default_Header();
|
||
else
|
||
StyleId = this.Get_Styles().Get_Default_Footer();
|
||
|
||
this.Content.SetHdrFtrPageNum(nAlign, StyleId);
|
||
},
|
||
|
||
IsCell : function(isReturnCell)
|
||
{
|
||
if (true === isReturnCell)
|
||
return null;
|
||
|
||
return false;
|
||
},
|
||
|
||
Check_AutoFit : function()
|
||
{
|
||
return false;
|
||
},
|
||
|
||
IsHdrFtr : function(bReturnHdrFtr)
|
||
{
|
||
if (true === bReturnHdrFtr)
|
||
return this;
|
||
|
||
return true;
|
||
},
|
||
|
||
IsFootnote : function(bReturnFootnote)
|
||
{
|
||
return (bReturnFootnote ? null : false);
|
||
},
|
||
|
||
Get_ParentTextTransform : function()
|
||
{
|
||
return null;
|
||
},
|
||
|
||
Is_DrawingShape : function(bRetShape)
|
||
{
|
||
if(bRetShape === true)
|
||
{
|
||
return null;
|
||
}
|
||
return false;
|
||
},
|
||
|
||
Is_TopDocument : function(bReturnTopDocument)
|
||
{
|
||
if ( true === bReturnTopDocument )
|
||
return this.Content;
|
||
|
||
return true;
|
||
},
|
||
|
||
IsInTable : function(bReturnTopTable)
|
||
{
|
||
if ( true === bReturnTopTable )
|
||
return null;
|
||
|
||
return false;
|
||
},
|
||
|
||
IsSelectionUse : function()
|
||
{
|
||
return this.Content.IsSelectionUse();
|
||
},
|
||
|
||
IsNumberingSelection : function()
|
||
{
|
||
return this.Content.IsNumberingSelection();
|
||
},
|
||
|
||
IsTextSelectionUse : function()
|
||
{
|
||
return this.Content.IsTextSelectionUse();
|
||
},
|
||
|
||
IsUseInDocument : function(Id)
|
||
{
|
||
if ( null != this.Parent )
|
||
return this.Parent.IsUseInDocument(this.Get_Id());
|
||
|
||
return false;
|
||
},
|
||
|
||
Check_Page : function(PageIndex)
|
||
{
|
||
return this.Parent.Check_Page( this, PageIndex );
|
||
},
|
||
|
||
GetCurPosXY : function()
|
||
{
|
||
return this.Content.GetCurPosXY();
|
||
},
|
||
|
||
GetSelectedText : function(bClearText, oPr)
|
||
{
|
||
return this.Content.GetSelectedText(bClearText, oPr);
|
||
},
|
||
|
||
GetSelectedElementsInfo : function(Info)
|
||
{
|
||
this.Content.GetSelectedElementsInfo(Info);
|
||
},
|
||
|
||
GetSelectedContent : function(SelectedContent)
|
||
{
|
||
this.Content.GetSelectedContent(SelectedContent);
|
||
},
|
||
|
||
UpdateCursorType : function(X, Y, PageAbs)
|
||
{
|
||
if (PageAbs !== this.Content.GetAbsoluteStartPage())
|
||
this.DrawingDocument.SetCursorType("text", new AscCommon.CMouseMoveData());
|
||
else
|
||
return this.Content.UpdateCursorType(X, Y, 0);
|
||
},
|
||
|
||
IsTableBorder : function(X, Y, PageAbs)
|
||
{
|
||
this.Set_Page(PageAbs);
|
||
return this.Content.IsTableBorder(X, Y, 0);
|
||
},
|
||
|
||
IsInText : function(X, Y, PageAbs)
|
||
{
|
||
this.Set_Page(PageAbs);
|
||
return this.Content.IsInText(X, Y, 0);
|
||
},
|
||
|
||
IsInDrawing : function(X, Y, PageAbs)
|
||
{
|
||
this.Set_Page(PageAbs);
|
||
return this.Content.IsInDrawing(X, Y, 0);
|
||
},
|
||
|
||
Document_UpdateInterfaceState : function()
|
||
{
|
||
this.Content.Document_UpdateInterfaceState();
|
||
},
|
||
|
||
Document_UpdateRulersState : function()
|
||
{
|
||
if ( -1 === this.RecalcInfo.CurPage )
|
||
return;
|
||
|
||
var SectPr = this.LogicDocument.Pages[this.RecalcInfo.CurPage].GetFirstSectPr();
|
||
var Bounds = this.Get_Bounds();
|
||
|
||
// нужно обновить линейку
|
||
if ( this.Type === hdrftr_Header )
|
||
{
|
||
this.DrawingDocument.Set_RulerState_HdrFtr( true, Bounds.Top, Math.max( Bounds.Bottom, SectPr.GetPageMarginTop() ) );
|
||
}
|
||
else
|
||
{
|
||
this.DrawingDocument.Set_RulerState_HdrFtr( false, Bounds.Top, SectPr.GetPageHeight() );
|
||
}
|
||
|
||
this.Content.Document_UpdateRulersState( this.Content.GetAbsoluteStartPage() );
|
||
},
|
||
|
||
Document_UpdateSelectionState : function()
|
||
{
|
||
if (-1 === this.RecalcInfo.CurPage)
|
||
{
|
||
// Если колонтитул не рассчитан, либо данный колонтитул неиспользуется, тогда смещаемся к первой странице
|
||
this.DrawingDocument.TargetEnd();
|
||
this.DrawingDocument.SelectEnabled(false);
|
||
this.LogicDocument.NeedUpdateTarget = true;
|
||
return;
|
||
}
|
||
|
||
if ( docpostype_DrawingObjects == this.Content.CurPos.Type )
|
||
{
|
||
return this.LogicDocument.DrawingObjects.documentUpdateSelectionState();
|
||
}
|
||
else //if ( docpostype_Content === this.Content.CurPos.Type )
|
||
{
|
||
// Если у нас есть выделение, тогда убираем курсор и рисуем выделение.
|
||
// Если никакого выделения нет, тогда убираем его и восстанавливаем курсор.
|
||
if ( true === this.Content.IsSelectionUse() )
|
||
{
|
||
// Выделение нумерации
|
||
if ( selectionflag_Numbering == this.Content.Selection.Flag )
|
||
{
|
||
this.DrawingDocument.TargetEnd();
|
||
this.DrawingDocument.SelectEnabled(true);
|
||
this.DrawingDocument.SelectClear();
|
||
this.DrawingDocument.SelectShow();
|
||
}
|
||
// Обрабатываем движение границы у таблиц
|
||
else if ( null != this.Content.Selection.Data && true === this.Content.Selection.Data.TableBorder && type_Table == this.Content.Content[this.Content.Selection.Data.Pos].GetType() )
|
||
{
|
||
// Убираем курсор, если он был
|
||
this.DrawingDocument.TargetEnd();
|
||
}
|
||
else
|
||
{
|
||
if ( false === this.Content.IsSelectionEmpty() )
|
||
{
|
||
if (true !== this.Content.Selection.Start)
|
||
this.RecalculateCurPos();
|
||
|
||
this.DrawingDocument.TargetEnd();
|
||
this.DrawingDocument.SelectEnabled(true);
|
||
this.DrawingDocument.SelectClear();
|
||
this.DrawingDocument.SelectShow();
|
||
}
|
||
else
|
||
{
|
||
this.DrawingDocument.SelectEnabled(false);
|
||
this.RecalculateCurPos();
|
||
|
||
this.DrawingDocument.TargetStart();
|
||
this.DrawingDocument.TargetShow();
|
||
|
||
if (this.LogicDocument && this.LogicDocument.IsFillingFormMode())
|
||
{
|
||
var oContentControl = this.LogicDocument.GetContentControl();
|
||
if (oContentControl && oContentControl.IsCheckBox())
|
||
this.DrawingDocument.TargetEnd();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
this.DrawingDocument.SelectEnabled(false);
|
||
this.RecalculateCurPos();
|
||
|
||
this.DrawingDocument.TargetStart();
|
||
this.DrawingDocument.TargetShow();
|
||
|
||
if (this.LogicDocument && this.LogicDocument.IsFillingFormMode())
|
||
{
|
||
var oContentControl = this.LogicDocument.GetContentControl();
|
||
if (oContentControl && oContentControl.IsCheckBox())
|
||
this.DrawingDocument.TargetEnd();
|
||
}
|
||
}
|
||
}
|
||
},
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с контентом
|
||
//-----------------------------------------------------------------------------------
|
||
AddNewParagraph : function()
|
||
{
|
||
this.Content.AddNewParagraph();
|
||
},
|
||
|
||
AddInlineImage : function(W, H, Img, GraphicObject, bFlow)
|
||
{
|
||
this.Content.AddInlineImage(W,H,Img, GraphicObject, bFlow);
|
||
},
|
||
AddImages : function(aImages)
|
||
{
|
||
this.Content.AddImages(aImages);
|
||
},
|
||
AddSignatureLine : function(oSignatureDrawing)
|
||
{
|
||
this.Content.AddSignatureLine(oSignatureDrawing);
|
||
},
|
||
|
||
AddOleObject : function(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory)
|
||
{
|
||
return this.Content.AddOleObject(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory);
|
||
},
|
||
|
||
AddTextArt : function(nStyle)
|
||
{
|
||
this.Content.AddTextArt(nStyle);
|
||
},
|
||
LoadChartData : function(bNeedRecalculate)
|
||
{
|
||
this.Content.LoadChartData(bNeedRecalculate);
|
||
},
|
||
EditChart : function(Chart)
|
||
{
|
||
this.Content.EditChart( Chart );
|
||
},
|
||
UpdateChart : function(Chart)
|
||
{
|
||
this.Content.UpdateChart( Chart );
|
||
},
|
||
OpenChartEditor : function()
|
||
{
|
||
this.Content.OpenChartEditor();
|
||
},
|
||
GetChartSettings : function()
|
||
{
|
||
return this.Content.GetChartSettings();
|
||
},
|
||
ApplyChartSettings : function(oChartSettings)
|
||
{
|
||
return this.Content.ApplyChartSettings( oChartSettings );
|
||
},
|
||
|
||
AddInlineTable : function(nCols, nRows, nMode)
|
||
{
|
||
return this.Content.AddInlineTable(nCols, nRows, nMode);
|
||
},
|
||
|
||
AddToParagraph : function(ParaItem, bRecalculate)
|
||
{
|
||
this.Content.AddToParagraph(ParaItem, bRecalculate);
|
||
},
|
||
|
||
ClearParagraphFormatting : function(isClearParaPr, isClearTextPr)
|
||
{
|
||
this.Content.ClearParagraphFormatting(isClearParaPr, isClearTextPr);
|
||
},
|
||
|
||
PasteFormatting : function(oData)
|
||
{
|
||
this.Content.PasteFormatting(oData);
|
||
},
|
||
|
||
Remove : function(Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord)
|
||
{
|
||
this.Content.Remove(Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord);
|
||
},
|
||
|
||
GetCursorPosXY : function()
|
||
{
|
||
return this.Content.GetCursorPosXY();
|
||
},
|
||
|
||
MoveCursorLeft : function(AddToSelect, Word)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorLeft(AddToSelect, Word);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorRight : function(AddToSelect, Word)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorRight(AddToSelect, Word);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorUp : function(AddToSelect)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorUp(AddToSelect);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorDown : function(AddToSelect)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorDown(AddToSelect);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorToEndOfLine : function(AddToSelect)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorToEndOfLine(AddToSelect);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorToStartOfLine : function(AddToSelect)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorToStartOfLine(AddToSelect);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorToStartPos : function(AddToSelect)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorToStartPos(AddToSelect);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorToEndPos : function(AddToSelect)
|
||
{
|
||
var bRetValue = this.Content.MoveCursorToEndPos(AddToSelect);
|
||
|
||
this.Document_UpdateInterfaceState();
|
||
this.Document_UpdateRulersState();
|
||
|
||
return bRetValue;
|
||
},
|
||
|
||
MoveCursorToXY : function(X, Y, PageIndex, AddToSelect, bRemoveOldSelection)
|
||
{
|
||
this.Set_Page(PageIndex);
|
||
return this.Content.MoveCursorToXY(X, Y, AddToSelect, bRemoveOldSelection, PageIndex);
|
||
},
|
||
|
||
MoveCursorToCell : function(bNext)
|
||
{
|
||
this.Content.MoveCursorToCell(bNext);
|
||
},
|
||
|
||
SetParagraphAlign : function(Align)
|
||
{
|
||
return this.Content.SetParagraphAlign(Align);
|
||
},
|
||
|
||
SetParagraphSpacing : function(Spacing)
|
||
{
|
||
return this.Content.SetParagraphSpacing(Spacing);
|
||
},
|
||
|
||
SetParagraphIndent : function(Ind)
|
||
{
|
||
return this.Content.SetParagraphIndent(Ind);
|
||
},
|
||
|
||
SetParagraphShd : function(Shd)
|
||
{
|
||
return this.Content.SetParagraphShd(Shd);
|
||
},
|
||
|
||
SetParagraphStyle : function(Name)
|
||
{
|
||
return this.Content.SetParagraphStyle(Name);
|
||
},
|
||
|
||
SetParagraphTabs : function(Tabs)
|
||
{
|
||
return this.Content.SetParagraphTabs(Tabs);
|
||
},
|
||
|
||
SetParagraphContextualSpacing : function(Value)
|
||
{
|
||
return this.Content.SetParagraphContextualSpacing(Value);
|
||
},
|
||
|
||
SetParagraphPageBreakBefore : function(Value)
|
||
{
|
||
return this.Content.SetParagraphPageBreakBefore(Value);
|
||
},
|
||
|
||
SetParagraphKeepLines : function(Value)
|
||
{
|
||
return this.Content.SetParagraphKeepLines(Value);
|
||
},
|
||
|
||
SetParagraphKeepNext : function(Value)
|
||
{
|
||
return this.Content.SetParagraphKeepNext(Value);
|
||
},
|
||
|
||
SetParagraphWidowControl : function(Value)
|
||
{
|
||
return this.Content.SetParagraphWidowControl(Value);
|
||
},
|
||
|
||
SetParagraphBorders : function(Value)
|
||
{
|
||
return this.Content.SetParagraphBorders(Value);
|
||
},
|
||
|
||
IncreaseDecreaseFontSize : function(bIncrease)
|
||
{
|
||
return this.Content.IncreaseDecreaseFontSize(bIncrease);
|
||
},
|
||
|
||
IncreaseDecreaseIndent : function(bIncrease)
|
||
{
|
||
return this.Content.IncreaseDecreaseIndent(bIncrease);
|
||
},
|
||
|
||
SetImageProps : function(Props)
|
||
{
|
||
return this.Content.SetImageProps(Props);
|
||
},
|
||
|
||
SetTableProps : function(Props)
|
||
{
|
||
return this.Content.SetTableProps(Props);
|
||
},
|
||
|
||
GetCalculatedParaPr : function()
|
||
{
|
||
return this.Content.GetCalculatedParaPr();
|
||
},
|
||
|
||
GetCalculatedTextPr : function()
|
||
{
|
||
return this.Content.GetCalculatedTextPr(true);
|
||
},
|
||
|
||
GetDirectTextPr : function()
|
||
{
|
||
return this.Content.GetDirectTextPr();
|
||
},
|
||
|
||
GetDirectParaPr : function()
|
||
{
|
||
return this.Content.GetDirectParaPr();
|
||
},
|
||
|
||
GetAllParagraphs : function(Props, ParaArray)
|
||
{
|
||
return this.Content.GetAllParagraphs(Props, ParaArray);
|
||
},
|
||
|
||
GetAllTables : function(oProps, arrTables)
|
||
{
|
||
return this.Content.GetAllTables(oProps, arrTables);
|
||
},
|
||
|
||
GetAllDrawingObjects : function(arrDrawings)
|
||
{
|
||
return this.Content.GetAllDrawingObjects(arrDrawings);
|
||
},
|
||
|
||
UpdateBookmarks : function(oBookmarkManager)
|
||
{
|
||
this.Content.UpdateBookmarks(oBookmarkManager);
|
||
},
|
||
|
||
GetPrevElementEndInfo : function(CurElement)
|
||
{
|
||
return null;
|
||
},
|
||
|
||
RemoveSelection : function(bNoCheckDrawing)
|
||
{
|
||
return this.Content.RemoveSelection(bNoCheckDrawing);
|
||
},
|
||
|
||
DrawSelectionOnPage : function(CurPage)
|
||
{
|
||
if (CurPage !== this.GetPage())
|
||
return;
|
||
|
||
return this.Content.DrawSelectionOnPage(0);
|
||
},
|
||
|
||
Selection_SetStart : function(X,Y, PageIndex, MouseEvent)
|
||
{
|
||
this.Set_Page( PageIndex );
|
||
|
||
if (editor.isStartAddShape || editor.isInkDrawerOn())
|
||
{
|
||
this.Content.SetDocPosType(docpostype_DrawingObjects);
|
||
this.Content.Selection.Use = true;
|
||
this.Content.Selection.Start = true;
|
||
|
||
let oDrawingObjects = this.LogicDocument.DrawingObjects;
|
||
if(true === editor.isStartAddShape)
|
||
{
|
||
if(!oDrawingObjects.isPolylineAddition())
|
||
oDrawingObjects.startAddShape(editor.addShapePreset);
|
||
|
||
}
|
||
oDrawingObjects.OnMouseDown(MouseEvent, X, Y, PageIndex);
|
||
}
|
||
else
|
||
{
|
||
return this.Content.Selection_SetStart(X, Y, 0, MouseEvent);
|
||
}
|
||
},
|
||
|
||
Selection_SetEnd : function(X, Y, PageIndex, MouseEvent)
|
||
{
|
||
this.Set_Page( PageIndex );
|
||
return this.Content.Selection_SetEnd(X, Y, 0, MouseEvent);
|
||
},
|
||
|
||
IsMovingTableBorder : function()
|
||
{
|
||
return this.Content.IsMovingTableBorder();
|
||
},
|
||
|
||
CheckPosInSelection : function(X, Y, PageAbs, NearPos)
|
||
{
|
||
if (-1 === this.RecalcInfo.CurPage)
|
||
return false;
|
||
|
||
var HdrFtrPage = this.Content.GetAbsoluteStartPage();
|
||
if (undefined !== NearPos || HdrFtrPage === PageAbs)
|
||
return this.Content.CheckPosInSelection(X, Y, 0, NearPos);
|
||
|
||
return false;
|
||
},
|
||
|
||
SelectAll : function()
|
||
{
|
||
return this.Content.SelectAll();
|
||
},
|
||
|
||
GetCurrentParagraph : function(bIgnoreSelection, arrSelectedParagraphs)
|
||
{
|
||
return this.Content.GetCurrentParagraph(bIgnoreSelection, arrSelectedParagraphs);
|
||
},
|
||
|
||
GetCurrentTablesStack : function(arrTables)
|
||
{
|
||
return this.Content.GetCurrentTablesStack(arrTables);
|
||
},
|
||
|
||
StartSelectionFromCurPos : function()
|
||
{
|
||
this.Content.StartSelectionFromCurPos();
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с номерами страниц
|
||
//-----------------------------------------------------------------------------------
|
||
GetAbsoluteStartPage : function()
|
||
{
|
||
return 0;
|
||
},
|
||
|
||
GetRelativeStartPage : function()
|
||
{
|
||
return 0;
|
||
},
|
||
|
||
GetAbsolutePage : function(CurPage)
|
||
{
|
||
return CurPage;
|
||
},
|
||
|
||
GetAbsoluteColumn : function(CurPage)
|
||
{
|
||
return 0;
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с таблицами
|
||
//-----------------------------------------------------------------------------------
|
||
AddTableRow : function(bBefore, nCount)
|
||
{
|
||
this.Content.AddTableRow(bBefore, nCount);
|
||
},
|
||
|
||
AddTableColumn : function(bBefore, nCount)
|
||
{
|
||
this.Content.AddTableColumn(bBefore, nCount);
|
||
},
|
||
|
||
RemoveTableRow : function()
|
||
{
|
||
this.Content.RemoveTableRow();
|
||
},
|
||
|
||
RemoveTableColumn : function()
|
||
{
|
||
this.Content.RemoveTableColumn();
|
||
},
|
||
|
||
MergeTableCells : function()
|
||
{
|
||
this.Content.MergeTableCells();
|
||
},
|
||
|
||
SplitTableCells : function(Cols, Rows)
|
||
{
|
||
this.Content.SplitTableCells(Cols, Rows);
|
||
},
|
||
|
||
RemoveTableCells : function()
|
||
{
|
||
this.Content.RemoveTableCells();
|
||
},
|
||
|
||
RemoveTable : function()
|
||
{
|
||
this.Content.RemoveTable();
|
||
},
|
||
|
||
SelectTable : function(Type)
|
||
{
|
||
this.Content.SelectTable(Type);
|
||
},
|
||
|
||
CanMergeTableCells : function()
|
||
{
|
||
return this.Content.CanMergeTableCells();
|
||
},
|
||
|
||
CanSplitTableCells : function()
|
||
{
|
||
return this.Content.CanSplitTableCells();
|
||
},
|
||
|
||
CheckTableCoincidence : function(Table)
|
||
{
|
||
return false;
|
||
},
|
||
|
||
DistributeTableCells : function(isHorizontally)
|
||
{
|
||
return this.Content.DistributeTableCells(isHorizontally);
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Undo/Redo функции
|
||
//-----------------------------------------------------------------------------------
|
||
Get_ParentObject_or_DocumentPos : function()
|
||
{
|
||
return { Type : AscDFH.historyitem_recalctype_HdrFtr, Data : this };
|
||
},
|
||
|
||
Refresh_RecalcData : function(Data)
|
||
{
|
||
this.Refresh_RecalcData2();
|
||
},
|
||
|
||
Refresh_RecalcData2 : function()
|
||
{
|
||
// Сохраняем пересчитаные страницы в старый пересчет, а текущий обнуляем
|
||
this.RecalcInfo.PageNumInfo = {};
|
||
this.RecalcInfo.SectPr = {};
|
||
this.RecalcInfo.CurPage = -1;
|
||
this.RecalcInfo.NeedRecalc = {};
|
||
this.RecalcInfo.LastPage = -1;
|
||
this.RecalcInfo.RequestedPage = -1;
|
||
|
||
History.RecalcData_Add( { Type : AscDFH.historyitem_recalctype_HdrFtr, Data : this } );
|
||
},
|
||
|
||
Refresh_RecalcData_BySection : function(SectPr)
|
||
{
|
||
// Найдем среди пересчитанных страниц те, которые пересчитывались в заданной секции,
|
||
// и среди них найдем ключ с наименьшим номером. Далее, отметим все страницы с номером большим, чем найденный,
|
||
// как не пересчитанные.
|
||
|
||
var MinPageIndex = -1;
|
||
for ( var PageIndex in this.RecalcInfo.PageNumInfo )
|
||
{
|
||
if ( SectPr === this.RecalcInfo.SectPr[PageIndex] && ( -1 === MinPageIndex || PageIndex < MinPageIndex ) )
|
||
MinPageIndex = PageIndex;
|
||
}
|
||
|
||
for ( var PageIndex in this.RecalcInfo.PageNumInfo )
|
||
{
|
||
if ( PageIndex >= MinPageIndex )
|
||
{
|
||
delete this.RecalcInfo.PageNumInfo[PageIndex];
|
||
delete this.RecalcInfo.SectPr[PageIndex];
|
||
delete this.RecalcInfo.NeedRecalc[PageIndex];
|
||
}
|
||
}
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с гиперссылками
|
||
//-----------------------------------------------------------------------------------
|
||
AddHyperlink : function(HyperProps)
|
||
{
|
||
return this.Content.AddHyperlink(HyperProps);
|
||
},
|
||
|
||
ModifyHyperlink : function(HyperProps)
|
||
{
|
||
this.Content.ModifyHyperlink(HyperProps);
|
||
},
|
||
|
||
RemoveHyperlink : function()
|
||
{
|
||
this.Content.RemoveHyperlink();
|
||
},
|
||
|
||
CanAddHyperlink : function(bCheckInHyperlink)
|
||
{
|
||
return this.Content.CanAddHyperlink(bCheckInHyperlink);
|
||
},
|
||
|
||
IsCursorInHyperlink : function(bCheckEnd)
|
||
{
|
||
return this.Content.IsCursorInHyperlink(bCheckEnd);
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с генерацией карты шрифтов
|
||
//-----------------------------------------------------------------------------------
|
||
Document_CreateFontMap : function(FontMap)
|
||
{
|
||
this.Content.Document_CreateFontMap(FontMap);
|
||
},
|
||
|
||
Document_CrateFontCharMap : function(FontCharMap)
|
||
{
|
||
this.Content.Document_CreateFontCharMap( FontCharMap );
|
||
},
|
||
|
||
Document_Get_AllFontNames : function(AllFonts)
|
||
{
|
||
this.Content.Document_Get_AllFontNames(AllFonts);
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с совместным редактирования
|
||
//-----------------------------------------------------------------------------------
|
||
Write_ToBinary2 : function(Writer)
|
||
{
|
||
Writer.WriteLong( AscDFH.historyitem_type_HdrFtr );
|
||
|
||
// String : Id
|
||
// Long : Type
|
||
// String : Content Id
|
||
|
||
Writer.WriteString2( this.Id );
|
||
Writer.WriteLong( this.Type );
|
||
Writer.WriteString2( this.Content.Get_Id() );
|
||
},
|
||
|
||
Read_FromBinary2 : function(Reader)
|
||
{
|
||
// String : Id
|
||
// Long : Type
|
||
// String : Content Id
|
||
|
||
var LogicDocument = editor.WordControl.m_oLogicDocument;
|
||
|
||
this.Parent = LogicDocument.HdrFtr;
|
||
this.DrawingDocument = LogicDocument.DrawingDocument;
|
||
this.LogicDocument = LogicDocument;
|
||
|
||
this.Id = Reader.GetString2();
|
||
this.Type = Reader.GetLong();
|
||
|
||
this.Content = AscCommon.g_oTableId.Get_ById(Reader.GetString2());
|
||
this.Content.SetParent(this);
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с комментариями
|
||
//-----------------------------------------------------------------------------------
|
||
AddComment : function(Comment)
|
||
{
|
||
this.Content.AddComment(Comment, true, true);
|
||
},
|
||
|
||
CanAddComment : function()
|
||
{
|
||
return this.Content.CanAddComment();
|
||
}
|
||
};
|
||
CHeaderFooter.prototype.constructor = CHeaderFooter;
|
||
CHeaderFooter.prototype.UpdateContentToDefaults = function()
|
||
{
|
||
this.Content.ClearContent(true);
|
||
let oParagraph = this.Content.GetElement(0);
|
||
let oLogicDocument = this.LogicDocument;
|
||
if (!oLogicDocument || !oParagraph || !oParagraph.IsParagraph())
|
||
return;
|
||
|
||
let sStyleId = this.Type === hdrftr_Header ? oLogicDocument.GetStyles().Get_Default_Header() : oLogicDocument.GetStyles().Get_Default_Footer();
|
||
oParagraph.SetParagraphStyleById(sStyleId);
|
||
};
|
||
CHeaderFooter.prototype.GetSectionIndex = function()
|
||
{
|
||
if (!this.LogicDocument)
|
||
return -1;
|
||
|
||
return this.LogicDocument.SectionsInfo.Find_ByHdrFtr(this);
|
||
};
|
||
CHeaderFooter.prototype.GetSectionPr = function()
|
||
{
|
||
return this.Get_SectPr();
|
||
};
|
||
CHeaderFooter.prototype.Get_SectPr = function()
|
||
{
|
||
let sectionIndex = this.GetSectionIndex();
|
||
return (-1 !== sectionIndex ? this.LogicDocument.SectionsInfo.GetSectPrByIndex(sectionIndex) : null);
|
||
};
|
||
CHeaderFooter.prototype.SetParagraphFramePr = function(FramePr, bDelete)
|
||
{
|
||
return this.Content.SetParagraphFramePr(FramePr, bDelete);
|
||
};
|
||
CHeaderFooter.prototype.GetRevisionsChangeElement = function(SearchEngine)
|
||
{
|
||
return this.Content.GetRevisionsChangeElement(SearchEngine);
|
||
};
|
||
CHeaderFooter.prototype.GetSelectionBounds = function()
|
||
{
|
||
if (-1 !== this.RecalcInfo.CurPage)
|
||
return this.Content.GetSelectionBounds();
|
||
|
||
return null;
|
||
};
|
||
CHeaderFooter.prototype.Get_DocumentContent = function()
|
||
{
|
||
return this.Content;
|
||
};
|
||
CHeaderFooter.prototype.Add_PageCountElement = function(oElement)
|
||
{
|
||
for (var nIndex = 0, nCount = this.PageCountElements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
if (oElement == this.PageCountElements[nIndex])
|
||
return;
|
||
}
|
||
|
||
this.PageCountElements.push(oElement);
|
||
};
|
||
CHeaderFooter.prototype.Have_PageCountElement = function()
|
||
{
|
||
return this.PageCountElements.length > 0 ? true : false;
|
||
};
|
||
CHeaderFooter.prototype.Clear_PageCountElements = function()
|
||
{
|
||
this.PageCountElements = [];
|
||
};
|
||
CHeaderFooter.prototype.Update_PageCountElements = function(nPageCount)
|
||
{
|
||
for (var nIndex = 0, nCount = this.PageCountElements.length; nIndex < nCount; ++nIndex)
|
||
{
|
||
this.PageCountElements[nIndex].UpdatePageCount(nPageCount);
|
||
}
|
||
};
|
||
CHeaderFooter.prototype.ForceRecalculate = function(nPageAbs)
|
||
{
|
||
this.RecalcInfo.NeedRecalc[nPageAbs] = true;
|
||
};
|
||
CHeaderFooter.prototype.GetAllContentControls = function(arrContentControls)
|
||
{
|
||
return this.Content.GetAllContentControls(arrContentControls);
|
||
};
|
||
/**
|
||
* * Получаем класс, управляющий содержимым колонтитула
|
||
* @returns {CDocumentContent}
|
||
*/
|
||
CHeaderFooter.prototype.GetContent = function()
|
||
{
|
||
return this.Content;
|
||
};
|
||
/**
|
||
* Функция для выставления класса содержимого колонтитула (используется в совместке)
|
||
* @param {CDocumentContent} oDocumentContent
|
||
*/
|
||
CHeaderFooter.prototype.SetDocumentContent = function(oDocumentContent)
|
||
{
|
||
this.Content = oDocumentContent;
|
||
oDocumentContent.SetParent(this);
|
||
};
|
||
CHeaderFooter.prototype.FindWatermark = function()
|
||
{
|
||
var aAllDrawings = this.Content.GetAllDrawingObjects();
|
||
var oCandidate = null, oDrawing;
|
||
for(var i = aAllDrawings.length - 1; i > -1; --i)
|
||
{
|
||
oDrawing = aAllDrawings[i];
|
||
if(oDrawing.IsWatermark())
|
||
{
|
||
if(null === oCandidate)
|
||
{
|
||
oCandidate = oDrawing;
|
||
}
|
||
else
|
||
{
|
||
if(oCandidate.getDrawingArrayType() < oDrawing.getDrawingArrayType() || (typeof ComparisonByZIndexSimple !== undefined && ComparisonByZIndexSimple(oDrawing, oCandidate)))
|
||
{
|
||
oCandidate = oDrawing;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return oCandidate;
|
||
};
|
||
CHeaderFooter.prototype.GetAllTablesOnPage = function(nPageAbs, arrTables)
|
||
{
|
||
this.Set_Page(nPageAbs);
|
||
return this.Content.GetAllTablesOnPage(nPageAbs, arrTables);
|
||
};
|
||
CHeaderFooter.prototype.RestartSpellCheck = function()
|
||
{
|
||
this.Content.RestartSpellCheck();
|
||
};
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
// CHeaderFooter
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
CHeaderFooter.prototype.Search = function(oSearchEngine, nType)
|
||
{
|
||
this.Content.Search(oSearchEngine, nType);
|
||
};
|
||
CHeaderFooter.prototype.GetSearchElementId = function(bNext, bCurrent)
|
||
{
|
||
return this.Content.GetSearchElementId( bNext, bCurrent );
|
||
};
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
// Класс для работы с колонтитулами
|
||
//-----------------------------------------------------------------------------------
|
||
function CHeaderFooterController(LogicDocument, DrawingDocument)
|
||
{
|
||
this.Id = AscCommon.g_oIdCounter.Get_NewId();
|
||
|
||
this.DrawingDocument = DrawingDocument;
|
||
this.LogicDocument = LogicDocument;
|
||
|
||
// Текущий колонтитул
|
||
this.CurHdrFtr = null;
|
||
|
||
this.Pages = {};
|
||
this.CurPage = 0;
|
||
this.ChangeCurPageOnEnd = true;
|
||
|
||
this.WaitMouseDown = true;
|
||
|
||
this.Lock = new AscCommon.CLock();
|
||
|
||
// Добавляем данный класс в таблицу Id (обязательно в конце конструктора)
|
||
AscCommon.g_oTableId.Add( this, this.Id );
|
||
}
|
||
|
||
CHeaderFooterController.prototype =
|
||
{
|
||
Get_Id : function()
|
||
{
|
||
return this.Id;
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с колонтитулами
|
||
//-----------------------------------------------------------------------------------
|
||
GoTo_NextHdrFtr : function()
|
||
{
|
||
var CurHdrFtr = this.CurHdrFtr;
|
||
if (null === CurHdrFtr || -1 === CurHdrFtr.RecalcInfo.CurPage)
|
||
return;
|
||
|
||
var CurPage = CurHdrFtr.RecalcInfo.CurPage;
|
||
var Pages = this.Pages;
|
||
|
||
if (hdrftr_Header === CurHdrFtr.Type && undefined !== Pages[CurPage].Footer)
|
||
CurHdrFtr = Pages[CurPage].Footer;
|
||
else
|
||
CurHdrFtr = null;
|
||
|
||
while (null === CurHdrFtr)
|
||
{
|
||
CurPage++;
|
||
|
||
if (undefined === Pages[CurPage])
|
||
break;
|
||
else if (undefined !== Pages[CurPage].Header && null !== Pages[CurPage].Header)
|
||
CurHdrFtr = Pages[CurPage].Header;
|
||
else if (undefined !== Pages[CurPage].Footer && null !== Pages[CurPage].Footer)
|
||
CurHdrFtr = Pages[CurPage].Footer;
|
||
}
|
||
|
||
if (null !== CurHdrFtr)
|
||
{
|
||
this.CurHdrFtr = CurHdrFtr;
|
||
CurHdrFtr.Set_Page(CurPage);
|
||
CurHdrFtr.Content.MoveCursorToStartPos(false);
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
},
|
||
|
||
GoTo_PrevHdrFtr : function()
|
||
{
|
||
var CurHdrFtr = this.CurHdrFtr;
|
||
if (null === CurHdrFtr || -1 === CurHdrFtr.RecalcInfo.CurPage)
|
||
return;
|
||
|
||
var CurPage = CurHdrFtr.RecalcInfo.CurPage;
|
||
var Pages = this.Pages;
|
||
|
||
if (hdrftr_Footer === CurHdrFtr.Type && undefined !== Pages[CurPage].Header)
|
||
CurHdrFtr = Pages[CurPage].Header;
|
||
else
|
||
CurHdrFtr = null;
|
||
|
||
while (null === CurHdrFtr)
|
||
{
|
||
CurPage--;
|
||
|
||
if (undefined === Pages[CurPage])
|
||
return;
|
||
else if (undefined !== Pages[CurPage].Footer && null !== Pages[CurPage].Footer)
|
||
CurHdrFtr = Pages[CurPage].Footer;
|
||
else if (undefined !== Pages[CurPage].Header && null !== Pages[CurPage].Header)
|
||
CurHdrFtr = Pages[CurPage].Header;
|
||
}
|
||
|
||
if (null !== CurHdrFtr)
|
||
{
|
||
this.CurHdrFtr = CurHdrFtr;
|
||
CurHdrFtr.Set_Page(CurPage);
|
||
CurHdrFtr.Content.MoveCursorToStartPos(false);
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
},
|
||
|
||
Get_CurPage : function()
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.Content.GetAbsoluteStartPage();
|
||
|
||
return 0;
|
||
},
|
||
|
||
// Получаем своства колонтитула для интерфейса
|
||
Get_Props : function()
|
||
{
|
||
if ( null != this.CurHdrFtr && -1 !== this.CurHdrFtr.RecalcInfo.CurPage )
|
||
{
|
||
var Pr = {};
|
||
Pr.Type = this.CurHdrFtr.Type;
|
||
|
||
if ( undefined === this.LogicDocument.Pages[this.CurHdrFtr.RecalcInfo.CurPage] )
|
||
return Pr;
|
||
|
||
let SectPr = this.LogicDocument.Pages[this.CurHdrFtr.RecalcInfo.CurPage].GetFirstSectPr();
|
||
|
||
if ( hdrftr_Footer === Pr.Type )
|
||
Pr.Position = SectPr.GetPageMarginFooter();
|
||
else
|
||
Pr.Position = SectPr.GetPageMarginHeader();
|
||
|
||
Pr.DifferentFirst = SectPr.Get_TitlePage();
|
||
Pr.DifferentEvenOdd = EvenAndOddHeaders;
|
||
|
||
if ( SectPr === this.LogicDocument.SectionsInfo.GetSectPrByIndex(0) )
|
||
{
|
||
// У первой секции не может быть повторяющихся колонтитулов. Посылаем особое значение (null) в меню
|
||
Pr.LinkToPrevious = null;
|
||
}
|
||
else
|
||
{
|
||
// Определим тип колонтитула, в котором мы находимся
|
||
var PageIndex = this.CurHdrFtr.RecalcInfo.CurPage;
|
||
var SectionPageInfo = this.LogicDocument.Get_SectionPageNumInfo( PageIndex );
|
||
|
||
var bFirst = ( true === SectionPageInfo.bFirst && true === SectPr.Get_TitlePage() ? true : false );
|
||
var bEven = ( true === SectionPageInfo.bEven && true === EvenAndOddHeaders ? true : false );
|
||
var bHeader = ( hdrftr_Header === this.CurHdrFtr.Type ? true : false );
|
||
|
||
Pr.LinkToPrevious = ( null === SectPr.GetHdrFtr( bHeader, bFirst, bEven ) ? true : false );
|
||
}
|
||
|
||
Pr.Locked = this.Lock.Is_Locked();
|
||
|
||
Pr.StartPageNumber = SectPr.GetPageNumStart();
|
||
Pr.NumFormat = SectPr.GetPageNumFormat();
|
||
|
||
return Pr;
|
||
}
|
||
else
|
||
return null;
|
||
},
|
||
|
||
Set_CurHdrFtr_ById : function(Id)
|
||
{
|
||
let HdrFtr = AscCommon.g_oTableId.GetById(Id);
|
||
if (!HdrFtr || -1 === this.LogicDocument.SectionsInfo.Find_ByHdrFtr(HdrFtr))
|
||
return false;
|
||
|
||
this.CurHdrFtr = HdrFtr;
|
||
HdrFtr.Content.MoveCursorToStartPos();
|
||
|
||
return true;
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
//
|
||
//-----------------------------------------------------------------------------------
|
||
RecalculateCurPos : function(bUpdateX, bUpdateY, isUpdateTarget)
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.RecalculateCurPos(bUpdateX, bUpdateY, isUpdateTarget);
|
||
|
||
return null;
|
||
},
|
||
|
||
Recalculate : function(PageIndex)
|
||
{
|
||
let logicDocument = this.LogicDocument;
|
||
|
||
// Определим четность страницы и является ли она первой в данной секции. Заметим, что четность страницы
|
||
// отсчитывается от начала текущей секции и не зависит от настроек нумерации страниц для данной секции.
|
||
var SectionPageInfo = logicDocument.Get_SectionPageNumInfo( PageIndex );
|
||
|
||
var bFirst = SectionPageInfo.bFirst;
|
||
var bEven = SectionPageInfo.bEven;
|
||
|
||
// Запросим нужный нам колонтитул
|
||
var HdrFtr = logicDocument.Get_SectionHdrFtr( PageIndex, bFirst, bEven );
|
||
|
||
var Header = HdrFtr.Header;
|
||
var Footer = HdrFtr.Footer;
|
||
var SectPr = HdrFtr.SectPr;
|
||
|
||
this.Pages[PageIndex] = new CHdrFtrPage();
|
||
this.Pages[PageIndex].Header = Header;
|
||
this.Pages[PageIndex].Footer = Footer;
|
||
|
||
var oFrame = SectPr.GetContentFrame(PageIndex);
|
||
var X = oFrame.Left;
|
||
var XLimit = oFrame.Right;
|
||
|
||
let maxContentH = SectPr.GetPageHeight() / 2;
|
||
if (logicDocument.GetCompatibilityMode() >= AscCommon.document_compatibility_mode_Word15)
|
||
maxContentH = AscWord.MAX_MM_VALUE;
|
||
|
||
var bRecalcHeader = false;
|
||
|
||
var HeaderDrawings, HeaderTables, FooterDrawings, FooterTables;
|
||
// Рассчитываем верхний колонтитул
|
||
if ( null !== Header )
|
||
{
|
||
if ( true === Header.Is_NeedRecalculate( PageIndex ) )
|
||
{
|
||
var Y = SectPr.GetPageMarginHeader();
|
||
var YLimit = Y + maxContentH;
|
||
|
||
Header.Reset( X, Y, XLimit, YLimit );
|
||
bRecalcHeader = Header.Recalculate(PageIndex, SectPr);
|
||
}
|
||
else
|
||
{
|
||
if ( -1 === Header.RecalcInfo.CurPage )
|
||
Header.Set_Page(PageIndex);
|
||
}
|
||
HeaderDrawings = Header.Content.GetAllDrawingObjects([]);
|
||
HeaderTables = Header.Content.GetAllFloatElements();
|
||
}
|
||
|
||
var bRecalcFooter = false;
|
||
|
||
// Рассчитываем нижний колонтитул
|
||
if ( null !== Footer )
|
||
{
|
||
if ( true === Footer.Is_NeedRecalculate( PageIndex ) )
|
||
{
|
||
// Нижний колонтитул рассчитываем 2 раза. Сначала, с 0 позиции, чтобы рассчитать суммарную высоту колонитула.
|
||
// Исходя из уже известной высоты располагаем и рассчитываем колонтитул.
|
||
|
||
Footer.Reset( X, 0, XLimit, maxContentH );
|
||
Footer.RecalculateContent(PageIndex);
|
||
|
||
let contentBounds = Footer.Content.GetPageBounds(0);
|
||
let Y = Math.max(0, SectPr.GetPageHeight() - SectPr.GetPageMarginFooter() - (contentBounds.Bottom - contentBounds.Top));
|
||
|
||
Footer.Reset( X, Y, XLimit, Y + maxContentH );
|
||
bRecalcFooter = Footer.Recalculate(PageIndex, SectPr);
|
||
}
|
||
else
|
||
{
|
||
if ( -1 === Footer.RecalcInfo.CurPage )
|
||
Footer.Set_Page(PageIndex);
|
||
}
|
||
FooterDrawings = Footer.Content.GetAllDrawingObjects([]);
|
||
FooterTables = Footer.Content.GetAllFloatElements();
|
||
}
|
||
|
||
// Подправляем позиции автофигур с учетом возможно изменившихся границ колонтитулов. Делаем это для всех автофигур,
|
||
// потому что колонтитулы рассчитываются первыми на странице и внутри них нет обтекания.
|
||
let contentFrame = this.LogicDocument.GetPageContentFrame(PageIndex);
|
||
this.private_UpdateDrawingVerticalPositions(HeaderDrawings, contentFrame.Y, contentFrame.YLimit);
|
||
this.private_UpdateDrawingVerticalPositions(FooterDrawings, contentFrame.Y, contentFrame.YLimit);
|
||
|
||
this.private_MergeFlowObjectsFromHeaderAndFooter(PageIndex, HeaderDrawings, HeaderTables, FooterDrawings, FooterTables);
|
||
|
||
if ( true === bRecalcHeader || true === bRecalcFooter )
|
||
return true;
|
||
|
||
return false;
|
||
},
|
||
|
||
private_UpdateDrawingVerticalPositions : function(Drawings, HeaderY, FooterY)
|
||
{
|
||
if (Drawings)
|
||
{
|
||
for (var Index = 0, Count = Drawings.length; Index < Count; ++Index)
|
||
{
|
||
var Drawing = Drawings[Index];
|
||
Drawing.Update_PositionYHeaderFooter(HeaderY, FooterY);
|
||
}
|
||
}
|
||
},
|
||
|
||
private_MergeFlowObjectsFromHeaderAndFooter : function(nPageIndex, arrHeaderDrawings, arrHeaderTables, arrFooterDrawings, arrFooterTables)
|
||
{
|
||
var oHeader = this.Pages[nPageIndex].Header;
|
||
var oFooter = this.Pages[nPageIndex].Footer;
|
||
|
||
var nOldHeaderCurPage = null;
|
||
var nOldFooterCurPage = null;
|
||
|
||
if (oHeader)
|
||
{
|
||
nOldHeaderCurPage = oHeader.RecalcInfo.CurPage;
|
||
oHeader.Set_Page(nPageIndex);
|
||
}
|
||
|
||
if (oFooter)
|
||
{
|
||
nOldFooterCurPage = oFooter.RecalcInfo.CurPage;
|
||
oFooter.Set_Page(nPageIndex);
|
||
}
|
||
|
||
this.LogicDocument.DrawingObjects.mergeDrawings(nPageIndex, arrHeaderDrawings, arrHeaderTables, arrFooterDrawings, arrFooterTables);
|
||
|
||
if (null !== nOldHeaderCurPage)
|
||
oHeader.Set_Page(nOldHeaderCurPage);
|
||
|
||
if (null !== nOldFooterCurPage)
|
||
oFooter.Set_Page(nOldFooterCurPage);
|
||
},
|
||
|
||
// Отрисовка колонтитулов на данной странице
|
||
Draw : function(nPageIndex, pGraphics)
|
||
{
|
||
var oHeader = this.Pages[nPageIndex].Header;
|
||
var oFooter = this.Pages[nPageIndex].Footer;
|
||
|
||
var nOldHeaderCurPage = null;
|
||
var nOldFooterCurPage = null;
|
||
|
||
if (oHeader)
|
||
{
|
||
nOldHeaderCurPage = oHeader.RecalcInfo.CurPage;
|
||
oHeader.Set_Page(nPageIndex);
|
||
}
|
||
|
||
if (oFooter)
|
||
{
|
||
nOldFooterCurPage = oFooter.RecalcInfo.CurPage;
|
||
oFooter.Set_Page(nPageIndex);
|
||
}
|
||
|
||
this.LogicDocument.DrawingObjects.drawBehindDocHdrFtr(nPageIndex, pGraphics);
|
||
|
||
if (oHeader)
|
||
oHeader.Draw(nPageIndex, pGraphics);
|
||
|
||
if (oFooter)
|
||
oFooter.Draw(nPageIndex, pGraphics);
|
||
|
||
this.LogicDocument.DrawingObjects.drawBeforeObjectsHdrFtr(nPageIndex, pGraphics);
|
||
|
||
if (null !== nOldHeaderCurPage)
|
||
oHeader.Set_Page(nOldHeaderCurPage);
|
||
|
||
if (null !== nOldFooterCurPage)
|
||
oFooter.Set_Page(nOldFooterCurPage);
|
||
},
|
||
|
||
CheckRange : function(X0, Y0, X1, Y1, _Y0, _Y1, X_lf, X_rf, PageIndex, bMathWrap)
|
||
{
|
||
if (undefined === this.Pages[PageIndex])
|
||
return [];
|
||
|
||
var Header = this.Pages[PageIndex].Header;
|
||
var Footer = this.Pages[PageIndex].Footer;
|
||
|
||
var HeaderRange = [];
|
||
var FooterRange = [];
|
||
|
||
if ( null != Header )
|
||
HeaderRange = Header.CheckRange( X0, Y0, X1, Y1, _Y0, _Y1, X_lf, X_rf, bMathWrap );
|
||
|
||
if ( null != Footer )
|
||
FooterRange = Footer.CheckRange( X0, Y0, X1, Y1, _Y0, _Y1, X_lf, X_rf, bMathWrap );
|
||
|
||
return HeaderRange.concat( FooterRange );
|
||
},
|
||
|
||
// Запрашиваем низ у верхнего колонтитула для данной страницы
|
||
GetHdrFtrLines : function(PageIndex)
|
||
{
|
||
var Header = null;
|
||
var Footer = null;
|
||
|
||
if ( undefined !== this.Pages[PageIndex] )
|
||
{
|
||
Header = this.Pages[PageIndex].Header;
|
||
Footer = this.Pages[PageIndex].Footer;
|
||
}
|
||
|
||
var Top = null;
|
||
if ( null !== Header )
|
||
Top = Header.Get_DividingLine(PageIndex);
|
||
|
||
var Bottom = null;
|
||
if ( null !== Footer )
|
||
Bottom = Footer.Get_DividingLine(PageIndex);
|
||
|
||
return { Top : Top, Bottom : Bottom };
|
||
},
|
||
|
||
UpdateCursorType : function( X, Y, PageNum_Abs )
|
||
{
|
||
if ( true === this.Lock.Is_Locked() )
|
||
{
|
||
let contentFrame = this.LogicDocument.GetPageContentFrame( PageNum_Abs );
|
||
|
||
var MMData_header = new AscCommon.CMouseMoveData();
|
||
var Coords = this.DrawingDocument.ConvertCoordsToCursorWR( contentFrame.X, contentFrame.Y, PageNum_Abs );
|
||
MMData_header.X_abs = Coords.X;
|
||
MMData_header.Y_abs = Coords.Y + 2;
|
||
MMData_header.Type = Asc.c_oAscMouseMoveDataTypes.LockedObject;
|
||
MMData_header.UserId = this.Lock.Get_UserId();
|
||
MMData_header.HaveChanges = this.Lock.Have_Changes();
|
||
MMData_header.LockedObjectType = c_oAscMouseMoveLockedObjectType.Header;
|
||
editor.sync_MouseMoveCallback( MMData_header );
|
||
|
||
var MMData_footer = new AscCommon.CMouseMoveData();
|
||
Coords = this.DrawingDocument.ConvertCoordsToCursorWR( contentFrame.X, contentFrame.YLimit, PageNum_Abs );
|
||
MMData_footer.X_abs = Coords.X;
|
||
MMData_footer.Y_abs = Coords.Y - 2;
|
||
MMData_footer.Type = Asc.c_oAscMouseMoveDataTypes.LockedObject;
|
||
MMData_footer.UserId = this.Lock.Get_UserId();
|
||
MMData_footer.HaveChanges = this.Lock.Have_Changes();
|
||
MMData_footer.LockedObjectType = c_oAscMouseMoveLockedObjectType.Footer;
|
||
editor.sync_MouseMoveCallback( MMData_footer );
|
||
}
|
||
|
||
// TODO: Сделать выбор в зависимости колонтитула от номера страница PageNum_Abs
|
||
if ( null != this.CurHdrFtr )
|
||
{
|
||
// Если мы попадаем в заселекченную автофигуру, пусть она даже выходит за пределы
|
||
if ( true === this.LogicDocument.DrawingObjects.pointInSelectedObject(X, Y, PageNum_Abs) )
|
||
{
|
||
var NewPos = this.DrawingDocument.ConvertCoordsToAnotherPage(X, Y, PageNum_Abs, this.CurPage);
|
||
var _X = NewPos.X;
|
||
var _Y = NewPos.Y;
|
||
return this.CurHdrFtr.UpdateCursorType( _X, _Y, this.CurPage );
|
||
}
|
||
else
|
||
return this.CurHdrFtr.UpdateCursorType( X, Y, PageNum_Abs );
|
||
}
|
||
},
|
||
|
||
IsTableBorder : function( X, Y, PageNum_Abs )
|
||
{
|
||
var HdrFtr = this.Internal_GetContentByXY( X, Y, PageNum_Abs );
|
||
if ( null != HdrFtr )
|
||
return HdrFtr.IsTableBorder( X, Y, PageNum_Abs );
|
||
|
||
return null;
|
||
},
|
||
|
||
IsInText : function(X,Y, PageNum_Abs)
|
||
{
|
||
var HdrFtr = this.Internal_GetContentByXY( X, Y, PageNum_Abs );
|
||
if ( null != HdrFtr )
|
||
return HdrFtr.IsInText( X, Y, PageNum_Abs );
|
||
|
||
return null;
|
||
},
|
||
|
||
IsInDrawing : function(X,Y, PageNum_Abs)
|
||
{
|
||
var HdrFtr = this.Internal_GetContentByXY( X, Y, PageNum_Abs );
|
||
if ( null != HdrFtr )
|
||
return HdrFtr.IsInDrawing( X, Y, PageNum_Abs );
|
||
|
||
return null;
|
||
},
|
||
|
||
Document_UpdateInterfaceState : function()
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
this.CurHdrFtr.Document_UpdateInterfaceState();
|
||
},
|
||
|
||
Document_UpdateRulersState : function(CurPage)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
this.CurHdrFtr.Document_UpdateRulersState(CurPage);
|
||
},
|
||
|
||
Document_UpdateSelectionState : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.Document_UpdateSelectionState();
|
||
},
|
||
|
||
IsSelectionUse : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.IsSelectionUse();
|
||
|
||
return false;
|
||
},
|
||
|
||
IsNumberingSelection : function()
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.IsNumberingSelection();
|
||
|
||
return false;
|
||
},
|
||
|
||
IsTextSelectionUse : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.IsTextSelectionUse();
|
||
|
||
return false;
|
||
},
|
||
|
||
IsUseInDocument : function(Id)
|
||
{
|
||
let hdrFtr = AscCommon.g_oTableId.GetById(Id);
|
||
return !(!hdrFtr || -1 === this.LogicDocument.SectionsInfo.Find_ByHdrFtr(hdrFtr));
|
||
},
|
||
|
||
Check_Page : function(HdrFtr, PageIndex)
|
||
{
|
||
var Header = this.Pages[PageIndex].Header;
|
||
var Footer = this.Pages[PageIndex].Footer;
|
||
|
||
if ( HdrFtr === Header || HdrFtr === Footer )
|
||
return true;
|
||
|
||
return false;
|
||
},
|
||
|
||
GetCurPosXY : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetCurPosXY();
|
||
|
||
return {X : 0, Y : 0};
|
||
},
|
||
|
||
GetSelectedText : function(bClearText, oPr)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetSelectedText(bClearText, oPr);
|
||
|
||
return null;
|
||
},
|
||
|
||
GetSelectedElementsInfo : function(Info)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.GetSelectedElementsInfo(Info);
|
||
},
|
||
|
||
GetSelectedContent : function(SelectedContent)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.GetSelectedContent(SelectedContent);
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с контентом
|
||
//-----------------------------------------------------------------------------------
|
||
AddNewParagraph : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.AddNewParagraph();
|
||
},
|
||
|
||
AddInlineImage : function(W, H, Img, GraphicObject, bFlow)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.AddInlineImage(W,H,Img, GraphicObject, bFlow);
|
||
},
|
||
AddImages : function(aImages)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.AddImages(aImages);
|
||
},
|
||
AddSignatureLine : function(oSignatureDrawing)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.AddSignatureLine(oSignatureDrawing);
|
||
},
|
||
|
||
AddOleObject: function(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.AddOleObject(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory);
|
||
},
|
||
|
||
AddTextArt : function(nStyle)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.AddTextArt(nStyle);
|
||
},
|
||
LoadChartData : function(bNeedRecalculate)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.LoadChartData(bNeedRecalculate);
|
||
},
|
||
EditChart : function(Chart)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.EditChart( Chart );
|
||
},
|
||
|
||
UpdateChart : function(Chart)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.UpdateChart( Chart );
|
||
},
|
||
OpenChartEditor : function()
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.OpenChartEditor();
|
||
},
|
||
GetChartSettings : function()
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.GetChartSettings();
|
||
},
|
||
|
||
ApplyChartSettings : function(oChartSettings)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.ApplyChartSettings( oChartSettings );
|
||
},
|
||
|
||
AddInlineTable : function(nCols, nRows, nMode)
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.AddInlineTable(nCols, nRows, nMode);
|
||
|
||
return null;
|
||
},
|
||
|
||
AddToParagraph : function(ParaItem, bRecalculate)
|
||
{
|
||
if (para_NewLine === ParaItem.Type && true === ParaItem.IsPageBreak())
|
||
return;
|
||
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.AddToParagraph(ParaItem, bRecalculate);
|
||
},
|
||
|
||
ClearParagraphFormatting : function(isClearParaPr, isClearTextPr)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.ClearParagraphFormatting();
|
||
},
|
||
|
||
PasteFormatting : function(oData)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.PasteFormatting(oData);
|
||
},
|
||
|
||
Remove : function(Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord)
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.Remove(Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord);
|
||
},
|
||
|
||
GetCursorPosXY : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetCursorPosXY();
|
||
},
|
||
|
||
MoveCursorLeft : function(AddToSelect, Word)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorLeft(AddToSelect, Word);
|
||
},
|
||
|
||
MoveCursorRight : function(AddToSelect, Word)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorRight(AddToSelect, Word);
|
||
},
|
||
|
||
MoveCursorUp : function(AddToSelect)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorUp(AddToSelect);
|
||
},
|
||
|
||
MoveCursorDown : function(AddToSelect)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorDown(AddToSelect);
|
||
},
|
||
|
||
MoveCursorToEndOfLine : function(AddToSelect)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorToEndOfLine(AddToSelect);
|
||
},
|
||
|
||
MoveCursorToStartOfLine : function(AddToSelect)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorToStartOfLine(AddToSelect);
|
||
},
|
||
|
||
MoveCursorToXY : function(X, Y, PageIndex, AddToSelect)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorToXY(X, Y, PageIndex, AddToSelect);
|
||
},
|
||
|
||
MoveCursorToStartPos : function(AddToSelect)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorToStartPos(AddToSelect);
|
||
},
|
||
|
||
MoveCursorToEndPos : function(AddToSelect)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.MoveCursorToEndPos(AddToSelect);
|
||
},
|
||
|
||
MoveCursorToCell : function(bNext)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.MoveCursorToCell(bNext);
|
||
},
|
||
|
||
SetParagraphAlign : function(Align)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphAlign(Align);
|
||
},
|
||
|
||
SetParagraphSpacing : function(Spacing)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphSpacing(Spacing);
|
||
},
|
||
|
||
SetParagraphIndent : function(Ind)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphIndent(Ind);
|
||
},
|
||
|
||
SetParagraphShd : function(Shd)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphShd(Shd);
|
||
},
|
||
|
||
SetParagraphStyle : function(Name)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphStyle(Name);
|
||
},
|
||
|
||
SetParagraphTabs : function(Tabs)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphTabs(Tabs);
|
||
},
|
||
|
||
SetParagraphContextualSpacing : function(Value)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphContextualSpacing(Value);
|
||
},
|
||
|
||
SetParagraphPageBreakBefore : function(Value)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphPageBreakBefore(Value);
|
||
},
|
||
|
||
SetParagraphKeepLines : function(Value)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphKeepLines(Value);
|
||
},
|
||
|
||
SetParagraphKeepNext : function(Value)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphKeepNext(Value);
|
||
},
|
||
|
||
SetParagraphWidowControl : function(Value)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphWidowControl(Value);
|
||
},
|
||
|
||
SetParagraphBorders : function(Value)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetParagraphBorders(Value);
|
||
},
|
||
|
||
IncreaseDecreaseFontSize : function(bIncrease)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.IncreaseDecreaseFontSize(bIncrease);
|
||
},
|
||
|
||
IncreaseDecreaseIndent : function(bIncrease)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.IncreaseDecreaseIndent(bIncrease);
|
||
},
|
||
|
||
SetImageProps : function(Props)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetImageProps(Props);
|
||
},
|
||
|
||
SetTableProps : function(Props)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SetTableProps(Props);
|
||
},
|
||
|
||
GetCalculatedParaPr : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetCalculatedParaPr();
|
||
},
|
||
|
||
GetCalculatedTextPr : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetCalculatedTextPr();
|
||
},
|
||
|
||
GetDirectTextPr : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetDirectTextPr();
|
||
|
||
return null;
|
||
},
|
||
|
||
GetDirectParaPr : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetDirectParaPr();
|
||
|
||
return null;
|
||
},
|
||
|
||
RemoveSelection : function(bNoCheckDrawing)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.RemoveSelection(bNoCheckDrawing);
|
||
},
|
||
|
||
DrawSelectionOnPage : function(CurPage)
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.DrawSelectionOnPage(CurPage);
|
||
},
|
||
|
||
Selection_SetStart : function(X, Y, PageIndex, MouseEvent, bActivate)
|
||
{
|
||
let TempHdrFtr = null;
|
||
let logicDocument = this.LogicDocument;
|
||
|
||
// Если мы попадаем в заселекченную автофигуру, пусть она даже выходит за пределы
|
||
if (logicDocument && logicDocument.DrawingObjects.pointInSelectedObject(X, Y, PageIndex))
|
||
{
|
||
let selectedObjects = logicDocument.DrawingObjects.getSelectedObjects();
|
||
if (selectedObjects.length)
|
||
{
|
||
let paraDrawing = selectedObjects[0].GetParaDrawing();
|
||
TempHdrFtr = paraDrawing ? paraDrawing.isHdrFtrChild(true) : null;
|
||
}
|
||
|
||
if (!TempHdrFtr)
|
||
logicDocument.DrawingObjects.resetSelection(undefined, true);
|
||
}
|
||
|
||
if (TempHdrFtr
|
||
|| (null !== (TempHdrFtr = this.Pages[PageIndex].Header) && true === TempHdrFtr.Is_PointInFlowTable(X, Y))
|
||
|| (null !== (TempHdrFtr = this.Pages[PageIndex].Footer) && true === TempHdrFtr.Is_PointInFlowTable(X, Y)))
|
||
{
|
||
if (this.CurHdrFtr && ((null !== TempHdrFtr && TempHdrFtr !== this.CurHdrFtr) || this.CurPage !== PageIndex))
|
||
this.CurHdrFtr.RemoveSelection();
|
||
|
||
if (null !== TempHdrFtr)
|
||
this.CurHdrFtr = TempHdrFtr;
|
||
|
||
this.CurPage = PageIndex;
|
||
this.CurHdrFtr.Selection_SetStart(X, Y, PageIndex, MouseEvent);
|
||
this.ChangeCurPageOnEnd = false;
|
||
|
||
this.WaitMouseDown = false;
|
||
|
||
return true;
|
||
}
|
||
|
||
this.ChangeCurPageOnEnd = true;
|
||
|
||
var OldPage = this.CurPage;
|
||
|
||
// Сначала проверяем, не попали ли мы в контент документа. Если да, тогда надо
|
||
// активировать работу с самим документом (просто вернуть false здесь)
|
||
|
||
let contentFrame = this.LogicDocument.GetPageContentFrame( PageIndex );
|
||
|
||
if ( MouseEvent.ClickCount >= 2 && (!editor.isStartAddShape && !editor.isInkDrawerOn()) &&
|
||
!( Y <= contentFrame.Y || ( null !== ( TempHdrFtr = this.Pages[PageIndex].Header ) && true === TempHdrFtr.Is_PointInDrawingObjects( X, Y ) ) ) &&
|
||
!( Y >= contentFrame.YLimit || ( null !== ( TempHdrFtr = this.Pages[PageIndex].Footer ) && true === TempHdrFtr.Is_PointInDrawingObjects( X, Y ) ) ) )
|
||
{
|
||
// Убираем селект, если он был
|
||
if ( null != this.CurHdrFtr )
|
||
{
|
||
this.CurHdrFtr.RemoveSelection();
|
||
}
|
||
|
||
MouseEvent.ClickCount = 1;
|
||
return false;
|
||
}
|
||
|
||
this.CurPage = PageIndex;
|
||
|
||
var HdrFtr = null;
|
||
|
||
// Проверяем попали ли мы в колонтитул, если он есть. Если мы попали в
|
||
// область колонтитула, а его там нет, тогда добавим новый колонтитул.
|
||
if ( Y <= contentFrame.Y || ( null !== ( TempHdrFtr = this.Pages[PageIndex].Header ) && true === TempHdrFtr.Is_PointInDrawingObjects( X, Y ) ) || (editor.isStartAddShape || editor.isInkDrawerOn()) )
|
||
{
|
||
if ( null === this.Pages[PageIndex].Header )
|
||
{
|
||
if ( false === editor.WordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_HdrFtr) )
|
||
{
|
||
// Меняем старый режим редактирования, чтобы при Undo/Redo возвращаться в режим редактирования документа
|
||
this.LogicDocument.SetDocPosType(docpostype_Content);
|
||
this.LogicDocument.StartAction(AscDFH.historydescription_Document_AddHeader);
|
||
this.LogicDocument.SetDocPosType(docpostype_HdrFtr);
|
||
HdrFtr = this.LogicDocument.Create_SectionHdrFtr( hdrftr_Header, PageIndex );
|
||
|
||
if (this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveSelection();
|
||
|
||
this.CurHdrFtr = HdrFtr;
|
||
|
||
this.LogicDocument.Recalculate();
|
||
this.LogicDocument.FinalizeAction();
|
||
}
|
||
else
|
||
return false;
|
||
}
|
||
else
|
||
HdrFtr = this.Pages[PageIndex].Header;
|
||
}
|
||
else if ( Y >= contentFrame.YLimit || ( null !== ( TempHdrFtr = this.Pages[PageIndex].Footer ) && true === TempHdrFtr.Is_PointInDrawingObjects( X, Y ) ) )
|
||
{
|
||
if ( null === this.Pages[PageIndex].Footer )
|
||
{
|
||
if ( false === editor.WordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_HdrFtr) )
|
||
{
|
||
// Меняем старый режим редактирования, чтобы при Undo/Redo возвращаться в режим редактирования документа
|
||
this.LogicDocument.SetDocPosType(docpostype_Content);
|
||
this.LogicDocument.StartAction(AscDFH.historydescription_Document_AddFooter);
|
||
this.LogicDocument.SetDocPosType(docpostype_HdrFtr);
|
||
HdrFtr = this.LogicDocument.Create_SectionHdrFtr( hdrftr_Footer, PageIndex );
|
||
|
||
if (this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveSelection();
|
||
|
||
this.CurHdrFtr = HdrFtr;
|
||
|
||
this.LogicDocument.Recalculate();
|
||
this.LogicDocument.FinalizeAction();
|
||
}
|
||
else
|
||
return false;
|
||
}
|
||
else
|
||
HdrFtr = this.Pages[PageIndex].Footer;
|
||
}
|
||
|
||
if (!HdrFtr)
|
||
{
|
||
// Ничего не делаем и отключаем дальнейшую обработку MouseUp и MouseMove
|
||
this.WaitMouseDown = true;
|
||
return true;
|
||
}
|
||
|
||
// В зависимости от страницы и позиции на странице мы активируем(делаем текущим)
|
||
// соответствующий колонтитул
|
||
var oPrevHdrFtr = this.CurHdrFtr;
|
||
|
||
// Очищаем селект, если он был в предыдущем колонтитуле
|
||
if (oPrevHdrFtr && (oPrevHdrFtr !== HdrFtr || OldPage != this.CurPage))
|
||
{
|
||
oPrevHdrFtr.RemoveSelection();
|
||
}
|
||
|
||
this.CurHdrFtr = HdrFtr;
|
||
if ( null != this.CurHdrFtr )
|
||
{
|
||
this.CurHdrFtr.Selection_SetStart( X, Y, PageIndex, MouseEvent );
|
||
if ( true === bActivate )
|
||
{
|
||
var NewMouseEvent = {};
|
||
NewMouseEvent.Type = AscCommon.g_mouse_event_type_up;
|
||
NewMouseEvent.ClickCount = 1;
|
||
this.CurHdrFtr.Selection_SetEnd( X, Y, PageIndex, NewMouseEvent );
|
||
this.CurHdrFtr.Content.MoveCursorToStartPos(false);
|
||
}
|
||
}
|
||
|
||
this.WaitMouseDown = false;
|
||
return true;
|
||
},
|
||
|
||
Selection_SetEnd : function(X, Y, PageIndex, MouseEvent)
|
||
{
|
||
if ( true === this.WaitMouseDown )
|
||
return;
|
||
|
||
if ( null != this.CurHdrFtr )
|
||
{
|
||
// Селект может происходить только внутри одного колонтитула, а колонтитул
|
||
// не может быть разбит на несколько страниц
|
||
var ResY = Y;
|
||
|
||
if (docpostype_DrawingObjects != this.CurHdrFtr.Content.GetDocPosType())
|
||
{
|
||
if ( PageIndex > this.CurPage )
|
||
ResY = this.LogicDocument.Get_PageLimits(this.CurPage).YLimit + 10;
|
||
else if ( PageIndex < this.CurPage )
|
||
ResY = -10;
|
||
|
||
PageIndex = this.CurPage;
|
||
}
|
||
|
||
this.CurHdrFtr.Selection_SetEnd(X, ResY, PageIndex, MouseEvent);
|
||
|
||
if ( false === this.ChangeCurPageOnEnd )
|
||
{
|
||
this.CurHdrFtr.Set_Page( this.CurPage );
|
||
}
|
||
}
|
||
},
|
||
|
||
IsMovingTableBorder : function()
|
||
{
|
||
if ( null != this.CurHdrFtr )
|
||
return this.CurHdrFtr.IsMovingTableBorder();
|
||
|
||
return false;
|
||
},
|
||
|
||
CheckPosInSelection : function(X, Y, PageAbs, NearPos)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.CheckPosInSelection(X, Y, PageAbs, NearPos);
|
||
},
|
||
|
||
IsSelectionEmpty : function(bCheckHidden)
|
||
{
|
||
if (null !== this.CurHdrFtr)
|
||
return this.CurHdrFtr.Content.IsSelectionEmpty(bCheckHidden);
|
||
|
||
return true;
|
||
},
|
||
|
||
SelectAll : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.SelectAll();
|
||
},
|
||
|
||
Get_NearestPos : function(PageNum, X, Y, bAnchor, Drawing)
|
||
{
|
||
var HdrFtr = (editor.isStartAddShape || editor.isInkDrawerOn() ? this.CurHdrFtr : this.Internal_GetContentByXY( X, Y, PageNum ));
|
||
|
||
if ( null != HdrFtr )
|
||
return HdrFtr.Get_NearestPos( X, Y, bAnchor, Drawing );
|
||
else
|
||
return { X : -1, Y : -1, Height : -1 };
|
||
},
|
||
|
||
GetCurrentParagraph : function(bIgnoreSelection, arrSelectedParagraphs, oPr)
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetCurrentParagraph(bIgnoreSelection, arrSelectedParagraphs, oPr);
|
||
|
||
return null;
|
||
},
|
||
|
||
GetCurrentTablesStack : function(arrTables)
|
||
{
|
||
return this.CurHdrFtr ? this.CurHdrFtr.GetCurrentTablesStack(arrTables) : arrTables;
|
||
},
|
||
|
||
StartSelectionFromCurPos : function()
|
||
{
|
||
if (null !== this.CurHdrFtr)
|
||
this.CurHdrFtr.StartSelectionFromCurPos();
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Внутренние(вспомогательные) функции
|
||
//-----------------------------------------------------------------------------------
|
||
|
||
// Возвращаем колонтитул по данной позиции
|
||
Internal_GetContentByXY : function( X, Y, PageIndex )
|
||
{
|
||
var Header = null;
|
||
var Footer = null;
|
||
|
||
if ( undefined !== this.Pages[PageIndex] )
|
||
{
|
||
Header = this.Pages[PageIndex].Header;
|
||
Footer = this.Pages[PageIndex].Footer;
|
||
}
|
||
|
||
var PageH = this.LogicDocument.Get_PageLimits( PageIndex).YLimit;
|
||
|
||
if ( Y <= PageH / 2 && null != Header )
|
||
return Header;
|
||
else if ( Y >= PageH / 2 && null != Footer )
|
||
return Footer;
|
||
else if ( null != Header )
|
||
return Header;
|
||
else
|
||
return Footer;
|
||
|
||
return null;
|
||
},
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с таблицами
|
||
//-----------------------------------------------------------------------------------
|
||
AddTableRow : function(bBefore, nCount)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.AddTableRow(bBefore, nCount);
|
||
},
|
||
|
||
AddTableColumn : function(bBefore, nCount)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.AddTableColumn(bBefore, nCount);
|
||
},
|
||
|
||
RemoveTableRow : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveTableRow();
|
||
},
|
||
|
||
RemoveTableColumn : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveTableColumn();
|
||
},
|
||
|
||
MergeTableCells : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.MergeTableCells();
|
||
},
|
||
|
||
SplitTableCells : function(Cols, Rows)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.SplitTableCells(Cols, Rows);
|
||
},
|
||
|
||
RemoveTableCells : function()
|
||
{
|
||
if (this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveTableCells();
|
||
},
|
||
|
||
RemoveTable : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveTable();
|
||
},
|
||
|
||
SelectTable : function(Type)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.SelectTable(Type);
|
||
},
|
||
|
||
CanMergeTableCells : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.CanMergeTableCells();
|
||
},
|
||
|
||
CanSplitTableCells : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.CanSplitTableCells();
|
||
},
|
||
|
||
DistributeTableCells : function(isHorizontally)
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.DistributeTableCells(isHorizontally);
|
||
|
||
return false;
|
||
},
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
// Undo/Redo функции
|
||
//-----------------------------------------------------------------------------------
|
||
GetSelectionState : function()
|
||
{
|
||
var HdrFtrState = {};
|
||
HdrFtrState.CurHdrFtr = this.CurHdrFtr;
|
||
|
||
var State = null;
|
||
if (null != this.CurHdrFtr)
|
||
State = this.CurHdrFtr.Content.GetSelectionState();
|
||
else
|
||
State = [];
|
||
|
||
State.push(HdrFtrState);
|
||
|
||
return State;
|
||
},
|
||
|
||
SetSelectionState : function(State, StateIndex)
|
||
{
|
||
if (State.length <= 0)
|
||
return;
|
||
|
||
var HdrFtrState = State[StateIndex];
|
||
this.CurHdrFtr = HdrFtrState.CurHdrFtr;
|
||
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.Content.SetSelectionState(State, StateIndex - 1);
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с гиперссылками
|
||
//-----------------------------------------------------------------------------------
|
||
AddHyperlink : function(HyperProps)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.AddHyperlink(HyperProps);
|
||
|
||
return null;
|
||
},
|
||
|
||
ModifyHyperlink : function(HyperProps)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.ModifyHyperlink(HyperProps);
|
||
},
|
||
|
||
RemoveHyperlink : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveHyperlink();
|
||
},
|
||
|
||
CanAddHyperlink : function(bCheckInHyperlink)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.CanAddHyperlink(bCheckInHyperlink);
|
||
|
||
return false;
|
||
},
|
||
|
||
IsCursorInHyperlink : function(bCheckEnd)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.IsCursorInHyperlink(bCheckEnd);
|
||
|
||
return null;
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с комментариями
|
||
//-----------------------------------------------------------------------------------
|
||
AddComment : function(Comment)
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
{
|
||
// Отмечаем, что данный комментарий добавлен к колонтитулу
|
||
Comment.Set_TypeInfo(AscCommon.comment_type_HdrFtr, this.CurHdrFtr);
|
||
this.CurHdrFtr.AddComment(Comment);
|
||
}
|
||
},
|
||
|
||
CanAddComment : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.CanAddComment();
|
||
|
||
return false;
|
||
},
|
||
|
||
GetSelectionAnchorPos : function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.Content.GetSelectionAnchorPos();
|
||
|
||
return {X : 0, Y : 0, Page : 0};
|
||
}
|
||
};
|
||
CHeaderFooterController.prototype.constructor = CHeaderFooterController;
|
||
CHeaderFooterController.prototype.GetStyleFromFormatting = function()
|
||
{
|
||
if (null != this.CurHdrFtr)
|
||
return this.CurHdrFtr.Content.GetStyleFromFormatting();
|
||
|
||
return null;
|
||
};
|
||
CHeaderFooterController.prototype.GetSimilarNumbering = function(oEngine)
|
||
{
|
||
if (!this.CurHdrFtr)
|
||
return null;
|
||
|
||
let docContent = this.CurHdrFtr.GetContent();
|
||
if (docpostype_DrawingObjects === docContent.GetDocPosType() && this.LogicDocument)
|
||
return this.LogicDocument.DrawingsController.GetSimilarNumbering(oEngine);
|
||
else
|
||
return this.CurHdrFtr.Content.GetSimilarNumbering(oEngine)
|
||
};
|
||
CHeaderFooterController.prototype.GetPlaceHolderObject = function()
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.Content.GetPlaceHolderObject();
|
||
|
||
return null;
|
||
};
|
||
CHeaderFooterController.prototype.SetParagraphFramePr = function(FramePr, bDelete)
|
||
{
|
||
if (null !== this.CurHdrFtr)
|
||
this.CurHdrFtr.SetParagraphFramePr(FramePr, bDelete);
|
||
};
|
||
CHeaderFooterController.prototype.GetSelectionBounds = function()
|
||
{
|
||
if (null !== this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetSelectionBounds();
|
||
|
||
return null;
|
||
};
|
||
CHeaderFooterController.prototype.Get_CurHdrFtr = function()
|
||
{
|
||
return this.CurHdrFtr;
|
||
};
|
||
CHeaderFooterController.prototype.GetCurHdrFtr = function()
|
||
{
|
||
return this.CurHdrFtr;
|
||
};
|
||
CHeaderFooterController.prototype.Set_CurHdrFtr = function(HdrFtr)
|
||
{
|
||
if (null !== this.CurHdrFtr)
|
||
this.CurHdrFtr.RemoveSelection();
|
||
|
||
this.CurHdrFtr = HdrFtr;
|
||
};
|
||
CHeaderFooterController.prototype.GetHdrFtr = function(nPageAbs, isHeader)
|
||
{
|
||
let oPage = this.Pages[nPageAbs];
|
||
return oPage ? (isHeader ? oPage.Header : oPage.Footer) : null;
|
||
};
|
||
CHeaderFooterController.prototype.RecalculatePageCountUpdate = function(nPageAbs, nPageCount)
|
||
{
|
||
var oPage = this.Pages[nPageAbs];
|
||
if (!oPage)
|
||
return false;
|
||
|
||
var oHeader = oPage.Header;
|
||
var oFooter = oPage.Footer;
|
||
|
||
var bNeedRecalc = false;
|
||
if (oHeader && oHeader.Have_PageCountElement())
|
||
{
|
||
oHeader.Update_PageCountElements(nPageCount);
|
||
bNeedRecalc = true;
|
||
}
|
||
|
||
if (oFooter && oFooter.Have_PageCountElement())
|
||
{
|
||
oFooter.Update_PageCountElements(nPageCount);
|
||
bNeedRecalc = true;
|
||
}
|
||
|
||
if (true === bNeedRecalc)
|
||
return this.Recalculate(nPageAbs);
|
||
|
||
return null;
|
||
};
|
||
CHeaderFooterController.prototype.UpdatePagesCount = function(nPageAbs, nPageCount)
|
||
{
|
||
var oPage = this.Pages[nPageAbs];
|
||
if (!oPage)
|
||
return false;
|
||
|
||
var oHeader = oPage.Header;
|
||
var oFooter = oPage.Footer;
|
||
|
||
if (oHeader && oHeader.Have_PageCountElement())
|
||
oHeader.Update_PageCountElements(nPageCount);
|
||
|
||
if (oFooter && oFooter.Have_PageCountElement())
|
||
oFooter.Update_PageCountElements(nPageCount);
|
||
|
||
};
|
||
CHeaderFooterController.prototype.HavePageCountElement = function()
|
||
{
|
||
var nStartPage = -1;
|
||
var nPagesCount = this.LogicDocument.Pages.length;
|
||
for (var nPageAbs = 0; nPageAbs < nPagesCount; ++nPageAbs)
|
||
{
|
||
var oPage = this.Pages[nPageAbs];
|
||
if (!oPage)
|
||
continue;
|
||
|
||
var oHeader = oPage.Header;
|
||
var oFooter = oPage.Footer;
|
||
|
||
if (oHeader && oHeader.Have_PageCountElement())
|
||
{
|
||
oHeader.ForceRecalculate(nPageAbs);
|
||
if (-1 === nStartPage)
|
||
nStartPage = nPageAbs;
|
||
}
|
||
|
||
if (oFooter && oFooter.Have_PageCountElement())
|
||
{
|
||
oFooter.ForceRecalculate(nPageAbs);
|
||
if (-1 === nStartPage)
|
||
nStartPage = nPageAbs;
|
||
}
|
||
}
|
||
|
||
return nStartPage;
|
||
};
|
||
CHeaderFooterController.prototype.GetAllFields = function(isUseSelection, arrFields)
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetContent().GetAllFields(isUseSelection, arrFields);
|
||
|
||
return arrFields ? arrFields : [];
|
||
};
|
||
CHeaderFooterController.prototype.IsTableCellSelection = function()
|
||
{
|
||
if (this.CurHdrFtr)
|
||
return this.CurHdrFtr.GetContent().IsTableCellSelection();
|
||
|
||
return false;
|
||
};
|
||
CHeaderFooterController.prototype.AcceptRevisionChanges = function(Type, bAll)
|
||
{
|
||
if (null !== this.CurHdrFtr)
|
||
this.CurHdrFtr.Content.AcceptRevisionChanges(Type, bAll);
|
||
};
|
||
CHeaderFooterController.prototype.RejectRevisionChanges = function(Type, bAll)
|
||
{
|
||
if (null !== this.CurHdrFtr)
|
||
this.CurHdrFtr.Content.RejectRevisionChanges(Type, bAll);
|
||
};
|
||
CHeaderFooterController.prototype.Document_Is_SelectionLocked = function(nCheckType)
|
||
{
|
||
// Любое действие внутри колонтитула лочит его
|
||
this.Lock.Check(this.Get_Id());
|
||
|
||
// Нужно запускать проверку дальше, чтобы проверить залоченность Sdt
|
||
if (this.CurHdrFtr)
|
||
this.CurHdrFtr.GetContent().Document_Is_SelectionLocked(nCheckType);
|
||
};
|
||
CHeaderFooterController.prototype.GetAllTablesOnPage = function(nPageAbs, arrTables)
|
||
{
|
||
var oPage = this.Pages[nPageAbs];
|
||
if (!oPage)
|
||
return arrTables;
|
||
|
||
if (oPage.Header)
|
||
oPage.Header.GetAllTablesOnPage(nPageAbs, arrTables);
|
||
|
||
if (oPage.Footer)
|
||
oPage.Footer.GetAllTablesOnPage(nPageAbs, arrTables);
|
||
|
||
return arrTables;
|
||
};
|
||
CHeaderFooterController.prototype.CollectSelectedReviewChanges = function(oTrackManager)
|
||
{
|
||
if (this.CurHdrFtr)
|
||
this.CurHdrFtr.GetContent().CollectSelectedReviewChanges(oTrackManager);
|
||
};
|
||
|
||
function CHdrFtrPage()
|
||
{
|
||
this.Header = null;
|
||
this.Footer = null;
|
||
}
|
||
|
||
//--------------------------------------------------------export----------------------------------------------------
|
||
window['AscCommonWord'] = window['AscCommonWord'] || {};
|
||
window['AscCommonWord'].CHeaderFooter = CHeaderFooter;
|
||
window['AscCommonWord'].CHeaderFooterController = CHeaderFooterController;
|