Yajbir Singh
983 lines
37 KiB
JavaScript
983 lines
37 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";
|
|
(function (window, undefined){
|
|
|
|
|
|
/**
|
|
* CDrawingDocContent
|
|
* @constructor
|
|
* @extends {CDocumentContent}
|
|
*/
|
|
function CDrawingDocContent(Parent, DrawingDocument, X, Y, XLimit, YLimit) {
|
|
CDocumentContent.call(this, Parent, DrawingDocument, X, Y, XLimit, YLimit, false, false, true);
|
|
this.FullRecalc = new CDocumentRecalculateState();
|
|
this.AllFields = [];
|
|
}
|
|
|
|
CDrawingDocContent.prototype = Object.create(CDocumentContent.prototype);
|
|
CDrawingDocContent.prototype.constructor = CDrawingDocContent;
|
|
|
|
CDrawingDocContent.prototype.CalculateAllFields = function () {
|
|
var aParagraphs = this.Content;
|
|
this.AllFields.length = 0;
|
|
for(var i = 0; i < aParagraphs.length; ++i){
|
|
var aContent = aParagraphs[i].Content;
|
|
for(var j = 0; j < aContent.length; ++j){
|
|
if(aContent[j] instanceof AscCommonWord.CPresentationField){
|
|
this.AllFields.push(aContent[j]);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.CanAddComment = function() {
|
|
return false;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.getFontSizeForConstr = function () {
|
|
return this.Content.reduce(function (pAcc, paragraph) {
|
|
var maxFontSizeInParagraph = paragraph.Content.reduce(function (acc, paraRun) {
|
|
return paraRun.Pr && paraRun.Pr.FontSize && paraRun.Pr.FontSize > acc ? paraRun.Pr.FontSize : acc;
|
|
}, 0);
|
|
return maxFontSizeInParagraph > pAcc ? maxFontSizeInParagraph : pAcc;
|
|
}, 0);
|
|
};
|
|
|
|
CDrawingDocContent.prototype.getBulletImages = function (arrImages) {
|
|
var aParagraphs = this.Content;
|
|
var sImageId;
|
|
for(var nPar = 0; nPar < aParagraphs.length; ++nPar)
|
|
{
|
|
var oPr = aParagraphs[nPar].Pr;
|
|
if(oPr.Bullet)
|
|
{
|
|
sImageId = oPr.Bullet.getImageBulletURL();
|
|
if(sImageId)
|
|
{
|
|
arrImages.push(sImageId);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.GetFieldByType = function (sType) {
|
|
var sType_ = sType.toLowerCase();
|
|
var oField;
|
|
for(var i = 0; i < this.AllFields.length; ++i){
|
|
oField = this.AllFields[i];
|
|
if(oField.GetFieldType() === sType_){
|
|
return oField;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.GetFieldByType2 = function (sType) {
|
|
var sType_ = sType.toLowerCase();
|
|
var oField;
|
|
var sFieldType;
|
|
for(var i = 0; i < this.AllFields.length; ++i){
|
|
oField = this.AllFields[i];
|
|
sFieldType = oField.GetFieldType();
|
|
if(typeof sFieldType === "string" && sFieldType.indexOf(sType_) === 0){
|
|
return oField;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.GetAllDrawingObjects = function(arrDrawings){
|
|
if (undefined === arrDrawings || null === arrDrawings)
|
|
arrDrawings = [];
|
|
return arrDrawings;
|
|
};
|
|
CDrawingDocContent.prototype.GetSummaryHeight = function(){
|
|
var fSummHeight = 0;
|
|
var nColumnsCount = this.GetColumnCount();
|
|
for(var i = 0; i < this.Pages.length; ++i){
|
|
var oPage = this.Pages[i];
|
|
var fPageHeight = 0;
|
|
if(oPage.Sections.length > 0){
|
|
var aColumns = oPage.Sections[0].Columns;
|
|
for(var j = 0; j < aColumns.length; ++j){
|
|
var oColumn = aColumns[j];
|
|
for(var k = oColumn.Pos; k <= oColumn.EndPos; ++k){
|
|
var nElementPageIndex = this.private_GetElementPageIndex(k, i, j, nColumnsCount);
|
|
var fParagraphPageBottom = this.Content[k].Get_PageBounds(nElementPageIndex).Bottom;
|
|
if(fPageHeight < fParagraphPageBottom){
|
|
fPageHeight = fParagraphPageBottom;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
var Bounds = this.Get_PageBounds(i);
|
|
fPageHeight = Bounds.Bottom - Bounds.Top;
|
|
}
|
|
fSummHeight += fPageHeight;
|
|
}
|
|
return fSummHeight;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.GetSummaryHeight_ =function () {
|
|
var dHeight = 0.0;
|
|
for(var i = 0; i < this.Content.length; ++i){
|
|
var oElement = this.Content[i];
|
|
if(oElement.GetType() === type_Paragraph){
|
|
for(var j = 0; j < oElement.Lines.length; ++j){
|
|
var oLine = oElement.Lines[j];
|
|
dHeight += (oLine.Bottom - oLine.Top - oLine.Metrics.Descent);
|
|
}
|
|
}
|
|
}
|
|
return dHeight;
|
|
};
|
|
|
|
// function to find the maximum width of the text inside the rect, as each line contains different widths
|
|
CDrawingDocContent.prototype.GetSummaryWidth =function () {
|
|
// width of single line label
|
|
let width = 20000;
|
|
if (!this.Content || !Array.isArray(this.Content )) {
|
|
return width;
|
|
}
|
|
const lines = this.Content[0].Lines;
|
|
if (lines && Array.isArray(lines)) {
|
|
for (let i = 0; i < lines.length; i++) {
|
|
const newWidth = lines[i] && lines[i].Ranges && Array.isArray(lines[i].Ranges) && lines[i].Ranges.length > 0 ? lines[i].Ranges[0].W : null;
|
|
if (newWidth !== null && (i === 0 || width < newWidth)) {
|
|
width = newWidth;
|
|
}
|
|
}
|
|
}
|
|
|
|
return width;
|
|
};
|
|
|
|
// function to find the width of the unfolded 2d array, simply add width of each line
|
|
CDrawingDocContent.prototype.getUnfoldedWidth = function (nLines) {
|
|
// width of single line label
|
|
if (!this.Content || !Array.isArray(this.Content )) {
|
|
return 20000;
|
|
}
|
|
let width = 0;
|
|
const boxError = 0.1;
|
|
const lines = this.Content[0].Lines;
|
|
if (lines && Array.isArray(lines)) {
|
|
for (let i = 0; i < nLines; i++) {
|
|
if (lines.length < i) {
|
|
break;
|
|
}
|
|
const newWidth = lines[i] && lines[i].Ranges && Array.isArray(lines[i].Ranges) && lines[i].Ranges.length > 0 ? lines[i].Ranges[0].W : null;
|
|
if (newWidth !== null) {
|
|
width += newWidth;
|
|
}
|
|
}
|
|
}
|
|
|
|
return width + boxError;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.GetColumnCount = function(){
|
|
var nColumnCount = 1;
|
|
if(this.Parent.getBodyPr){
|
|
var oBodyPr = this.Parent.getBodyPr();
|
|
nColumnCount = AscFormat.isRealNumber(oBodyPr.numCol) ? oBodyPr.numCol : 1;
|
|
}
|
|
return nColumnCount;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.GetPageContentFrame = function(page, sectPr){
|
|
return this._GetColumnContentFrame(0);
|
|
};
|
|
|
|
CDrawingDocContent.prototype.GetColumnContentFrame = function(page, column, sectPr){
|
|
return this._GetColumnContentFrame(column);
|
|
};
|
|
|
|
CDrawingDocContent.prototype._GetColumnContentFrame = function(nColumnIndex){
|
|
|
|
var X = this.X;
|
|
var Y = this.Y;
|
|
var XLimit = this.XLimit;
|
|
var YLimit = this.YLimit;
|
|
var ColumnSpaceBefore = 0;
|
|
var ColumnSpaceAfter = 0;
|
|
var nNumCol = this.GetColumnCount();
|
|
var oBodyPr = this.Parent.getBodyPr && this.Parent.getBodyPr();
|
|
if(nNumCol > 1 && oBodyPr)
|
|
{
|
|
var fSpace = AscFormat.isRealNumber(oBodyPr.spcCol) ? oBodyPr.spcCol : 0;
|
|
fSpace = Math.min(fSpace, this.XLimit/(nNumCol - 1));
|
|
var fColumnWidth = Math.max((this.XLimit - this.X - (nNumCol - 1)*fSpace)/nNumCol, 0);
|
|
X += nColumnIndex*(fColumnWidth + fSpace);
|
|
XLimit = X + fColumnWidth;
|
|
if(nColumnIndex > 0)
|
|
{
|
|
ColumnSpaceBefore = fSpace;
|
|
}
|
|
if(nColumnIndex < nNumCol - 1)
|
|
{
|
|
ColumnSpaceAfter = fSpace;
|
|
}
|
|
}
|
|
return {
|
|
X : X,
|
|
Y : Y,
|
|
XLimit : XLimit,
|
|
YLimit : YLimit,
|
|
ColumnSpaceBefore : ColumnSpaceBefore,
|
|
ColumnSpaceAfter : ColumnSpaceAfter
|
|
};
|
|
};
|
|
|
|
|
|
CDrawingDocContent.prototype.RecalculateContent = function(fWidth, fHeight, nStartPage){
|
|
this.Recalculated = true;
|
|
this.CalculateAllFields();
|
|
if(this.GetColumnCount() === 1){
|
|
CDocumentContent.prototype.RecalculateContent.call(this, fWidth, fHeight, nStartPage);
|
|
}
|
|
else{
|
|
this.Start_Recalculate(fWidth, fHeight);
|
|
if(this.Pages.length > 1){
|
|
var fSummaryHeight = this.GetSummaryHeight();
|
|
|
|
var fLow = fHeight, fHigh = fSummaryHeight;
|
|
this.Start_Recalculate(fWidth, fHigh);
|
|
var nItCount = 0;
|
|
while(this.Pages.length > 1 && nItCount < 5){
|
|
fHigh += fSummaryHeight;
|
|
this.Start_Recalculate(fWidth, fHigh);
|
|
++nItCount;
|
|
}
|
|
var fNeedHeight = fHigh;
|
|
if(this.GetColumnCount() > 1){
|
|
while((fHigh - fLow) > 0.1){
|
|
var fCheckHeight = fLow + (fHigh - fLow)/2;
|
|
this.Start_Recalculate(fWidth, fCheckHeight);
|
|
if(this.Pages.length > 1){
|
|
fLow = fCheckHeight;
|
|
}
|
|
else{
|
|
fHigh = fCheckHeight;
|
|
fNeedHeight = fCheckHeight;
|
|
}
|
|
}
|
|
}
|
|
this.Start_Recalculate(fWidth, fNeedHeight + 0.01);
|
|
}
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Start_Recalculate = function(fWidth, fHeight){
|
|
this.FullRecalc.PageIndex = 0;
|
|
this.FullRecalc.SectionIndex = 0;
|
|
this.FullRecalc.ColumnIndex = 0;
|
|
this.FullRecalc.StartIndex = 0;
|
|
this.FullRecalc.Start = true;
|
|
this.FullRecalc.StartPage = 0;
|
|
this.Reset(0, 0, fWidth, fHeight);
|
|
this.Recalculate_PageDrawing();
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Recalculate_PageDrawing = function()
|
|
{
|
|
var nColumnsCount = this.GetColumnCount();
|
|
var nPageIndex = this.FullRecalc.PageIndex;
|
|
this.Pages.length = nPageIndex + 1;
|
|
if(0 === this.FullRecalc.ColumnIndex && true === this.FullRecalc.Start)
|
|
{
|
|
var oPage = new AscWord.DocumentPage();
|
|
oPage.Pos = this.FullRecalc.StartIndex;
|
|
oPage.Sections[0] = new AscWord.DocumentPageSection();
|
|
for (var i = 0; i < nColumnsCount; ++i)
|
|
{
|
|
oPage.Sections[0].Columns[i] = new AscWord.DocumentPageColumn();
|
|
}
|
|
this.Pages[nPageIndex] = oPage;
|
|
}
|
|
this.Recalculate_PageColumn();
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Recalculate_PageColumn = function()
|
|
{
|
|
var nPageIndex = this.FullRecalc.PageIndex;
|
|
var nColumnIndex = this.FullRecalc.ColumnIndex;
|
|
var nStartIndex = this.FullRecalc.StartIndex;
|
|
|
|
var oStartPos = this._GetColumnContentFrame(nColumnIndex);
|
|
var X = oStartPos.X;
|
|
var Y = oStartPos.Y;
|
|
var XLimit = oStartPos.XLimit;
|
|
var YLimit = oStartPos.YLimit;
|
|
|
|
var nColumnsCount = this.GetColumnCount();
|
|
|
|
var aContent = this.Content;
|
|
var nCount = aContent.length;
|
|
var nRecalcResult = recalcresult_NextPage;
|
|
var oParagraph;
|
|
var bContinue = false;
|
|
|
|
var oPage = this.Pages[nPageIndex];
|
|
var oSection = oPage.Sections[0];
|
|
var oColumn = oSection.Columns[nColumnIndex];
|
|
oColumn.X = X;
|
|
oColumn.XLimit = XLimit;
|
|
oColumn.Y = Y;
|
|
oColumn.YLimit = YLimit;
|
|
oColumn.Pos = nStartIndex;
|
|
oColumn.Empty = false;
|
|
oColumn.SpaceBefore = oStartPos.ColumnSpaceBefore;
|
|
oColumn.SpaceAfter = oStartPos.ColumnSpaceAfter;
|
|
for(var i = nStartIndex; i < nCount; ++i)
|
|
{
|
|
oParagraph = this.Content[i];
|
|
|
|
if((0 === i && 0 === nPageIndex && 0 === nColumnIndex) || i != nStartIndex || (i === nStartIndex && true === this.FullRecalc.ResetStartElement))
|
|
{
|
|
oParagraph.Set_DocumentIndex(i);
|
|
oParagraph.Reset(X, Y, XLimit, YLimit, nPageIndex, nColumnIndex, nColumnsCount);
|
|
}
|
|
var nElementPageIndex = this.private_GetElementPageIndex(i, nPageIndex, nColumnIndex, nColumnsCount);
|
|
nRecalcResult = oParagraph.Recalculate_Page(nElementPageIndex);
|
|
if(nRecalcResult & recalcresult_NextElement)
|
|
{
|
|
Y = oParagraph.Get_PageBounds(nElementPageIndex).Bottom;
|
|
}
|
|
oColumn.Bounds.Bottom = Y;
|
|
if (nRecalcResult & recalcresult_CurPage)
|
|
{
|
|
if (nRecalcResult & recalcresultflags_Column)
|
|
{
|
|
this.FullRecalc.ColumnIndex = nColumnIndex;
|
|
}
|
|
else
|
|
{
|
|
this.FullRecalc.ColumnIndex = 0;
|
|
}
|
|
bContinue = true;
|
|
break;
|
|
}
|
|
else if(nRecalcResult & recalcresult_NextPage)
|
|
{
|
|
if (nRecalcResult & recalcresultflags_LastFromNewColumn)
|
|
{
|
|
oColumn.EndPos = i - 1;
|
|
oSection.EndPos = i - 1;
|
|
oPage.EndPos = i - 1;
|
|
bContinue = true;
|
|
this.FullRecalc.ColumnIndex = nColumnIndex + 1;
|
|
this.FullRecalc.PageIndex = nPageIndex;
|
|
this.FullRecalc.StartIndex = i;
|
|
this.FullRecalc.Start = true;
|
|
if (this.FullRecalc.ColumnIndex >= nColumnsCount)
|
|
{
|
|
this.FullRecalc.ColumnIndex = 0;
|
|
this.FullRecalc.PageIndex = nPageIndex + 1;
|
|
}
|
|
break;
|
|
}
|
|
else if (nRecalcResult & recalcresultflags_LastFromNewPage)
|
|
{
|
|
oColumn.EndPos = i - 1;
|
|
oSection.EndPos = i - 1;
|
|
oPage.EndPos = i - 1;
|
|
bContinue = true;
|
|
this.FullRecalc.SectionIndex = 0;
|
|
this.FullRecalc.ColumnIndex = 0;
|
|
this.FullRecalc.PageIndex = nPageIndex + 1;
|
|
this.FullRecalc.StartIndex = i;
|
|
this.FullRecalc.Start = true;
|
|
if (oColumn.EndPos === oColumn.Pos)
|
|
{
|
|
var Element = this.Content[oColumn.Pos];
|
|
var ElementPageIndex = this.private_GetElementPageIndex(i, nPageIndex, nColumnIndex, nColumnsCount);
|
|
if (true === Element.IsEmptyPage(ElementPageIndex))
|
|
oColumn.Empty = true;
|
|
}
|
|
for (var TempColumnIndex = nColumnIndex + 1; TempColumnIndex < nColumnsCount; ++TempColumnIndex)
|
|
{
|
|
oSection.Columns[TempColumnIndex].Empty = true;
|
|
oSection.Columns[TempColumnIndex].Pos = i;
|
|
oSection.Columns[TempColumnIndex].EndPos = i - 1;
|
|
}
|
|
break;
|
|
}
|
|
else if (nRecalcResult & recalcresultflags_Page)
|
|
{
|
|
oColumn.EndPos = i;
|
|
oSection.EndPos = i;
|
|
oPage.EndPos = i;
|
|
|
|
bContinue = true;
|
|
|
|
this.FullRecalc.SectionIndex = 0;
|
|
this.FullRecalc.ColumnIndex = 0;
|
|
this.FullRecalc.PageIndex = nPageIndex + 1;
|
|
this.FullRecalc.StartIndex = i;
|
|
this.FullRecalc.Start = true;
|
|
|
|
if (oColumn.EndPos === oColumn.Pos)
|
|
{
|
|
var Element = this.Content[oColumn.Pos];
|
|
var ElementPageIndex = this.private_GetElementPageIndex(i, nPageIndex, nColumnIndex, nColumnsCount);
|
|
if (true === Element.IsEmptyPage(nElementPageIndex))
|
|
oColumn.Empty = true;
|
|
}
|
|
for (var TempColumnIndex = nColumnIndex + 1; TempColumnIndex < nColumnsCount; ++TempColumnIndex)
|
|
{
|
|
var ElementPageIndex = this.private_GetElementPageIndex(i, nPageIndex, TempColumnIndex, nColumnsCount);
|
|
this.Content[i].Recalculate_SkipPage(ElementPageIndex);
|
|
oSection.Columns[TempColumnIndex].Empty = true;
|
|
oSection.Columns[TempColumnIndex].Pos = i;
|
|
oSection.Columns[TempColumnIndex].EndPos = i - 1;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
oColumn.EndPos = i;
|
|
oSection.EndPos = i;
|
|
oPage.EndPos = i;
|
|
|
|
bContinue = true;
|
|
|
|
this.FullRecalc.ColumnIndex = nColumnIndex + 1;
|
|
if (this.FullRecalc.ColumnIndex >= nColumnsCount)
|
|
{
|
|
this.FullRecalc.SectionIndex = 0;
|
|
this.FullRecalc.ColumnIndex = 0;
|
|
this.FullRecalc.PageIndex = nPageIndex + 1;
|
|
}
|
|
|
|
this.FullRecalc.StartIndex = i;
|
|
this.FullRecalc.Start = true;
|
|
|
|
if (oColumn.EndPos === oColumn.Pos)
|
|
{
|
|
var Element = this.Content[oColumn.Pos];
|
|
var ElementPageIndex = this.private_GetElementPageIndex(i, nPageIndex, nColumnIndex, nColumnsCount);
|
|
if (true === Element.IsEmptyPage(ElementPageIndex))
|
|
oColumn.Empty = true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (i === nCount)
|
|
{
|
|
oPage.EndPos = nCount - 1;
|
|
oSection.EndPos = nCount - 1;
|
|
oColumn.EndPos = nCount - 1;
|
|
}
|
|
if(bContinue)
|
|
{
|
|
this.Recalculate_PageDrawing();
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Draw = function(nPageIndex, pGraphics){
|
|
if(this.Pages.length > 0){
|
|
|
|
var oSection = this.Pages[0].Sections[0];
|
|
if(oSection){
|
|
|
|
pGraphics.Start_Command(AscFormat.DRAW_COMMAND_CONTENT);
|
|
|
|
for (var ColumnIndex = 0, ColumnsCount = oSection.Columns.length; ColumnIndex < ColumnsCount; ++ColumnIndex)
|
|
{
|
|
var Column = oSection.Columns[ColumnIndex];
|
|
var ColumnStartPos = Column.Pos;
|
|
var ColumnEndPos = Column.EndPos;
|
|
|
|
// Плавающие объекты не должны попадать в клип колонок
|
|
var FlowElements = [];
|
|
|
|
if (ColumnsCount > 1)
|
|
{
|
|
// pGraphics.SaveGrState();
|
|
|
|
var X = ColumnIndex === 0 ? 0 : Column.X - Column.SpaceBefore / 2;
|
|
// var XEnd = (ColumnIndex >= ColumnsCount - 1 ? Page.Width : Column.XLimit + Column.SpaceAfter / 2);
|
|
// pGraphics.AddClipRect(X, 0, XEnd - X, Page.Height);
|
|
}
|
|
|
|
for (var ContentPos = ColumnStartPos; ContentPos <= ColumnEndPos; ++ContentPos)
|
|
{
|
|
var ElementPageIndex = this.private_GetElementPageIndex(ContentPos, 0, ColumnIndex, ColumnsCount);
|
|
this.Content[ContentPos].Draw(ElementPageIndex, pGraphics);
|
|
}
|
|
|
|
/*if (ColumnsCount > 1)
|
|
{
|
|
pGraphics.RestoreGrState();
|
|
}*/
|
|
}
|
|
|
|
pGraphics.End_Command();
|
|
}
|
|
|
|
else{
|
|
CDocumentContent.prototype.Draw.call(this, nPageIndex, pGraphics);
|
|
}
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Write_ToBinary2 = function(oWriter){
|
|
oWriter.WriteLong(AscDFH.historyitem_type_DrawingContent);
|
|
CDocumentContent.prototype.Write_ToBinary2.call(this, oWriter);
|
|
};
|
|
CDrawingDocContent.prototype.Read_FromBinary2 = function(oReader){
|
|
oReader.GetLong();//type of DocumentContent
|
|
CDocumentContent.prototype.Read_FromBinary2.call(this, oReader);
|
|
};
|
|
CDrawingDocContent.prototype.IsTableCellContent = function(isReturnCell){
|
|
|
|
if (true === isReturnCell)
|
|
return null;
|
|
|
|
return false;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Is_ChartTitleContent = function(){
|
|
if(this.Parent instanceof AscFormat.CTextBody &&
|
|
this.Parent.parent instanceof AscFormat.CTitle){
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.DrawSelectionOnPage = function(PageIndex, clipInfo){
|
|
var CurPage = PageIndex;
|
|
if (CurPage < 0 || CurPage >= this.Pages.length)
|
|
return;
|
|
var Pos_start = this.Pages[CurPage].Pos;
|
|
var Pos_end = this.Pages[CurPage].EndPos;
|
|
|
|
clipInfo = this.IntersectClip(clipInfo, PageIndex);
|
|
|
|
if (true === this.Selection.Use)
|
|
{
|
|
if(this.Selection.Flag === selectionflag_Common)
|
|
{
|
|
var Start = this.Selection.StartPos;
|
|
var End = this.Selection.EndPos;
|
|
|
|
if (Start > End)
|
|
{
|
|
Start = this.Selection.EndPos;
|
|
End = this.Selection.StartPos;
|
|
}
|
|
|
|
var Start = Math.max(Start, Pos_start);
|
|
var End = Math.min(End, Pos_end);
|
|
|
|
var Page = this.Pages[PageIndex];
|
|
if(this.Pages[PageIndex].Sections.length === 0){
|
|
for (var Index = Start; Index <= End; Index++)
|
|
{
|
|
var ElementPageIndex = this.private_GetElementPageIndex(Index, CurPage, 0, 1);
|
|
this.Content[Index].DrawSelectionOnPage(ElementPageIndex, clipInfo);
|
|
}
|
|
}
|
|
else{
|
|
var PageSection = Page.Sections[0];
|
|
for (var ColumnIndex = 0, ColumnsCount = PageSection.Columns.length; ColumnIndex < ColumnsCount; ++ColumnIndex)
|
|
{
|
|
var Pos_start = Page.Pos;
|
|
var Pos_end = Page.EndPos;
|
|
|
|
var Start = this.Selection.StartPos;
|
|
var End = this.Selection.EndPos;
|
|
|
|
if (Start > End)
|
|
{
|
|
Start = this.Selection.EndPos;
|
|
End = this.Selection.StartPos;
|
|
}
|
|
|
|
var Start = Math.max(Start, Pos_start);
|
|
var End = Math.min(End, Pos_end);
|
|
|
|
for (var Index = Start; Index <= End; ++Index)
|
|
{
|
|
var ElementPage = this.private_GetElementPageIndex(Index, 0, ColumnIndex, ColumnsCount);
|
|
this.Content[Index].DrawSelectionOnPage(ElementPage, clipInfo);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Internal_GetContentPosByXY = function(X, Y, PageNum)
|
|
{
|
|
if (undefined === PageNum || null === PageNum)
|
|
PageNum = this.CurPage;
|
|
// Теперь проверим пустые параграфы с окончанием секций
|
|
var SectCount = this.Pages[PageNum].EndSectionParas.length;
|
|
if(this.Pages[PageNum].Sections.length === 0){
|
|
return CDocumentContent.prototype.Internal_GetContentPosByXY.call(this, X, Y, PageNum);
|
|
}
|
|
for (var Index = 0; Index < SectCount; ++Index)
|
|
{
|
|
var Item = this.Pages[PageNum].EndSectionParas[Index];
|
|
var Bounds = Item.Pages[0].Bounds;
|
|
|
|
if (Y < Bounds.Bottom && Y > Bounds.Top && X > Bounds.Left && X < Bounds.Right)
|
|
return Item.Index;
|
|
}
|
|
|
|
// Сначала мы определим секцию и колонку, в которую попали
|
|
var Page = this.Pages[PageNum];
|
|
|
|
var SectionIndex = 0;
|
|
for (var SectionsCount = Page.Sections.length; SectionIndex < SectionsCount - 1; ++SectionIndex)
|
|
{
|
|
if (Y < Page.Sections[SectionIndex + 1].Y)
|
|
break;
|
|
}
|
|
|
|
var PageSection = this.Pages[PageNum].Sections[SectionIndex];
|
|
var ColumnsCount = PageSection.Columns.length;
|
|
var ColumnIndex = 0;
|
|
for (; ColumnIndex < ColumnsCount - 1; ++ColumnIndex)
|
|
{
|
|
if (X < (PageSection.Columns[ColumnIndex].XLimit + PageSection.Columns[ColumnIndex + 1].X) / 2)
|
|
break;
|
|
}
|
|
|
|
// TODO: Разобраться с ситуацией, когда пустые колонки стоят не только в конце
|
|
while (ColumnIndex > 0 && true === PageSection.Columns[ColumnIndex].Empty)
|
|
ColumnIndex--;
|
|
|
|
var Column = PageSection.Columns[ColumnIndex];
|
|
var StartPos = Column.Pos;
|
|
var EndPos = Column.EndPos;
|
|
|
|
for (var Pos = StartPos; Pos < EndPos; ++Pos)
|
|
{
|
|
var Item = this.Content[Pos + 1];
|
|
var PageBounds = Item.Get_PageBounds(0);
|
|
if (Y < PageBounds.Top)
|
|
return Pos;
|
|
}
|
|
|
|
if (Pos === EndPos)
|
|
{
|
|
return EndPos;
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.private_GetElementPageIndexByXY = function(ElementPos, X, Y, PageIndex){
|
|
if(this.Pages.length > 0){
|
|
if(this.Pages[0].Sections.length > 0){
|
|
return CDocument_prototype_private_GetElementPageIndexByXY.call(this, ElementPos, X, Y, PageIndex);
|
|
}
|
|
}
|
|
return CDocumentContent.prototype.private_GetElementPageIndexByXY.call(this, ElementPos, X, Y, PageIndex);
|
|
};
|
|
CDrawingDocContent.prototype.Copy = function(Parent, DrawingDocument)
|
|
{
|
|
var DC = new CDrawingDocContent(Parent, DrawingDocument ? DrawingDocument : this.DrawingDocument, 0, 0, 0, 0, this.Split, this.TurnOffInnerWrap, this.bPresentation);
|
|
|
|
// Копируем содержимое
|
|
DC.Internal_Content_RemoveAll();
|
|
|
|
var Count = this.Content.length;
|
|
for (var Index = 0; Index < Count; Index++)
|
|
{
|
|
DC.Internal_Content_Add(Index, this.Content[Index].Copy(DC, DrawingDocument, {}), false);
|
|
}
|
|
|
|
return DC;
|
|
};
|
|
CDrawingDocContent.prototype.Copy3 = function(Parent)//для заголовков диаграмм
|
|
{
|
|
var DC = new CDrawingDocContent(Parent, this.DrawingDocument, 0, 0, 0, 0, this.Split, this.TurnOffInnerWrap, true);
|
|
|
|
// Копируем содержимое
|
|
DC.Internal_Content_RemoveAll();
|
|
|
|
var Count = this.Content.length;
|
|
for (var Index = 0; Index < Count; Index++)
|
|
{
|
|
DC.Internal_Content_Add(Index, this.Content[Index].Copy2(DC), false);
|
|
}
|
|
return DC;
|
|
};
|
|
|
|
CDrawingDocContent.prototype.Recalculate = function()
|
|
{
|
|
|
|
if(typeof editor !== "undefined" && editor &&
|
|
(editor.isPresentationEditor || editor.isDocumentEditor)){
|
|
if(editor.WordControl && editor.WordControl.m_oLogicDocument){
|
|
editor.WordControl.m_oLogicDocument.Recalculate();
|
|
}
|
|
}
|
|
else{
|
|
if(this.Parent){
|
|
if(this.Parent instanceof AscFormat.CShape){
|
|
this.Parent.recalculateContent();
|
|
return;
|
|
}
|
|
else if(this.Parent && this.Parent.parent){
|
|
if(this.Parent.parent instanceof AscFormat.CShape){
|
|
this.Parent.parent.recalculateContent();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if(this.XLimit > 0){
|
|
this.Recalculate_PageDrawing();
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
CDrawingDocContent.prototype.ClearParagraphFormatting = function(isClearParaPr, isClearTextPr)
|
|
{
|
|
if (true === this.ApplyToAll)
|
|
{
|
|
for (var Index = 0; Index < this.Content.length; Index++)
|
|
{
|
|
var Item = this.Content[Index];
|
|
Item.SetApplyToAll(true);
|
|
Item.ClearParagraphFormatting(isClearParaPr, isClearTextPr);
|
|
Item.SetApplyToAll(false);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (docpostype_DrawingObjects == this.CurPos.Type)
|
|
{
|
|
return this.LogicDocument.DrawingObjects.paragraphClearFormatting(isClearParaPr, isClearTextPr);
|
|
}
|
|
else //if ( docpostype_Content === this.CurPos.Type )
|
|
{
|
|
if (true === this.Selection.Use)
|
|
{
|
|
if (selectionflag_Common === this.Selection.Flag)
|
|
{
|
|
var StartPos = this.Selection.StartPos;
|
|
var EndPos = this.Selection.EndPos;
|
|
if (StartPos > EndPos)
|
|
{
|
|
var Temp = StartPos;
|
|
StartPos = EndPos;
|
|
EndPos = Temp;
|
|
}
|
|
|
|
for (var Index = StartPos; Index <= EndPos; Index++)
|
|
{
|
|
var Item = this.Content[Index];
|
|
Item.ClearParagraphFormatting(isClearParaPr, isClearTextPr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var Item = this.Content[this.CurPos.ContentPos];
|
|
Item.ClearParagraphFormatting(isClearParaPr, isClearTextPr);
|
|
}
|
|
}
|
|
};
|
|
CDrawingDocContent.prototype.Is_Empty = function(bDefault)
|
|
{
|
|
if (!bDefault) {
|
|
if (this.isDocumentContentInSmartArtShape()) {
|
|
var oShape = this.Parent.parent;
|
|
var contentPoints = oShape.getSmartArtPointContent();
|
|
if (contentPoints && contentPoints.length !== 0) {
|
|
var isPhldr = contentPoints.every(function (node) {
|
|
const point = node.point;
|
|
return point && point.prSet && point.prSet.phldr;
|
|
});
|
|
if (isPhldr) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return CDocumentContent.prototype.Is_Empty.call(this);
|
|
};
|
|
CDrawingDocContent.prototype.Shift = function(pageIndex, dx, dy, keepClip) {
|
|
if (!this.IsRecalculated() || pageIndex !== 0)
|
|
return;
|
|
|
|
this.Pages[0].Shift(dx, dy);
|
|
|
|
if (this.ClipInfo[0] && true !== keepClip)
|
|
this.ClipInfo[0].shift(dx, dy);
|
|
|
|
if (this.GetColumnCount() > 1) {
|
|
let pageSection = this.Pages[0].Sections[0];
|
|
if (!pageSection)
|
|
return;
|
|
|
|
for (let columnIndex = 0, columnCount = pageSection.Columns.length; columnIndex < columnCount; ++columnIndex) {
|
|
let pageColumn = pageSection.Columns[columnIndex];
|
|
|
|
let startPos = pageColumn.Pos;
|
|
let endPos = pageColumn.EndPos;
|
|
for (let pos = startPos; pos <= endPos; ++pos) {
|
|
let element = this.Content[pos];
|
|
let elementPageIndex = element.GetElementPageIndex(0, columnIndex, columnCount);
|
|
element.Shift(elementPageIndex, dx, dy);
|
|
}
|
|
}
|
|
} else {
|
|
let startPos = this.Pages[pageIndex].Pos;
|
|
let endPos = this.Pages[pageIndex].EndPos;
|
|
for (let pos = startPos; pos <= endPos; ++pos) {
|
|
let element = this.Content[pos];
|
|
let elementPageIndex = element.GetElementPageIndex(0, 0, 1);
|
|
element.Shift(elementPageIndex, dx, dy);
|
|
}
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.isDocumentContentInSmartArtShape = function () {
|
|
return this.Parent && this.Parent.parent && this.Parent.parent.isObjectInSmartArt && this.Parent.parent.isObjectInSmartArt();
|
|
};
|
|
|
|
CDrawingDocContent.prototype.RecalcAllFields = function() {
|
|
const aFields = this.AllFields;
|
|
for(let nField = 0; nField < aFields.length; ++nField)
|
|
{
|
|
let oField = aFields[nField];
|
|
oField.RecalcMeasure();
|
|
oField.Refresh_RecalcData2();
|
|
}
|
|
};
|
|
|
|
CDrawingDocContent.prototype.getDrawingDocument = function() {
|
|
if(this.Parent && this.Parent.getDrawingDocument) {
|
|
return this.Parent.getDrawingDocument();
|
|
}
|
|
return null;
|
|
};
|
|
CDrawingDocContent.prototype.GetLogicDocument = function() {
|
|
if(Asc.editor.private_GetLogicDocument)
|
|
return Asc.editor.private_GetLogicDocument();
|
|
return null;
|
|
};
|
|
CDrawingDocContent.prototype.Remove = function (Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord) {
|
|
const res = CDocumentContent.prototype.Remove.call(this, Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord);
|
|
const oShape = this.Is_DrawingShape(true);
|
|
if (oShape) {
|
|
oShape.onRemoveContent();
|
|
}
|
|
return res;
|
|
}
|
|
CDrawingDocContent.prototype.getCharContentLength = function () {
|
|
let nContentLength = 0;
|
|
this.CheckRunContent(function (oRun) {
|
|
nContentLength += oRun.Content.length;
|
|
});
|
|
return nContentLength;
|
|
};
|
|
// TODO: сделать по-нормальному!!!
|
|
function CDocument_prototype_private_GetElementPageIndexByXY(ElementPos, X, Y, PageIndex)
|
|
{
|
|
var Element = this.Content[ElementPos];
|
|
if (!Element)
|
|
return 0;
|
|
|
|
var Page = this.Pages[PageIndex];
|
|
if (!Page)
|
|
return 0;
|
|
|
|
var PageSection = null;
|
|
for (var SectionIndex = 0, SectionsCount = Page.Sections.length; SectionIndex < SectionsCount; ++SectionIndex)
|
|
{
|
|
if (Page.Sections[SectionIndex].Pos <= ElementPos && ElementPos <= Page.Sections[SectionIndex].EndPos)
|
|
{
|
|
PageSection = Page.Sections[SectionIndex];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!PageSection)
|
|
return 0;
|
|
|
|
var ElementStartPage = Element.GetRelativeStartPage();
|
|
var ElementStartColumn = Element.GetStartColumn();
|
|
var ElementPagesCount = Element.Get_PagesCount();
|
|
|
|
var ColumnsCount = PageSection.Columns.length;
|
|
var StartColumn = 0;
|
|
var EndColumn = ColumnsCount - 1;
|
|
|
|
if (PageIndex === ElementStartPage)
|
|
{
|
|
StartColumn = Element.GetStartColumn();
|
|
EndColumn = Math.min(ElementStartColumn + ElementPagesCount - 1, ColumnsCount - 1);
|
|
}
|
|
else
|
|
{
|
|
StartColumn = 0;
|
|
EndColumn = Math.min(ElementPagesCount - ElementStartColumn + (PageIndex - ElementStartPage) * ColumnsCount, ColumnsCount - 1);
|
|
}
|
|
|
|
// TODO: Разобраться с ситуацией, когда пустые колонки стоят не только в конце
|
|
while (true === PageSection.Columns[EndColumn].Empty && EndColumn > StartColumn)
|
|
EndColumn--;
|
|
|
|
var ResultColumn = EndColumn;
|
|
for (var ColumnIndex = StartColumn; ColumnIndex < EndColumn; ++ColumnIndex)
|
|
{
|
|
if (X < (PageSection.Columns[ColumnIndex].XLimit + PageSection.Columns[ColumnIndex + 1].X) / 2)
|
|
{
|
|
ResultColumn = ColumnIndex;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return this.private_GetElementPageIndex(ElementPos, PageIndex, ResultColumn, ColumnsCount);
|
|
}
|
|
|
|
function fReadParagraphs(reader) {
|
|
|
|
}
|
|
|
|
AscFormat.CDrawingDocContent = CDrawingDocContent;
|
|
})(window);
|