1528 lines
59 KiB
JavaScript
1528 lines
59 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2015
|
|
*
|
|
* 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 Lubanas st. 125a-25, Riga, Latvia,
|
|
* EU, LV-1021.
|
|
*
|
|
* 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";
|
|
Paragraph.prototype.Recalculate_FastWholeParagraph = function () {
|
|
if (true === this.Parent.Is_HdrFtr(false)) {
|
|
return [];
|
|
}
|
|
if (undefined === this.Parent || true === this.Parent.Is_TableCellContent()) {
|
|
return [];
|
|
}
|
|
if (this.LogicDocument && true === this.LogicDocument.Pages[this.Get_StartPage_Absolute()].Check_EndSectionPara(this)) {
|
|
return [];
|
|
}
|
|
if (1 === this.Lines.length && true !== this.Is_Inline()) {
|
|
return [];
|
|
}
|
|
if (1 === this.Pages.length) {
|
|
var PageNum = this.Get_StartPage_Relative();
|
|
var OldBounds = this.Pages[0].Bounds;
|
|
var FastRecalcResult = this.Recalculate_Page(PageNum, true);
|
|
if (FastRecalcResult === recalcresult_NextElement && 1 === this.Pages.length && true === this.Pages[0].Bounds.Compare(OldBounds)) {
|
|
var PageNum_abs = this.Get_StartPage_Absolute();
|
|
return [PageNum_abs];
|
|
}
|
|
} else {
|
|
if (2 === this.Pages.length) {
|
|
var OldBounds_0 = this.Pages[0].Bounds;
|
|
var OldBounds_1 = this.Pages[1].Bounds;
|
|
var OldStartFromNewPage = this.Pages[0].StartLine < 0 ? true : false;
|
|
var OldLinesCount_0 = this.Pages[0].EndLine - this.Pages[0].StartLine + 1;
|
|
var OldLinesCount_1 = this.Pages[1].EndLine - this.Pages[1].StartLine + 1;
|
|
var PageNum = this.Get_StartPage_Relative();
|
|
var FastRecalcResult = this.Recalculate_Page(PageNum, true);
|
|
if (FastRecalcResult !== recalcresult_NextPage) {
|
|
return [];
|
|
}
|
|
FastRecalcResult = this.Recalculate_Page(PageNum + 1);
|
|
if (FastRecalcResult !== recalcresult_NextElement) {
|
|
return [];
|
|
}
|
|
if (2 !== this.Pages.length || true !== this.Pages[0].Bounds.Compare(OldBounds_0) || true !== this.Pages[1].Bounds.Compare(OldBounds_1)) {
|
|
return [];
|
|
}
|
|
var StartFromNewPage = this.Pages[0].StartLine < 0 ? true : false;
|
|
if (StartFromNewPage !== OldStartFromNewPage) {
|
|
return [];
|
|
}
|
|
if (true !== StartFromNewPage) {
|
|
var LinesCount_0 = this.Pages[0].EndLine - this.Pages[0].StartLine + 1;
|
|
var LinesCount_1 = this.Pages[1].EndLine - this.Pages[1].StartLine + 1;
|
|
if ((OldLinesCount_0 <= 2 || LinesCount_0 <= 2) && OldLinesCount_0 !== LinesCount_0) {
|
|
return [];
|
|
}
|
|
if ((OldLinesCount_1 <= 2 || LinesCount_1 <= 2) && OldLinesCount_1 !== LinesCount_1) {
|
|
return [];
|
|
}
|
|
}
|
|
var PageNum_abs = this.Get_StartPage_Absolute();
|
|
if (true === StartFromNewPage) {
|
|
return [PageNum_abs + 1];
|
|
} else {
|
|
return [PageNum_abs, PageNum_abs + 1];
|
|
}
|
|
}
|
|
}
|
|
return [];
|
|
};
|
|
Paragraph.prototype.Recalculate_FastRange = function (SimpleChanges) {
|
|
if (true === this.Parent.Is_HdrFtr(false)) {
|
|
return -1;
|
|
}
|
|
var Run = SimpleChanges[0].Class;
|
|
var ParaPos = Run.Get_SimpleChanges_ParaPos(SimpleChanges);
|
|
if (null === ParaPos) {
|
|
return -1;
|
|
}
|
|
var Line = ParaPos.Line;
|
|
var Range = ParaPos.Range;
|
|
if (undefined === this.Parent || true === this.Parent.Is_TableCellContent()) {
|
|
return -1;
|
|
}
|
|
if (true === this.Lines[Line].RangeY) {
|
|
return -1;
|
|
}
|
|
if (this.Lines[Line].Info & paralineinfo_BreakPage || (this.Lines[Line].Info & paralineinfo_Empty && this.Lines[Line].Info & paralineinfo_End)) {
|
|
return -1;
|
|
}
|
|
var NumPr = this.Get_CompiledPr2(false).ParaPr.NumPr;
|
|
if (null !== this.Numbering.Item && (Line < this.Numbering.Line || (Line === this.Numbering.Line && Range <= this.Numbering.Range)) && (undefined !== NumPr && undefined !== NumPr.NumId && 0 !== NumPr.NumId && "0" !== NumPr.NumId)) {
|
|
return -1;
|
|
}
|
|
if (0 === Line && 0 === Range && undefined !== this.Get_SectionPr()) {
|
|
return -1;
|
|
}
|
|
if (1 === this.Lines.length && true !== this.Is_Inline()) {
|
|
return -1;
|
|
}
|
|
var PrevLine = Line;
|
|
var PrevRange = Range;
|
|
while (PrevLine >= 0) {
|
|
PrevRange--;
|
|
if (PrevRange < 0) {
|
|
PrevLine--;
|
|
if (PrevLine < 0) {
|
|
break;
|
|
}
|
|
PrevRange = this.Lines[PrevLine].Ranges.length - 1;
|
|
}
|
|
if (true === this.Is_EmptyRange(PrevLine, PrevRange)) {
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (PrevLine < 0) {
|
|
PrevLine = Line;
|
|
PrevRange = Range;
|
|
}
|
|
var NextLine = Line;
|
|
var NextRange = Range;
|
|
var LinesCount = this.Lines.length;
|
|
while (NextLine <= LinesCount - 1) {
|
|
NextRange++;
|
|
if (NextRange > this.Lines[NextLine].Ranges.length - 1) {
|
|
NextLine++;
|
|
if (NextLine > LinesCount - 1) {
|
|
break;
|
|
}
|
|
NextRange = 0;
|
|
}
|
|
if (true === this.Is_EmptyRange(NextLine, NextRange)) {
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (NextLine > LinesCount - 1) {
|
|
NextLine = Line;
|
|
NextRange = Range;
|
|
}
|
|
var CurLine = PrevLine;
|
|
var CurRange = PrevRange;
|
|
var Result;
|
|
while ((CurLine < NextLine) || (CurLine === NextLine && CurRange <= NextRange)) {
|
|
var TempResult = this.private_RecalculateFastRange(CurRange, CurLine);
|
|
if (-1 === TempResult) {
|
|
return -1;
|
|
}
|
|
if (CurLine === Line && CurRange === Range) {
|
|
Result = TempResult;
|
|
}
|
|
CurRange++;
|
|
if (CurRange > this.Lines[CurLine].Ranges.length - 1) {
|
|
CurLine++;
|
|
CurRange = 0;
|
|
}
|
|
}
|
|
this.CurPos.Line = -1;
|
|
this.CurPos.Range = -1;
|
|
this.Internal_CheckSpelling();
|
|
return Result;
|
|
};
|
|
Paragraph.prototype.Recalculate_Page = function (PageIndex) {
|
|
this.Clear_NearestPosArray();
|
|
this.CurPos.Line = -1;
|
|
this.CurPos.Range = -1;
|
|
this.FontMap.NeedRecalc = true;
|
|
this.Internal_CheckSpelling();
|
|
var CurPage = PageIndex - this.PageNum;
|
|
var RecalcResult = this.private_RecalculatePage(CurPage);
|
|
if (true === this.Parent.RecalcInfo.WidowControlReset) {
|
|
this.Parent.RecalcInfo.Reset();
|
|
}
|
|
return RecalcResult;
|
|
};
|
|
Paragraph.prototype.Save_RecalculateObject = function () {
|
|
var RecalcObj = new CParagraphRecalculateObject();
|
|
RecalcObj.Save(this);
|
|
return RecalcObj;
|
|
};
|
|
Paragraph.prototype.Load_RecalculateObject = function (RecalcObj) {
|
|
RecalcObj.Load(this);
|
|
};
|
|
Paragraph.prototype.Prepare_RecalculateObject = function () {
|
|
this.Pages = [];
|
|
this.Lines = [];
|
|
var Count = this.Content.length;
|
|
for (var Index = 0; Index < Count; Index++) {
|
|
this.Content[Index].Prepare_RecalculateObject();
|
|
}
|
|
};
|
|
Paragraph.prototype.Start_FromNewPage = function () {
|
|
this.Pages.length = 1;
|
|
this.Pages[0].Set_EndLine(-1);
|
|
this.Lines[-1] = new CParaLine(0);
|
|
};
|
|
Paragraph.prototype.private_RecalculateFastRange = function (CurRange, CurLine) {
|
|
var PRS = this.m_oPRSW;
|
|
var XStart, YStart, XLimit, YLimit;
|
|
var CurPage = 0;
|
|
var PagesLen = this.Pages.length;
|
|
for (var TempPage = 0; TempPage < PagesLen; TempPage++) {
|
|
var __Page = this.Pages[TempPage];
|
|
if (CurLine <= __Page.EndLine && CurLine >= __Page.FirstLine) {
|
|
CurPage = TempPage;
|
|
break;
|
|
}
|
|
}
|
|
if (-1 === CurPage) {
|
|
return -1;
|
|
}
|
|
var ParaPr = this.Get_CompiledPr2(false).ParaPr;
|
|
if (0 === CurPage) {
|
|
XStart = this.X;
|
|
YStart = this.Y;
|
|
XLimit = this.XLimit;
|
|
YLimit = this.YLimit;
|
|
} else {
|
|
var PageStart = this.Parent.Get_PageContentStartPos(this.PageNum + CurPage, this.Index);
|
|
XStart = PageStart.X;
|
|
YStart = PageStart.Y;
|
|
XLimit = PageStart.XLimit;
|
|
YLimit = PageStart.YLimit;
|
|
}
|
|
PRS.XStart = XStart;
|
|
PRS.YStart = YStart;
|
|
PRS.XLimit = XLimit - ParaPr.Ind.Right;
|
|
PRS.YLimit = YLimit;
|
|
PRS.Reset_Line();
|
|
PRS.Page = 0;
|
|
PRS.Line = CurLine;
|
|
PRS.Range = CurRange;
|
|
PRS.RangesCount = this.Lines[CurLine].Ranges.length - 1;
|
|
PRS.Paragraph = this;
|
|
var RangesCount = PRS.RangesCount;
|
|
var Line = this.Lines[CurLine];
|
|
var Range = Line.Ranges[CurRange];
|
|
var StartPos = Range.StartPos;
|
|
var EndPos = Range.EndPos;
|
|
PRS.Reset_Range(Range.X, Range.XEnd);
|
|
var ContentLen = this.Content.length;
|
|
for (var Pos = StartPos; Pos <= EndPos; Pos++) {
|
|
var Item = this.Content[Pos];
|
|
if (para_Math === Item.Type) {
|
|
Item.Set_Inline(true === this.Check_MathPara(Pos) ? false : true);
|
|
}
|
|
PRS.Update_CurPos(Pos, 0);
|
|
var SavedLines = Item.Save_RecalculateObject(true);
|
|
Item.Recalculate_Range(PRS, ParaPr, 1);
|
|
if ((true === PRS.NewRange && Pos !== EndPos) || (Pos === EndPos && true !== PRS.NewRange)) {
|
|
return -1;
|
|
} else {
|
|
if (Pos === EndPos && true === PRS.NewRange && true === PRS.MoveToLBP) {
|
|
var BreakPos = PRS.LineBreakPos.Get(0);
|
|
if (BreakPos !== Pos) {
|
|
return -1;
|
|
} else {
|
|
Item.Recalculate_Set_RangeEndPos(PRS, PRS.LineBreakPos, 1);
|
|
}
|
|
}
|
|
}
|
|
if (false === SavedLines.Compare(CurLine, CurRange, Item)) {
|
|
return -1;
|
|
}
|
|
Item.Load_RecalculateObject(SavedLines, this);
|
|
}
|
|
if (recalcresult_NextElement !== this.private_RecalculateLineAlign(CurLine, CurPage, PRS, ParaPr, true)) {
|
|
return -1;
|
|
}
|
|
return this.Get_StartPage_Absolute() + CurPage;
|
|
};
|
|
Paragraph.prototype.private_RecalculatePage = function (CurPage) {
|
|
var PRS = this.m_oPRSW;
|
|
PRS.Page = CurPage;
|
|
PRS.RunRecalcInfoLast = (0 === CurPage ? null : this.Pages[CurPage - 1].EndInfo.RunRecalcInfo);
|
|
PRS.RunRecalcInfoBreak = PRS.RunRecalcInfoLast;
|
|
var Pr = this.Get_CompiledPr();
|
|
var ParaPr = Pr.ParaPr;
|
|
var CurLine = (CurPage > 0 ? this.Pages[CurPage - 1].EndLine + 1 : 0);
|
|
if (false === this.private_RecalculatePageKeepNext(CurLine, CurPage, PRS, ParaPr)) {
|
|
return PRS.RecalcResult;
|
|
}
|
|
this.private_RecalculatePageXY(CurLine, CurPage, PRS, ParaPr);
|
|
if (false === this.private_RecalculatePageBreak(CurLine, CurPage, PRS, ParaPr)) {
|
|
return PRS.RecalcResult;
|
|
}
|
|
PRS.Reset_Ranges();
|
|
PRS.Reset_PageBreak();
|
|
var RecalcResult;
|
|
while (true) {
|
|
PRS.Line = CurLine;
|
|
PRS.RecalcResult = recalcresult_NextLine;
|
|
this.private_RecalculateLine(CurLine, CurPage, PRS, ParaPr);
|
|
RecalcResult = PRS.RecalcResult;
|
|
if (recalcresult_NextLine === RecalcResult) {
|
|
CurLine++;
|
|
PRS.Reset_Ranges();
|
|
PRS.Reset_PageBreak();
|
|
PRS.Reset_RunRecalcInfo();
|
|
} else {
|
|
if (recalcresult_CurLine === RecalcResult) {
|
|
PRS.Restore_RunRecalcInfo();
|
|
} else {
|
|
if (recalcresult_NextElement === RecalcResult || recalcresult_NextPage === RecalcResult) {
|
|
break;
|
|
} else {
|
|
if (recalcresult_CurPagePara === RecalcResult) {
|
|
RecalcResult = this.private_RecalculatePage(CurPage);
|
|
break;
|
|
} else {
|
|
return RecalcResult;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.Recalculate_PageEndInfo(PRS, CurPage);
|
|
return RecalcResult;
|
|
};
|
|
Paragraph.prototype.private_RecalculatePageKeepNext = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (1 === CurPage && this.Pages[0].EndLine < 0 && this.Parent instanceof CDocument && false === ParaPr.PageBreakBefore) {
|
|
var Curr = this.Get_DocumentPrev();
|
|
while (null != Curr && type_Paragraph === Curr.GetType() && undefined === Curr.Get_SectionPr()) {
|
|
var CurrKeepNext = Curr.Get_CompiledPr2(false).ParaPr.KeepNext;
|
|
if ((true === CurrKeepNext && Curr.Pages.length > 1) || false === CurrKeepNext || true !== Curr.Is_Inline() || true === Curr.Check_PageBreak()) {
|
|
break;
|
|
} else {
|
|
var Prev = Curr.Get_DocumentPrev();
|
|
if (null === Prev || type_Paragraph != Prev.GetType() || undefined !== Prev.Get_SectionPr()) {
|
|
break;
|
|
}
|
|
var PrevKeepNext = Prev.Get_CompiledPr2(false).ParaPr.KeepNext;
|
|
if (false === PrevKeepNext) {
|
|
if (true === this.Parent.RecalcInfo.Can_RecalcObject()) {
|
|
this.Parent.RecalcInfo.Set_KeepNext(Curr);
|
|
PRS.RecalcResult = recalcresult_PrevPage;
|
|
return false;
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
Curr = Prev;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculatePageXY = function (CurLine, CurPage, PRS, ParaPr) {
|
|
var XStart, YStart, XLimit, YLimit;
|
|
if (0 === CurPage || (undefined != this.Get_FramePr() && this.LogicDocument === this.Parent)) {
|
|
XStart = this.X;
|
|
YStart = this.Y;
|
|
XLimit = this.XLimit;
|
|
YLimit = this.YLimit;
|
|
} else {
|
|
var PageStart = this.Parent.Get_PageContentStartPos(this.PageNum + CurPage, this.Index);
|
|
XStart = PageStart.X;
|
|
YStart = PageStart.Y;
|
|
XLimit = PageStart.XLimit;
|
|
YLimit = PageStart.YLimit;
|
|
}
|
|
PRS.XStart = XStart;
|
|
PRS.YStart = YStart;
|
|
PRS.XLimit = XLimit - ParaPr.Ind.Right;
|
|
PRS.YLimit = YLimit;
|
|
PRS.Y = YStart;
|
|
this.Pages.length = CurPage + 1;
|
|
this.Pages[CurPage] = new CParaPage(XStart, YStart, XLimit, YLimit, CurLine);
|
|
};
|
|
Paragraph.prototype.private_RecalculatePageBreak = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (this.Parent instanceof CDocument) {
|
|
if (0 === CurPage && true === ParaPr.PageBreakBefore) {
|
|
var bNeedPageBreak = true;
|
|
var Prev = this.Get_DocumentPrev();
|
|
if ((true === this.IsEmpty() && undefined !== this.Get_SectionPr()) || null === Prev) {
|
|
bNeedPageBreak = false;
|
|
} else {
|
|
if (this.Parent === this.LogicDocument && type_Paragraph === Prev.GetType() && undefined !== Prev.Get_SectionPr()) {
|
|
var PrevSectPr = Prev.Get_SectionPr();
|
|
var CurSectPr = this.LogicDocument.SectionsInfo.Get_SectPr(this.Index).SectPr;
|
|
if (section_type_Continuous !== CurSectPr.Get_Type() || true !== CurSectPr.Compare_PageSize(PrevSectPr)) {
|
|
bNeedPageBreak = false;
|
|
}
|
|
}
|
|
}
|
|
if (true === bNeedPageBreak) {
|
|
this.Pages[CurPage].Set_EndLine(CurLine - 1);
|
|
if (0 === CurLine) {
|
|
this.Lines[-1] = new CParaLine(0);
|
|
}
|
|
PRS.RecalcResult = recalcresult_NextPage;
|
|
return false;
|
|
}
|
|
} else {
|
|
if (true === this.Parent.RecalcInfo.Check_KeepNext(this) && 0 === CurPage && null != this.Get_DocumentPrev()) {
|
|
this.Parent.RecalcInfo.Reset();
|
|
this.Pages[CurPage].Set_EndLine(CurLine - 1);
|
|
if (0 === CurLine) {
|
|
this.Lines[-1] = new CParaLine(0);
|
|
}
|
|
PRS.RecalcResult = recalcresult_NextPage;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (PRS.YStart > PRS.YLimit - 0.001 && (CurLine != this.Pages[CurPage].FirstLine || (0 === CurPage && (null != this.Get_DocumentPrev() || true === this.Parent.Is_TableCellContent()))) && true === this.Use_YLimit()) {
|
|
this.Pages[CurPage].Set_EndLine(CurLine - 1);
|
|
if (0 === CurLine) {
|
|
this.Lines[-1] = new CParaLine(0);
|
|
}
|
|
PRS.RecalcResult = recalcresult_NextPage;
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLine = function (CurLine, CurPage, PRS, ParaPr) {
|
|
this.ParaEnd.Line = -1;
|
|
this.ParaEnd.Range = -1;
|
|
this.Lines.length = CurLine + 1;
|
|
this.Lines[CurLine] = new CParaLine();
|
|
if (false === this.private_RecalculateLineWidow(CurLine, CurPage, PRS, ParaPr)) {
|
|
return;
|
|
}
|
|
this.private_RecalculateLineFillRanges(CurLine, CurPage, PRS, ParaPr);
|
|
if (false === this.private_RecalculateLineRanges(CurLine, CurPage, PRS, ParaPr)) {
|
|
return;
|
|
}
|
|
this.private_RecalculateLineInfo(CurLine, CurPage, PRS, ParaPr);
|
|
this.private_RecalculateLineMetrics(CurLine, CurPage, PRS, ParaPr);
|
|
this.private_RecalculateLinePosition(CurLine, CurPage, PRS, ParaPr);
|
|
if (false === this.private_RecalculateLineBottomBound(CurLine, CurPage, PRS, ParaPr)) {
|
|
return;
|
|
}
|
|
if (false === this.private_RecalculateLineCheckRanges(CurLine, CurPage, PRS, ParaPr)) {
|
|
return;
|
|
}
|
|
if (false === this.private_RecalculateLineBreakPageEnd(CurLine, CurPage, PRS, ParaPr)) {
|
|
return;
|
|
}
|
|
this.private_RecalculateLineBaseLine(CurLine, CurPage, PRS, ParaPr);
|
|
if (false === this.private_RecalculateLineCheckRangeY(CurLine, CurPage, PRS, ParaPr)) {
|
|
return;
|
|
}
|
|
if (recalcresult_NextElement !== this.private_RecalculateLineAlign(CurLine, CurPage, PRS, ParaPr, false)) {
|
|
return;
|
|
}
|
|
if (false === this.private_RecalculateLineEnd(CurLine, CurPage, PRS, ParaPr)) {
|
|
return;
|
|
}
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineWidow = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (this.Parent instanceof CDocument && true === this.Parent.RecalcInfo.Check_WidowControl(this, CurLine)) {
|
|
this.Parent.RecalcInfo.Reset_WidowControl();
|
|
this.Pages[CurPage].Set_EndLine(CurLine - 1);
|
|
if (0 === CurLine) {
|
|
this.Lines[-1] = new CParaLine(0);
|
|
}
|
|
PRS.RecalcResult = recalcresult_NextPage;
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineFillRanges = function (CurLine, CurPage, PRS, ParaPr) {
|
|
this.Lines[CurLine].Info = 0;
|
|
var Ranges = PRS.Ranges;
|
|
var RangesCount = PRS.RangesCount;
|
|
PRS.Reset_Line();
|
|
var UseFirstLine = true;
|
|
for (var TempCurLine = CurLine - 1; TempCurLine >= 0; TempCurLine--) {
|
|
var TempInfo = this.Lines[TempCurLine].Info;
|
|
if (! (TempInfo & paralineinfo_BreakPage) || !(TempInfo & paralineinfo_Empty)) {
|
|
UseFirstLine = false;
|
|
break;
|
|
}
|
|
}
|
|
PRS.UseFirstLine = UseFirstLine;
|
|
this.Lines[CurLine].Reset();
|
|
this.Lines[CurLine].Add_Range((true === UseFirstLine ? PRS.XStart + ParaPr.Ind.Left + ParaPr.Ind.FirstLine : PRS.XStart + ParaPr.Ind.Left), (RangesCount == 0 ? PRS.XLimit : Ranges[0].X0));
|
|
for (var Index = 1; Index < Ranges.length + 1; Index++) {
|
|
this.Lines[CurLine].Add_Range(Ranges[Index - 1].X1, (RangesCount == Index ? PRS.XLimit : Ranges[Index].X0));
|
|
}
|
|
if (true === PRS.RangeY) {
|
|
PRS.RangeY = false;
|
|
this.Lines[CurLine].Info |= paralineinfo_RangeY;
|
|
}
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineRanges = function (CurLine, CurPage, PRS, ParaPr) {
|
|
var RangesCount = PRS.RangesCount;
|
|
var CurRange = 0;
|
|
while (CurRange <= RangesCount) {
|
|
PRS.Range = CurRange;
|
|
this.private_RecalculateRange(CurRange, CurLine, CurPage, RangesCount, PRS, ParaPr);
|
|
if (true === PRS.ForceNewPage || true === PRS.NewPage) {
|
|
this.Lines[CurLine].Ranges.length = CurRange + 1;
|
|
break;
|
|
}
|
|
if (-1 === this.ParaEnd.Line && true === PRS.End) {
|
|
this.ParaEnd.Line = CurLine;
|
|
this.ParaEnd.Range = CurRange;
|
|
}
|
|
if (recalcresult_NextPage === PRS.RecalcResult) {
|
|
return false;
|
|
}
|
|
CurRange++;
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineInfo = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (true === PRS.BreakPageLine || true === PRS.SkipPageBreak) {
|
|
this.Lines[CurLine].Info |= paralineinfo_BreakPage;
|
|
}
|
|
if (true === PRS.EmptyLine) {
|
|
this.Lines[CurLine].Info |= paralineinfo_Empty;
|
|
}
|
|
if (true === PRS.End) {
|
|
this.Lines[CurLine].Info |= paralineinfo_End;
|
|
}
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineMetrics = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (true === PRS.EmptyLine || PRS.LineAscent < 0.001) {
|
|
var LastItem = (true === PRS.End ? this.Content[this.Content.length - 1] : this.Content[this.Lines[CurLine].Ranges[this.Lines[CurLine].Ranges.length - 1].EndPos]);
|
|
if (true === PRS.End) {
|
|
var EndTextPr = this.Get_CompiledPr2(false).TextPr.Copy();
|
|
EndTextPr.Merge(this.TextPr.Value);
|
|
g_oTextMeasurer.SetTextPr(EndTextPr, this.Get_Theme());
|
|
g_oTextMeasurer.SetFontSlot(fontslot_ASCII);
|
|
var EndTextHeight = g_oTextMeasurer.GetHeight();
|
|
var EndTextDescent = Math.abs(g_oTextMeasurer.GetDescender());
|
|
var EndTextAscent = EndTextHeight - EndTextDescent;
|
|
var EndTextAscent2 = g_oTextMeasurer.GetAscender();
|
|
PRS.LineTextAscent = EndTextAscent;
|
|
PRS.LineTextAscent2 = EndTextAscent2;
|
|
PRS.LineTextDescent = EndTextDescent;
|
|
if (PRS.LineAscent < EndTextAscent) {
|
|
PRS.LineAscent = EndTextAscent;
|
|
}
|
|
if (PRS.LineDescent < EndTextDescent) {
|
|
PRS.LineDescent = EndTextDescent;
|
|
}
|
|
} else {
|
|
if (undefined !== LastItem) {
|
|
var LastRun = LastItem.Get_LastRunInRange(PRS.Line, PRS.Range);
|
|
if (undefined !== LastRun && null !== LastRun) {
|
|
if (PRS.LineTextAscent < LastRun.TextAscent) {
|
|
PRS.LineTextAscent = LastRun.TextAscent;
|
|
}
|
|
if (PRS.LineTextAscent2 < LastRun.TextAscent2) {
|
|
PRS.LineTextAscent2 = LastRun.TextAscent2;
|
|
}
|
|
if (PRS.LineTextDescent < LastRun.TextDescent) {
|
|
PRS.LineTextDescent = LastRun.TextDescent;
|
|
}
|
|
if (PRS.LineAscent < LastRun.TextAscent) {
|
|
PRS.LineAscent = LastRun.TextAscent;
|
|
}
|
|
if (PRS.LineDescent < LastRun.TextDescent) {
|
|
PRS.LineDescent = LastRun.TextDescent;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.Lines[CurLine].Metrics.Update(PRS.LineTextAscent, PRS.LineTextAscent2, PRS.LineTextDescent, PRS.LineAscent, PRS.LineDescent, ParaPr);
|
|
};
|
|
Paragraph.prototype.private_RecalculateLinePosition = function (CurLine, CurPage, PRS, ParaPr) {
|
|
var BaseLineOffset = 0;
|
|
if (CurLine === this.Pages[CurPage].FirstLine) {
|
|
BaseLineOffset = this.Lines[CurLine].Metrics.Ascent;
|
|
if (0 === CurLine) {
|
|
if (0 === CurPage || true === this.Parent.Is_TableCellContent() || true === ParaPr.PageBreakBefore) {
|
|
BaseLineOffset += ParaPr.Spacing.Before;
|
|
}
|
|
if ((true === ParaPr.Brd.First || 1 === CurPage) && border_Single === ParaPr.Brd.Top.Value) {
|
|
BaseLineOffset += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
} else {
|
|
if (false === ParaPr.Brd.First && border_Single === ParaPr.Brd.Between.Value) {
|
|
BaseLineOffset += ParaPr.Brd.Between.Size + ParaPr.Brd.Between.Space;
|
|
}
|
|
}
|
|
}
|
|
PRS.BaseLineOffset = BaseLineOffset;
|
|
} else {
|
|
BaseLineOffset = PRS.BaseLineOffset;
|
|
}
|
|
var Top, Bottom;
|
|
var Top2, Bottom2;
|
|
var PrevBottom = this.Pages[CurPage].Bounds.Bottom;
|
|
if (this.Lines[CurLine].Info & paralineinfo_RangeY) {
|
|
Top = PRS.Y;
|
|
Top2 = PRS.Y;
|
|
if (0 === CurLine) {
|
|
if (0 === CurPage || true === this.Parent.Is_TableCellContent()) {
|
|
Top2 = Top + ParaPr.Spacing.Before;
|
|
Bottom2 = Top + ParaPr.Spacing.Before + this.Lines[0].Metrics.Ascent + this.Lines[0].Metrics.Descent;
|
|
if (true === ParaPr.Brd.First && border_Single === ParaPr.Brd.Top.Value) {
|
|
Top2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
Bottom2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
} else {
|
|
if (false === ParaPr.Brd.First && border_Single === ParaPr.Brd.Between.Value) {
|
|
Top2 += ParaPr.Brd.Between.Size + ParaPr.Brd.Between.Space;
|
|
Bottom2 += ParaPr.Brd.Between.Size + ParaPr.Brd.Between.Space;
|
|
}
|
|
}
|
|
} else {
|
|
Bottom2 = Top + this.Lines[0].Metrics.Ascent + this.Lines[0].Metrics.Descent;
|
|
if (border_Single === ParaPr.Brd.Top.Value) {
|
|
Top2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
Bottom2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
}
|
|
}
|
|
} else {
|
|
Bottom2 = Top + this.Lines[CurLine].Metrics.Ascent + this.Lines[CurLine].Metrics.Descent;
|
|
}
|
|
} else {
|
|
if (0 !== CurLine) {
|
|
if (CurLine !== this.Pages[CurPage].FirstLine) {
|
|
Top = PRS.Y + BaseLineOffset + this.Lines[CurLine - 1].Metrics.Descent + this.Lines[CurLine - 1].Metrics.LineGap;
|
|
Top2 = Top;
|
|
Bottom2 = Top + this.Lines[CurLine].Metrics.Ascent + this.Lines[CurLine].Metrics.Descent;
|
|
} else {
|
|
Top = this.Pages[CurPage].Y;
|
|
Top2 = Top;
|
|
Bottom2 = Top + this.Lines[CurLine].Metrics.Ascent + this.Lines[CurLine].Metrics.Descent;
|
|
}
|
|
} else {
|
|
Top = PRS.Y;
|
|
Top2 = PRS.Y;
|
|
if (0 === CurPage || true === this.Parent.Is_TableCellContent() || true === ParaPr.PageBreakBefore) {
|
|
Top2 = Top + ParaPr.Spacing.Before;
|
|
Bottom2 = Top + ParaPr.Spacing.Before + this.Lines[0].Metrics.Ascent + this.Lines[0].Metrics.Descent;
|
|
if (true === ParaPr.Brd.First && border_Single === ParaPr.Brd.Top.Value) {
|
|
Top2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
Bottom2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
} else {
|
|
if (false === ParaPr.Brd.First && border_Single === ParaPr.Brd.Between.Value) {
|
|
Top2 += ParaPr.Brd.Between.Size + ParaPr.Brd.Between.Space;
|
|
Bottom2 += ParaPr.Brd.Between.Size + ParaPr.Brd.Between.Space;
|
|
}
|
|
}
|
|
} else {
|
|
Bottom2 = Top + this.Lines[0].Metrics.Ascent + this.Lines[0].Metrics.Descent;
|
|
if (border_Single === ParaPr.Brd.Top.Value) {
|
|
Top2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
Bottom2 += ParaPr.Brd.Top.Size + ParaPr.Brd.Top.Space;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Bottom = Bottom2;
|
|
Bottom += this.Lines[CurLine].Metrics.LineGap;
|
|
if (true === PRS.End) {
|
|
Bottom += ParaPr.Spacing.After;
|
|
if (true === ParaPr.Brd.Last && border_Single === ParaPr.Brd.Bottom.Value) {
|
|
Bottom += ParaPr.Brd.Bottom.Size + ParaPr.Brd.Bottom.Space;
|
|
} else {
|
|
if (border_Single === ParaPr.Brd.Between.Value) {
|
|
Bottom += ParaPr.Brd.Between.Space;
|
|
}
|
|
}
|
|
if (false === this.Parent.Is_TableCellContent() && Bottom > this.YLimit && Bottom - this.YLimit <= ParaPr.Spacing.After) {
|
|
Bottom = this.YLimit;
|
|
}
|
|
}
|
|
if (CurLine === this.Pages[CurPage].FirstLine && !(this.Lines[CurLine].Info & paralineinfo_RangeY)) {
|
|
this.Pages[CurPage].Bounds.Top = Top;
|
|
}
|
|
this.Pages[CurPage].Bounds.Bottom = Bottom;
|
|
this.Lines[CurLine].Top = Top - this.Pages[CurPage].Y;
|
|
this.Lines[CurLine].Bottom = Bottom - this.Pages[CurPage].Y;
|
|
PRS.LineTop = Top;
|
|
PRS.LineBottom = Bottom;
|
|
PRS.LineTop2 = Top2;
|
|
PRS.LineBottom2 = Bottom2;
|
|
PRS.LinePrevBottom = PrevBottom;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineBottomBound = function (CurLine, CurPage, PRS, ParaPr) {
|
|
var Top = PRS.LineTop;
|
|
var Bottom2 = PRS.LineBottom;
|
|
if (true === this.Parent.Is_TableCellContent()) {
|
|
Bottom2 = PRS.LineBottom;
|
|
}
|
|
var LineInfo = this.Lines[CurLine].Info;
|
|
var BreakPageLineEmpty = (LineInfo & paralineinfo_BreakPage && LineInfo & paralineinfo_Empty && !(LineInfo & paralineinfo_End) ? true : false);
|
|
PRS.BreakPageLineEmpty = BreakPageLineEmpty;
|
|
if (true === this.Use_YLimit() && (Top > this.YLimit || Bottom2 > this.YLimit) && (CurLine != this.Pages[CurPage].FirstLine || (0 === CurPage && (null != this.Get_DocumentPrev() || true === this.Parent.Is_TableCellContent()))) && false === BreakPageLineEmpty) {
|
|
if (this.Parent instanceof CDocument && true === this.Parent.RecalcInfo.Can_RecalcObject() && true === ParaPr.WidowControl && CurLine - this.Pages[CurPage].StartLine <= 1 && CurLine >= 1 && true != PRS.BreakPageLine && (0 === CurPage && null != this.Get_DocumentPrev())) {
|
|
this.Recalculate_Drawing_AddPageBreak(0, 0, true);
|
|
this.Parent.RecalcInfo.Set_WidowControl(this, CurLine - 1);
|
|
PRS.RecalcResult = recalcresult_CurPage;
|
|
return false;
|
|
} else {
|
|
if (true === ParaPr.KeepLines && null != this.Get_DocumentPrev() && true != this.Parent.Is_TableCellContent() && 0 === CurPage) {
|
|
CurLine = 0;
|
|
}
|
|
this.Pages[CurPage].Bounds.Bottom = PRS.LinePrevBottom;
|
|
this.Pages[CurPage].Set_EndLine(CurLine - 1);
|
|
if (0 === CurLine) {
|
|
this.Lines[-1] = new CParaLine(0);
|
|
}
|
|
PRS.RecalcResult = recalcresult_NextPage;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineCheckRanges = function (CurLine, CurPage, PRS, ParaPr) {
|
|
var Left = (0 !== CurLine ? this.X + ParaPr.Ind.Left : this.X + ParaPr.Ind.Left + ParaPr.Ind.FirstLine);
|
|
var Right = this.XLimit - ParaPr.Ind.Right;
|
|
var Top = PRS.LineTop;
|
|
var Bottom = PRS.LineBottom;
|
|
var Top2 = PRS.LineTop2;
|
|
var Bottom2 = PRS.LineBottom2;
|
|
var PageFields = this.Parent.Get_PageFields(this.PageNum + CurPage);
|
|
var Ranges = PRS.Ranges;
|
|
var Ranges2;
|
|
if (true === this.Use_Wrap()) {
|
|
Ranges2 = this.Parent.CheckRange(Left, Top, Right, Bottom, Top2, Bottom2, PageFields.X, PageFields.XLimit, this.PageNum + CurPage, true);
|
|
} else {
|
|
Ranges2 = [];
|
|
}
|
|
if (-1 === FlowObjects_CompareRanges(Ranges, Ranges2) && true === FlowObjects_CheckInjection(Ranges, Ranges2) && false === PRS.BreakPageLineEmpty) {
|
|
PRS.Ranges = Ranges2;
|
|
PRS.RangesCount = Ranges2.length;
|
|
PRS.RecalcResult = recalcresult_CurLine;
|
|
if (this.Lines[CurLine].Info & paralineinfo_RangeY) {
|
|
PRS.RangeY = true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineBaseLine = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (this.Lines[CurLine].Info & paralineinfo_RangeY) {
|
|
this.Lines[CurLine].Y = PRS.Y - this.Pages[CurPage].Y;
|
|
PRS.BaseLineOffset = this.Lines[CurLine].Metrics.Ascent;
|
|
} else {
|
|
if (CurLine > 0) {
|
|
if (CurLine != this.Pages[CurPage].FirstLine && (true === PRS.End || true !== PRS.EmptyLine || PRS.RangesCount <= 0 || true === PRS.NewPage)) {
|
|
PRS.Y += this.Lines[CurLine - 1].Metrics.Descent + this.Lines[CurLine - 1].Metrics.LineGap + this.Lines[CurLine].Metrics.Ascent;
|
|
}
|
|
this.Lines[CurLine].Y = PRS.Y - this.Pages[CurPage].Y;
|
|
} else {
|
|
this.Lines[0].Y = 0;
|
|
}
|
|
}
|
|
this.Lines[CurLine].Y += PRS.BaseLineOffset;
|
|
if (this.Lines[CurLine].Metrics.LineGap < 0) {
|
|
this.Lines[CurLine].Y += this.Lines[CurLine].Metrics.LineGap;
|
|
}
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineCheckRangeY = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (recalcresult_NextPage === PRS.RecalcResult) {
|
|
return false;
|
|
}
|
|
if (true !== PRS.End && true === PRS.EmptyLine && PRS.RangesCount > 0) {
|
|
var Ranges = PRS.Ranges;
|
|
var RangesMaxY = Ranges[0].Y1;
|
|
for (var Index = 1; Index < Ranges.length; Index++) {
|
|
if (RangesMaxY > Ranges[Index].Y1) {
|
|
RangesMaxY = Ranges[Index].Y1;
|
|
}
|
|
}
|
|
if (Math.abs(RangesMaxY - PRS.Y) < 0.001) {
|
|
PRS.Y = RangesMaxY + 1;
|
|
} else {
|
|
PRS.Y = RangesMaxY + 0.001;
|
|
}
|
|
PRS.RangeY = true;
|
|
PRS.Reset_Ranges();
|
|
PRS.RecalcResult = recalcresult_CurLine;
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineBreakPageEnd = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (true === PRS.NewPage && true === this.Check_BreakPageEnd(PRS.PageBreak)) {
|
|
PRS.PageBreak.Flags.NewLine = false;
|
|
PRS.ExtendBoundToBottom = true;
|
|
PRS.SkipPageBreak = true;
|
|
PRS.RecalcResult = recalcresult_CurLine;
|
|
return false;
|
|
}
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineEnd = function (CurLine, CurPage, PRS, ParaPr) {
|
|
if (true === PRS.NewPage) {
|
|
if (true === this.Check_BreakPageEnd(PRS.PageBreak)) {
|
|
PRS.PageBreak.Flags.NewLine = false;
|
|
PRS.ExtendBoundToBottom = true;
|
|
PRS.SkipPageBreak = true;
|
|
PRS.RecalcResult = recalcresult_CurLine;
|
|
return false;
|
|
}
|
|
this.Pages[CurPage].Set_EndLine(CurLine);
|
|
PRS.RecalcResult = recalcresult_NextPage;
|
|
return false;
|
|
}
|
|
if (true !== PRS.End) {
|
|
if (true === PRS.ForceNewPage) {
|
|
this.Pages[CurPage].Set_EndLine(CurLine - 1);
|
|
if (0 === CurLine) {
|
|
this.Lines[-1] = new CParaLine();
|
|
}
|
|
PRS.RecalcResult = recalcresult_NextPage;
|
|
return false;
|
|
}
|
|
} else {
|
|
if (PRS.Range < PRS.RangesCount) {
|
|
this.Lines[CurLine].Ranges.length = PRS.Range + 1;
|
|
}
|
|
if (true === ParaPr.WidowControl && CurLine === this.Pages[CurPage].StartLine && CurLine >= 1) {
|
|
var BreakPagePrevLine = (this.Lines[CurLine - 1].Info & paralineinfo_BreakPage) | 0;
|
|
if (this.Parent instanceof CDocument && true === this.Parent.RecalcInfo.Can_RecalcObject() && 0 === BreakPagePrevLine && (1 === CurPage && null != this.Get_DocumentPrev()) && this.Lines[CurLine - 1].Ranges.length <= 1) {
|
|
this.Recalculate_Drawing_AddPageBreak(0, 0, true);
|
|
this.Parent.RecalcInfo.Set_WidowControl(this, (CurLine > 2 ? CurLine - 1 : 0));
|
|
PRS.RecalcResult = recalcresult_PrevPage;
|
|
return false;
|
|
}
|
|
}
|
|
if (true === PRS.ExtendBoundToBottom) {
|
|
this.Pages[CurPage].Bounds.Bottom = this.Pages[CurPage].YLimit;
|
|
if (para_End === this.Numbering.Item.Type) {
|
|
this.Numbering.Item = null;
|
|
this.Numbering.Run = null;
|
|
this.Numbering.Line = -1;
|
|
this.Numbering.Range = -1;
|
|
}
|
|
}
|
|
this.Pages[CurPage].Set_EndLine(CurLine);
|
|
PRS.RecalcResult = recalcresult_NextElement;
|
|
}
|
|
return true;
|
|
};
|
|
Paragraph.prototype.private_RecalculateLineAlign = function (CurLine, CurPage, PRS, ParaPr, Fast) {
|
|
var PRSW = PRS;
|
|
var PRSC = this.m_oPRSC;
|
|
var PRSA = this.m_oPRSA;
|
|
PRSA.Paragraph = this;
|
|
PRSA.LastW = 0;
|
|
PRSA.RecalcFast = Fast;
|
|
PRSA.RecalcResult = recalcresult_NextElement;
|
|
PRSA.PageY = this.Pages[CurPage].Bounds.Top;
|
|
var Line = this.Lines[CurLine];
|
|
var RangesCount = Line.Ranges.length;
|
|
for (var CurRange = 0; CurRange < RangesCount; CurRange++) {
|
|
var Range = Line.Ranges[CurRange];
|
|
var StartPos = Range.StartPos;
|
|
var EndPos = Range.EndPos;
|
|
PRSC.Reset(this, Range);
|
|
PRSC.Range.W = 0;
|
|
if (true === this.Numbering.Check_Range(CurRange, CurLine)) {
|
|
PRSC.Range.W += this.Numbering.WidthVisible;
|
|
}
|
|
for (var Pos = StartPos; Pos <= EndPos; Pos++) {
|
|
var Item = this.Content[Pos];
|
|
Item.Recalculate_Range_Width(PRSC, CurLine, CurRange);
|
|
}
|
|
var JustifyWord = 0;
|
|
var JustifySpace = 0;
|
|
var RangeWidth = Range.XEnd - Range.X;
|
|
var X = 0;
|
|
var ParaMath = this.Check_Range_OnlyMath(CurRange, CurLine);
|
|
if (null !== ParaMath) {
|
|
var Math_Jc = ParaMath.Get_Align();
|
|
var Math_X = (1 === RangesCount ? this.Pages[CurPage].X + ParaPr.Ind.Left : Range.X);
|
|
var Math_XLimit = (1 === RangesCount ? this.Pages[CurPage].XLimit - ParaPr.Ind.Right : Range.XEnd);
|
|
switch (Math_Jc) {
|
|
case align_Left:
|
|
X = Math_X;
|
|
break;
|
|
case align_Right:
|
|
X = Math_XLimit - ParaMath.Width;
|
|
break;
|
|
case align_Center:
|
|
X = Math.max(Math_X + (Math_XLimit - Math_X - ParaMath.Width) / 2, Math_X);
|
|
break;
|
|
}
|
|
} else {
|
|
switch (ParaPr.Jc) {
|
|
case align_Left:
|
|
X = Range.X;
|
|
break;
|
|
case align_Right:
|
|
X = Math.max(Range.X + RangeWidth - Range.W, Range.X);
|
|
break;
|
|
case align_Center:
|
|
X = Math.max(Range.X + (RangeWidth - Range.W) / 2, Range.X);
|
|
break;
|
|
case align_Justify:
|
|
X = Range.X;
|
|
if (1 == PRSC.Words) {
|
|
if (1 == RangesCount && !(Line.Info & paralineinfo_End)) {
|
|
if (RangeWidth - Range.W <= 0.05 * RangeWidth && PRSC.Letters > 1) {
|
|
JustifyWord = (RangeWidth - Range.W) / (PRSC.Letters - 1);
|
|
}
|
|
} else {
|
|
if (0 == CurRange || (Line.Info & paralineinfo_End && CurRange == RangesCount - 1)) {} else {
|
|
if (CurRange == RangesCount - 1) {
|
|
X = Range.X + RangeWidth - Range.W;
|
|
} else {
|
|
X = Range.X + (RangeWidth - Range.W) / 2;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (PRSC.Spaces > 0 && (!(Line.Info & paralineinfo_End) || CurRange != Line.Ranges.length - 1)) {
|
|
JustifySpace = (RangeWidth - Range.W) / PRSC.Spaces;
|
|
} else {
|
|
JustifySpace = 0;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
X = Range.X;
|
|
break;
|
|
}
|
|
if (CurLine === this.ParaEnd.Line && CurRange === this.ParaEnd.Range) {
|
|
JustifyWord = 0;
|
|
JustifySpace = 0;
|
|
}
|
|
}
|
|
Range.Spaces = PRSC.Spaces + PRSC.SpacesSkip;
|
|
PRSA.X = X;
|
|
PRSA.Y = this.Pages[CurPage].Y + this.Lines[CurLine].Y;
|
|
PRSA.XEnd = Range.XEnd;
|
|
PRSA.JustifyWord = JustifyWord;
|
|
PRSA.JustifySpace = JustifySpace;
|
|
PRSA.SpacesCounter = PRSC.Spaces;
|
|
PRSA.SpacesSkip = PRSC.SpacesSkip;
|
|
PRSA.LettersSkip = PRSC.LettersSkip;
|
|
PRSA.RecalcResult = recalcresult_NextElement;
|
|
this.Lines[CurLine].Ranges[CurRange].XVisible = X;
|
|
if (0 === CurRange) {
|
|
this.Lines[CurLine].X = X - PRSW.XStart;
|
|
}
|
|
if (true === this.Numbering.Check_Range(CurRange, CurLine)) {
|
|
PRSA.X += this.Numbering.WidthVisible;
|
|
}
|
|
for (var Pos = StartPos; Pos <= EndPos; Pos++) {
|
|
var Item = this.Content[Pos];
|
|
Item.Recalculate_Range_Spaces(PRSA, CurLine, CurRange, CurPage);
|
|
if (recalcresult_NextElement !== PRSA.RecalcResult) {
|
|
PRSW.RecalcResult = PRSA.RecalcResult;
|
|
return PRSA.RecalcResult;
|
|
}
|
|
}
|
|
}
|
|
return PRSA.RecalcResult;
|
|
};
|
|
Paragraph.prototype.private_RecalculateRange = function (CurRange, CurLine, CurPage, RangesCount, PRS, ParaPr) {
|
|
var StartPos = 0;
|
|
if (0 === CurLine && 0 === CurRange) {
|
|
StartPos = 0;
|
|
} else {
|
|
if (CurRange > 0) {
|
|
StartPos = this.Lines[CurLine].Ranges[CurRange - 1].EndPos;
|
|
} else {
|
|
StartPos = this.Lines[CurLine - 1].Ranges[this.Lines[CurLine - 1].Ranges.length - 1].EndPos;
|
|
}
|
|
}
|
|
var Line = this.Lines[CurLine];
|
|
var Range = Line.Ranges[CurRange];
|
|
this.Lines[CurLine].Set_RangeStartPos(CurRange, StartPos);
|
|
if (true === PRS.UseFirstLine && 0 !== CurRange && true === PRS.EmptyLine) {
|
|
if (ParaPr.Ind.FirstLine < 0) {
|
|
Range.X += ParaPr.Ind.Left + ParaPr.Ind.FirstLine;
|
|
} else {
|
|
Range.X += ParaPr.Ind.FirstLine;
|
|
}
|
|
}
|
|
var X = Range.X;
|
|
var XEnd = (CurRange == RangesCount ? PRS.XLimit : PRS.Ranges[CurRange].X0);
|
|
PRS.Reset_Range(X, XEnd);
|
|
var ContentLen = this.Content.length;
|
|
var Pos = StartPos;
|
|
for (; Pos < ContentLen; Pos++) {
|
|
var Item = this.Content[Pos];
|
|
if (para_Math === Item.Type) {
|
|
Item.Set_Inline(true === this.Check_MathPara(Pos) ? false : true);
|
|
}
|
|
if ((0 === Pos && 0 === CurLine && 0 === CurRange) || Pos !== StartPos) {
|
|
Item.Recalculate_Reset(CurRange, CurLine);
|
|
}
|
|
PRS.Update_CurPos(Pos, 0);
|
|
Item.Recalculate_Range(PRS, ParaPr, 1);
|
|
if (true === PRS.NewRange) {
|
|
break;
|
|
}
|
|
}
|
|
if (Pos >= ContentLen) {
|
|
Pos = ContentLen - 1;
|
|
}
|
|
if (recalcresult_NextLine === PRS.RecalcResult) {
|
|
if (true === PRS.MoveToLBP) {
|
|
this.private_RecalculateRangeEndPos(PRS, PRS.LineBreakPos, 0);
|
|
} else {
|
|
this.Lines[CurLine].Set_RangeEndPos(CurRange, Pos);
|
|
}
|
|
}
|
|
};
|
|
Paragraph.prototype.private_RecalculateRangeEndPos = function (PRS, PRP, Depth) {
|
|
var CurLine = PRS.Line;
|
|
var CurRange = PRS.Range;
|
|
var CurPos = PRP.Get(Depth);
|
|
this.Content[CurPos].Recalculate_Set_RangeEndPos(PRS, PRP, Depth + 1);
|
|
this.Lines[CurLine].Set_RangeEndPos(CurRange, CurPos);
|
|
};
|
|
var ERecalcPageType = {
|
|
START: 0,
|
|
ELEMENT: 1,
|
|
Y: 2
|
|
};
|
|
function CRecalcPageType() {
|
|
this.Type = ERecalcPageType.START;
|
|
this.Element = null;
|
|
this.Y = -1;
|
|
}
|
|
CRecalcPageType.prototype.Reset = function () {
|
|
this.Type = ERecalcPageType.START;
|
|
this.Element = null;
|
|
this.Y = -1;
|
|
};
|
|
CRecalcPageType.prototype.Set_Element = function (Element) {
|
|
this.Type = ERecalcPageType.Element;
|
|
this.Element = Element;
|
|
};
|
|
CRecalcPageType.prototype.Set_Y = function (Y) {
|
|
this.Type = ERecalcPageType.Y;
|
|
this.Y = Y;
|
|
};
|
|
var paralineinfo_BreakPage = 1;
|
|
var paralineinfo_Empty = 2;
|
|
var paralineinfo_End = 4;
|
|
var paralineinfo_RangeY = 8;
|
|
function CParaLine() {
|
|
this.Y = 0;
|
|
this.Top = 0;
|
|
this.Bottom = 0;
|
|
this.Metrics = new CParaLineMetrics();
|
|
this.Ranges = [];
|
|
this.Info = 0;
|
|
}
|
|
CParaLine.prototype = {
|
|
Add_Range: function (X, XEnd) {
|
|
this.Ranges.push(new CParaLineRange(X, XEnd));
|
|
},
|
|
Shift: function (Dx, Dy) {
|
|
for (var CurRange = 0, RangesCount = this.Ranges.length; CurRange < RangesCount; CurRange++) {
|
|
this.Ranges[CurRange].Shift(Dx, Dy);
|
|
}
|
|
},
|
|
Get_StartPos: function () {
|
|
return this.Ranges[0].StartPos;
|
|
},
|
|
Get_EndPos: function () {
|
|
return this.Ranges[this.Ranges.length - 1].EndPos;
|
|
},
|
|
Set_RangeStartPos: function (CurRange, StartPos) {
|
|
this.Ranges[CurRange].StartPos = StartPos;
|
|
},
|
|
Set_RangeEndPos: function (CurRange, EndPos) {
|
|
this.Ranges[CurRange].EndPos = EndPos;
|
|
},
|
|
Copy: function () {
|
|
var NewLine = new CParaLine();
|
|
NewLine.Y = this.Y;
|
|
NewLine.Top = this.Top;
|
|
NewLine.Bottom = this.Bottom;
|
|
NewLine.Metrics.Ascent = this.Ascent;
|
|
NewLine.Metrics.Descent = this.Descent;
|
|
NewLine.Metrics.TextAscent = this.TextAscent;
|
|
NewLine.Metrics.TextAscent2 = this.TextAscent2;
|
|
NewLine.Metrics.TextDescent = this.TextDescent;
|
|
NewLine.Metrics.LineGap = this.LineGap;
|
|
for (var CurRange = 0, RangesCount = this.Ranges.length; CurRange < RangesCount; CurRange++) {
|
|
NewLine.Ranges[CurRange] = this.Ranges[CurRange].Copy();
|
|
}
|
|
NewLine.Info = this.Info;
|
|
return NewLine;
|
|
},
|
|
Reset: function () {
|
|
this.Top = 0;
|
|
this.Bottom = 0;
|
|
this.Metrics = new CParaLineMetrics();
|
|
this.Ranges = [];
|
|
this.Info = 0;
|
|
}
|
|
};
|
|
function CParaLineMetrics() {
|
|
this.Ascent = 0;
|
|
this.Descent = 0;
|
|
this.TextAscent = 0;
|
|
this.TextAscent2 = 0;
|
|
this.TextDescent = 0;
|
|
this.LineGap = 0;
|
|
}
|
|
CParaLineMetrics.prototype = {
|
|
Update: function (TextAscent, TextAscent2, TextDescent, Ascent, Descent, ParaPr) {
|
|
if (TextAscent > this.TextAscent) {
|
|
this.TextAscent = TextAscent;
|
|
}
|
|
if (TextAscent2 > this.TextAscent2) {
|
|
this.TextAscent2 = TextAscent2;
|
|
}
|
|
if (TextDescent > this.TextDescent) {
|
|
this.TextDescent = TextDescent;
|
|
}
|
|
if (Ascent > this.Ascent) {
|
|
this.Ascent = Ascent;
|
|
}
|
|
if (Descent > this.Descent) {
|
|
this.Descent = Descent;
|
|
}
|
|
if (this.Ascent < this.TextAscent) {
|
|
this.Ascent = this.TextAscent;
|
|
}
|
|
if (this.Descent < this.TextDescent) {
|
|
this.Descent = this.TextDescent;
|
|
}
|
|
this.LineGap = this.Recalculate_LineGap(ParaPr, this.TextAscent, this.TextDescent);
|
|
if (linerule_AtLeast === ParaPr.Spacing.LineRule && (this.Ascent + this.Descent + this.LineGap) > (this.TextAscent + this.TextDescent)) {
|
|
this.Ascent = this.Ascent + this.LineGap;
|
|
this.LineGap = 0;
|
|
}
|
|
},
|
|
Recalculate_LineGap: function (ParaPr, TextAscent, TextDescent) {
|
|
var LineGap = 0;
|
|
switch (ParaPr.Spacing.LineRule) {
|
|
case linerule_Auto:
|
|
LineGap = (TextAscent + TextDescent) * (ParaPr.Spacing.Line - 1);
|
|
break;
|
|
case linerule_Exact:
|
|
var ExactValue = Math.max(25.4 / 72, ParaPr.Spacing.Line);
|
|
LineGap = ExactValue - (TextAscent + TextDescent);
|
|
var Gap = this.Ascent + this.Descent - ExactValue;
|
|
if (Gap > 0) {
|
|
var DescentDiff = this.Descent - this.TextDescent;
|
|
if (DescentDiff > 0) {
|
|
if (DescentDiff < Gap) {
|
|
this.Descent = this.TextDescent;
|
|
Gap -= DescentDiff;
|
|
} else {
|
|
this.Descent -= Gap;
|
|
Gap = 0;
|
|
}
|
|
}
|
|
var AscentDiff = this.Ascent - this.TextAscent;
|
|
if (AscentDiff > 0) {
|
|
if (AscentDiff < Gap) {
|
|
this.Ascent = this.TextAscent;
|
|
Gap -= AscentDiff;
|
|
} else {
|
|
this.Ascent -= Gap;
|
|
Gap = 0;
|
|
}
|
|
}
|
|
if (Gap > 0) {
|
|
var OldTA = this.TextAscent;
|
|
var OldTD = this.TextDescent;
|
|
var Sum = OldTA + OldTD;
|
|
this.Ascent = OldTA * (Sum - Gap) / Sum;
|
|
this.Descent = OldTD * (Sum - Gap) / Sum;
|
|
}
|
|
} else {
|
|
this.Ascent -= Gap;
|
|
}
|
|
LineGap = 0;
|
|
break;
|
|
case linerule_AtLeast:
|
|
var LineGap1 = ParaPr.Spacing.Line;
|
|
var LineGap2 = TextAscent + TextDescent;
|
|
if (Math.abs(LineGap2) < 0.001) {
|
|
LineGap = 0;
|
|
} else {
|
|
LineGap = Math.max(LineGap1, LineGap2) - (TextAscent + TextDescent);
|
|
}
|
|
break;
|
|
}
|
|
return LineGap;
|
|
}
|
|
};
|
|
function CParaLineRange(X, XEnd) {
|
|
this.X = X;
|
|
this.XVisible = 0;
|
|
this.XEnd = XEnd;
|
|
this.StartPos = 0;
|
|
this.EndPos = 0;
|
|
this.W = 0;
|
|
this.Spaces = 0;
|
|
}
|
|
CParaLineRange.prototype = {
|
|
Shift: function (Dx, Dy) {
|
|
this.X += Dx;
|
|
this.XEnd += Dx;
|
|
this.XVisible += Dx;
|
|
},
|
|
Copy: function () {
|
|
var NewRange = new CParaLineRange();
|
|
NewRange.X = this.X;
|
|
NewRange.XVisible = this.XVisible;
|
|
NewRange.XEnd = this.XEnd;
|
|
NewRange.StartPos = this.StartPos;
|
|
NewRange.EndPos = this.EndPos;
|
|
NewRange.W = this.W;
|
|
NewRange.Spaces = this.Spaces;
|
|
return NewRange;
|
|
}
|
|
};
|
|
function CParaPage(X, Y, XLimit, YLimit, FirstLine) {
|
|
this.X = X;
|
|
this.Y = Y;
|
|
this.XLimit = XLimit;
|
|
this.YLimit = YLimit;
|
|
this.FirstLine = FirstLine;
|
|
this.Bounds = new CDocumentBounds(X, Y, XLimit, Y);
|
|
this.StartLine = FirstLine;
|
|
this.EndLine = FirstLine;
|
|
this.TextPr = null;
|
|
this.Drawings = [];
|
|
this.EndInfo = new CParagraphPageEndInfo();
|
|
}
|
|
CParaPage.prototype = {
|
|
Reset: function (X, Y, XLimit, YLimit, FirstLine) {
|
|
this.X = X;
|
|
this.Y = Y;
|
|
this.XLimit = XLimit;
|
|
this.YLimit = YLimit;
|
|
this.FirstLine = FirstLine;
|
|
this.Bounds = new CDocumentBounds(X, Y, XLimit, Y);
|
|
this.StartLine = FirstLine;
|
|
this.Drawings = [];
|
|
},
|
|
Shift: function (Dx, Dy) {
|
|
this.X += Dx;
|
|
this.Y += Dy;
|
|
this.XLimit += Dx;
|
|
this.YLimit += Dy;
|
|
this.Bounds.Shift(Dx, Dy);
|
|
},
|
|
Set_EndLine: function (EndLine) {
|
|
this.EndLine = EndLine;
|
|
},
|
|
Add_Drawing: function (Item) {
|
|
this.Drawings.push(Item);
|
|
},
|
|
Copy: function () {
|
|
var NewPage = new CParaPage();
|
|
NewPage.X = this.X;
|
|
NewPage.Y = this.Y;
|
|
NewPage.XLimit = this.XLimit;
|
|
NewPage.YLimit = this.YLimit;
|
|
NewPage.FirstLine = this.FirstLine;
|
|
NewPage.Bounds.Left = this.Bounds.Left;
|
|
NewPage.Bounds.Right = this.Bounds.Right;
|
|
NewPage.Bounds.Top = this.Bounds.Top;
|
|
NewPage.Bounds.Bottom = this.Bounds.Bottom;
|
|
NewPage.StartLine = this.StartLine;
|
|
NewPage.EndLine = this.EndLine;
|
|
var Count = this.Drawings.length;
|
|
for (var Index = 0; Index < Count; Index++) {
|
|
NewPage.Drawings.push(this.Drawings[Index]);
|
|
}
|
|
NewPage.EndInfo = this.EndInfo.Copy();
|
|
return NewPage;
|
|
}
|
|
};
|
|
function CParagraphRecalculateTabInfo() {
|
|
this.TabPos = 0;
|
|
this.X = 0;
|
|
this.Value = -1;
|
|
this.Item = null;
|
|
}
|
|
CParagraphRecalculateTabInfo.prototype = {
|
|
Reset: function () {
|
|
this.TabPos = 0;
|
|
this.X = 0;
|
|
this.Value = -1;
|
|
this.Item = null;
|
|
}
|
|
};
|
|
function CParagraphRecalculateStateWrap(Para) {
|
|
this.Paragraph = Para;
|
|
this.Page = 0;
|
|
this.Line = 0;
|
|
this.Range = 0;
|
|
this.Ranges = [];
|
|
this.RangesCount = 0;
|
|
this.FirstItemOnLine = true;
|
|
this.EmptyLine = true;
|
|
this.StartWord = false;
|
|
this.Word = false;
|
|
this.AddNumbering = true;
|
|
this.BreakPageLine = false;
|
|
this.UseFirstLine = false;
|
|
this.BreakPageLineEmpty = false;
|
|
this.ExtendBoundToBottom = false;
|
|
this.WordLen = 0;
|
|
this.SpaceLen = 0;
|
|
this.SpacesCount = 0;
|
|
this.LastTab = new CParagraphRecalculateTabInfo();
|
|
this.LineTextAscent = 0;
|
|
this.LineTextDescent = 0;
|
|
this.LineTextAscent2 = 0;
|
|
this.LineAscent = 0;
|
|
this.LineDescent = 0;
|
|
this.LineTop = 0;
|
|
this.LineBottom = 0;
|
|
this.LineTop2 = 0;
|
|
this.LineBottom2 = 0;
|
|
this.LinePrevBottom = 0;
|
|
this.X = 0;
|
|
this.XEnd = 0;
|
|
this.Y = 0;
|
|
this.XStart = 0;
|
|
this.YStart = 0;
|
|
this.XLimit = 0;
|
|
this.YLimit = 0;
|
|
this.NewPage = false;
|
|
this.NewRange = false;
|
|
this.End = false;
|
|
this.RangeY = false;
|
|
this.CurPos = new CParagraphContentPos();
|
|
this.NumberingPos = new CParagraphContentPos();
|
|
this.MoveToLBP = false;
|
|
this.LineBreakPos = new CParagraphContentPos();
|
|
this.PageBreak = null;
|
|
this.SkipPageBreak = false;
|
|
this.RunRecalcInfoLast = null;
|
|
this.RunRecalcInfoBreak = null;
|
|
this.BaseLineOffset = 0;
|
|
this.RecalcResult = 0;
|
|
}
|
|
CParagraphRecalculateStateWrap.prototype = {
|
|
Reset_Line: function () {
|
|
this.RecalcResult = recalcresult_NextLine;
|
|
this.EmptyLine = true;
|
|
this.BreakPageLine = false;
|
|
this.End = false;
|
|
this.UseFirstLine = false;
|
|
this.LineTextAscent = 0;
|
|
this.LineTextAscent2 = 0;
|
|
this.LineTextDescent = 0;
|
|
this.LineAscent = 0;
|
|
this.LineDescent = 0;
|
|
this.NewPage = false;
|
|
this.ForceNewPage = false;
|
|
},
|
|
Reset_Range: function (X, XEnd) {
|
|
this.LastTab.Reset();
|
|
this.SpaceLen = 0;
|
|
this.WordLen = 0;
|
|
this.SpacesCount = 0;
|
|
this.Word = false;
|
|
this.FirstItemOnLine = true;
|
|
this.StartWord = false;
|
|
this.NewRange = false;
|
|
this.X = X;
|
|
this.XEnd = XEnd;
|
|
this.MoveToLBP = false;
|
|
this.LineBreakPos = new CParagraphContentPos();
|
|
},
|
|
Set_LineBreakPos: function (PosObj) {
|
|
this.LineBreakPos.Set(this.CurPos);
|
|
this.LineBreakPos.Add(PosObj);
|
|
},
|
|
Set_NumberingPos: function (PosObj, Item) {
|
|
this.NumberingPos.Set(this.CurPos);
|
|
this.NumberingPos.Add(PosObj);
|
|
this.Paragraph.Numbering.Pos = this.NumberingPos;
|
|
this.Paragraph.Numbering.Item = Item;
|
|
},
|
|
Update_CurPos: function (PosObj, Depth) {
|
|
this.CurPos.Update(PosObj, Depth);
|
|
},
|
|
Reset_Ranges: function () {
|
|
this.Ranges = [];
|
|
this.RangesCount = 0;
|
|
},
|
|
Reset_PageBreak: function () {
|
|
this.PageBreak = null;
|
|
this.SkipPageBreak = false;
|
|
this.ExtendBoundToBottom = false;
|
|
},
|
|
Reset_RunRecalcInfo: function () {
|
|
this.RunRecalcInfoBreak = this.RunRecalcInfoLast;
|
|
},
|
|
Restore_RunRecalcInfo: function () {
|
|
this.RunRecalcInfoLast = this.RunRecalcInfoBreak;
|
|
}
|
|
};
|
|
function CParagraphRecalculateStateCounter() {
|
|
this.Paragraph = undefined;
|
|
this.Range = undefined;
|
|
this.Word = false;
|
|
this.SpaceLen = 0;
|
|
this.SpacesCount = 0;
|
|
this.Words = 0;
|
|
this.Spaces = 0;
|
|
this.Letters = 0;
|
|
this.SpacesSkip = 0;
|
|
this.LettersSkip = 0;
|
|
}
|
|
CParagraphRecalculateStateCounter.prototype = {
|
|
Reset: function (Paragraph, Range) {
|
|
this.Paragraph = Paragraph;
|
|
this.Range = Range;
|
|
this.Word = false;
|
|
this.SpaceLen = 0;
|
|
this.SpacesCount = 0;
|
|
this.Words = 0;
|
|
this.Spaces = 0;
|
|
this.Letters = 0;
|
|
this.SpacesSkip = 0;
|
|
this.LettersSkip = 0;
|
|
}
|
|
};
|
|
function CParagraphRecalculateStateAlign() {
|
|
this.X = 0;
|
|
this.Y = 0;
|
|
this.XEnd = 0;
|
|
this.JustifyWord = 0;
|
|
this.JustifySpace = 0;
|
|
this.SpacesCounter = 0;
|
|
this.SpacesSkip = 0;
|
|
this.LettersSkip = 0;
|
|
this.LastW = 0;
|
|
this.Paragraph = undefined;
|
|
this.RecalcResult = 0;
|
|
this.CurPage = 0;
|
|
this.PageY = 0;
|
|
this.RecalcFast = false;
|
|
this.RecalcFast2 = false;
|
|
}
|
|
function CParagraphRecalculateStateInfo() {
|
|
this.Comments = [];
|
|
}
|
|
CParagraphRecalculateStateInfo.prototype = {
|
|
Reset: function (PrevInfo) {
|
|
if (null !== PrevInfo && undefined !== PrevInfo) {
|
|
this.Comments = PrevInfo.Comments;
|
|
} else {
|
|
this.Comments = [];
|
|
}
|
|
},
|
|
Add_Comment: function (Id) {
|
|
this.Comments.push(Id);
|
|
},
|
|
Remove_Comment: function (Id) {
|
|
var CommentsLen = this.Comments.length;
|
|
for (var CurPos = 0; CurPos < CommentsLen; CurPos++) {
|
|
if (this.Comments[CurPos] === Id) {
|
|
this.Comments.splice(CurPos, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
function CParagraphRecalculateObject() {
|
|
this.X = 0;
|
|
this.Y = 0;
|
|
this.XLimit = 0;
|
|
this.YLimit = 0;
|
|
this.Pages = [];
|
|
this.Lines = [];
|
|
this.Content = [];
|
|
}
|
|
CParagraphRecalculateObject.prototype = {
|
|
Save: function (Para) {
|
|
this.X = Para.X;
|
|
this.Y = Para.Y;
|
|
this.XLimit = Para.XLimit;
|
|
this.YLimit = Para.YLimit;
|
|
this.Pages = Para.Pages;
|
|
this.Lines = Para.Lines;
|
|
var Content = Para.Content;
|
|
var Count = Content.length;
|
|
for (var Index = 0; Index < Count; Index++) {
|
|
this.Content[Index] = Content[Index].Save_RecalculateObject();
|
|
}
|
|
},
|
|
Load: function (Para) {
|
|
Para.X = this.X;
|
|
Para.Y = this.Y;
|
|
Para.XLimit = this.XLimit;
|
|
Para.YLimit = this.YLimit;
|
|
Para.Pages = this.Pages;
|
|
Para.Lines = this.Lines;
|
|
var Count = Para.Content.length;
|
|
for (var Index = 0; Index < Count; Index++) {
|
|
Para.Content[Index].Load_RecalculateObject(this.Content[Index], Para);
|
|
}
|
|
},
|
|
Get_DrawingFlowPos: function (FlowPos) {
|
|
var Count = this.Content.length;
|
|
for (var Index = 0; Index < Count; Index++) {
|
|
this.Content[Index].Get_DrawingFlowPos(FlowPos);
|
|
}
|
|
}
|
|
}; |