741 lines
22 KiB
JavaScript
741 lines
22 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)
|
|
{
|
|
/**
|
|
* Class for storing the current draw state of various lines in the paragraph (underline/spelling/etc.)
|
|
* @param {AscWord.ParagraphDrawState} drawState
|
|
* @constructor
|
|
*/
|
|
function ParagraphLineDrawState(drawState)
|
|
{
|
|
this.drawState = drawState;
|
|
|
|
this.Paragraph = undefined;
|
|
this.Graphics = undefined;
|
|
|
|
this.logicDocument = null;
|
|
|
|
this.CurPos = new AscWord.CParagraphContentPos();
|
|
this.CurDepth = 0;
|
|
|
|
this.VisitedHyperlink = false;
|
|
this.Hyperlink = false;
|
|
|
|
this.ulTrailSpace = false;
|
|
this.activePermRanges = false;
|
|
|
|
this.Strikeout = new CParaDrawingRangeHorizontalLines();
|
|
this.DStrikeout = new CParaDrawingRangeHorizontalLines();
|
|
this.Underline = new CParaDrawingRangeHorizontalLines();
|
|
this.Spelling = new CParaDrawingRangeHorizontalLines();
|
|
this.DUnderline = new CParaDrawingRangeHorizontalLines();
|
|
this.RunReview = new CParaDrawingRangeLines();
|
|
this.CollChange = new CParaDrawingRangeLines();
|
|
this.FormBorder = new CParaDrawingRangeLines();
|
|
this.CustomLines = {};
|
|
|
|
this.Page = 0;
|
|
this.Line = 0;
|
|
this.Range = 0;
|
|
|
|
this.X = 0;
|
|
this.BaseLine = 0;
|
|
this.UnderlineOffset = 0;
|
|
this.Spaces = 0;
|
|
this.LineY0 = 0;
|
|
this.LineY1 = 0;
|
|
|
|
this.complexFields = new AscWord.ParagraphComplexFieldStack();
|
|
this.contentControls = [];
|
|
|
|
this.run = null;
|
|
|
|
this.isFormPlaceholder = false;
|
|
|
|
this.yOffset = 0;
|
|
this.color = null;
|
|
|
|
this.paraLineRange = null;
|
|
|
|
this.isUnderline = false;
|
|
this.isStrikeout = false;
|
|
this.isDStrikeout = false;
|
|
|
|
this.form = null;
|
|
this.formBorderColor = null;
|
|
this.formBorderWidth = 0;
|
|
this.combMax = -1;
|
|
|
|
this.reviewAdd = false;
|
|
this.reviewRem = false;
|
|
this.reviewRemAdd = false;
|
|
this.reviewMove = false;
|
|
|
|
this.reviewColor = REVIEW_COLOR;
|
|
this.reviewRemAddColor = REVIEW_COLOR;
|
|
this.reviewPrColor = null;
|
|
|
|
this.collPrChangeColor = null;
|
|
|
|
this.annotationMarks = [];
|
|
|
|
this.customMarks = null;
|
|
this.currentCustomMarks = [];
|
|
this.customMarkInRun = null;
|
|
this.customMarkPos = 0;
|
|
|
|
this.bidiFlow = new AscWord.BidiFlow(this);
|
|
}
|
|
ParagraphLineDrawState.prototype.init = function()
|
|
{
|
|
this.Paragraph = this.drawState.getParagraph();
|
|
this.Graphics = this.drawState.getGraphics();
|
|
|
|
this.logicDocument = this.GetLogicDocument();
|
|
if (this.logicDocument && this.logicDocument.IsDocumentEditor())
|
|
{
|
|
this.ulTrailSpace = this.logicDocument.IsUnderlineTrailSpace();
|
|
this.activePermRanges = this.logicDocument.IsEditCommentsMode() || this.logicDocument.IsViewModeInEditor();
|
|
|
|
this.customMarks = this.logicDocument.GetCustomMarks();
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.resetPage = function(page)
|
|
{
|
|
this.Page = page;
|
|
|
|
this.VisitedHyperlink = false;
|
|
this.Hyperlink = false;
|
|
|
|
this.CurPos = new AscWord.CParagraphContentPos();
|
|
this.CurDepth = 0;
|
|
|
|
this.complexFields.resetPage(this.Paragraph, page);
|
|
};
|
|
ParagraphLineDrawState.prototype.resetLine = function(Line, Baseline, UnderlineOffset, lineY0, lineY1)
|
|
{
|
|
this.Line = Line;
|
|
|
|
this.Baseline = Baseline;
|
|
this.UnderlineOffset = UnderlineOffset;
|
|
this.LineY0 = lineY0;
|
|
this.LineY1 = lineY1;
|
|
|
|
this.Strikeout.Clear();
|
|
this.DStrikeout.Clear();
|
|
this.Underline.Clear();
|
|
this.Spelling.Clear();
|
|
this.RunReview.Clear();
|
|
this.CollChange.Clear();
|
|
this.DUnderline.Clear();
|
|
this.FormBorder.Clear();
|
|
|
|
this.CustomLines = {};
|
|
};
|
|
ParagraphLineDrawState.prototype.beginRange = function(range, x, spaces)
|
|
{
|
|
this.run = null;
|
|
|
|
this.Range = range;
|
|
this.X = x;
|
|
this.Spaces = spaces;
|
|
|
|
this.bidiFlow.begin(this.Paragraph.isRtlDirection());
|
|
|
|
this.paraLineRange = this.Paragraph.Lines[this.Line].Ranges[this.Range];
|
|
};
|
|
ParagraphLineDrawState.prototype.endRange = function()
|
|
{
|
|
this.bidiFlow.end();
|
|
};
|
|
/**
|
|
* @param element {AscWord.CRunElementBase}
|
|
* @param run {AscWord.CRun}
|
|
* @param inRunPos {number}
|
|
* @param misspell {boolean}
|
|
*/
|
|
ParagraphLineDrawState.prototype.handleRunElement = function(element, run, inRunPos, misspell)
|
|
{
|
|
if (!this.complexFields.checkRunElement(element))
|
|
return;
|
|
|
|
if (para_Drawing === element.Type && !element.IsInline())
|
|
return;
|
|
|
|
this.checkCustomMarks(inRunPos);
|
|
|
|
this.bidiFlow.add([element, run, inRunPos, misspell, this.annotationMarks, this.currentCustomMarks.length ? this.currentCustomMarks.slice() : null], element.getBidiType());
|
|
|
|
this.annotationMarks = [];
|
|
};
|
|
ParagraphLineDrawState.prototype.handleBidiFlow = function(data, direction)
|
|
{
|
|
let element = data[0];
|
|
let run = data[1];
|
|
let inRunPos = data[2];
|
|
let misspell = data[3];
|
|
let marks = data[4];
|
|
let customMarks = data[5];
|
|
|
|
this.handleRun(run);
|
|
|
|
this.handleFormBorder(element, run, inRunPos);
|
|
|
|
if (this.isFormPlaceholder)
|
|
{
|
|
this.X += element.GetWidthVisible();
|
|
return;
|
|
}
|
|
|
|
this.addCompositeInputLine(element, run, inRunPos);
|
|
let oTextDrawerInfo;
|
|
if (this.Graphics.m_bIsTextDrawer) {
|
|
oTextDrawerInfo = {TextDrawer: {SplitType: this.Graphics.m_nCurrentSplitOptions, TextElement: element}};
|
|
}
|
|
let startX = this.X;
|
|
let endX = this.X + element.GetWidthVisible();
|
|
switch (element.Type)
|
|
{
|
|
case para_PageNum:
|
|
case para_PageCount:
|
|
case para_Tab:
|
|
case para_Text:
|
|
case para_Sym:
|
|
case para_FootnoteReference:
|
|
case para_FootnoteRef:
|
|
case para_EndnoteReference:
|
|
case para_EndnoteRef:
|
|
case para_Separator:
|
|
case para_ContinuationSeparator:
|
|
case para_Math_Text:
|
|
case para_Math_BreakOperator:
|
|
case para_Math_Ampersand:
|
|
case para_Math_Placeholder:
|
|
this.addLines(startX, endX, undefined, oTextDrawerInfo);
|
|
break;
|
|
case para_Space:
|
|
if (this.paraLineRange)
|
|
{
|
|
startX = this.paraLineRange.CorrectX(startX);
|
|
endX = this.paraLineRange.CorrectX(endX);
|
|
}
|
|
|
|
if (this.Spaces > 0 || this.ulTrailSpace)
|
|
{
|
|
--this.Spaces;
|
|
this.addLines(startX, endX, undefined, oTextDrawerInfo);
|
|
}
|
|
break;
|
|
case para_Drawing:
|
|
if (element.IsInline())
|
|
this.addLines(startX, endX, false, oTextDrawerInfo);
|
|
break;
|
|
case para_End:
|
|
this.isUnderline = false;
|
|
this.isStrikeout = false;
|
|
this.isDStrikeout = false;
|
|
this.addLines(startX, endX, undefined, oTextDrawerInfo);
|
|
break;
|
|
case para_FieldChar:
|
|
if (element.IsVisual())
|
|
this.addLines(startX, endX, undefined, oTextDrawerInfo);
|
|
break;
|
|
}
|
|
|
|
if (misspell)
|
|
this.Spelling.Add(startX, endX, AscWord.BLACK_COLOR);
|
|
|
|
if (customMarks)
|
|
this.addCustomMarkLines(startX, endX, customMarks);
|
|
|
|
if (this.reviewPrColor)
|
|
this.RunReview.Add(0, 0, startX, endX, 0, this.reviewPrColor.r, this.reviewPrColor.g, this.reviewPrColor.b, {RunPr: this.textPr});
|
|
|
|
if (this.collPrChangeColor)
|
|
this.CollChange.Add(0, 0, startX, endX, 0, this.collPrChangeColor.r, this.collPrChangeColor.g, this.collPrChangeColor.b, {RunPr : this.textPr});
|
|
|
|
if (marks)
|
|
{
|
|
let markX = direction === AscBidi.DIRECTION.L ? startX : endX;
|
|
for (let i = 0; i < marks.length; ++i)
|
|
{
|
|
marks[i].drawMark(markX, this.LineY0, this.LineY1 - this.LineY0, this.Graphics, direction === AscBidi.DIRECTION.R, this);
|
|
}
|
|
}
|
|
|
|
this.X = endX;
|
|
};
|
|
ParagraphLineDrawState.prototype.handleAnnotationMark = function(mark)
|
|
{
|
|
this.annotationMarks.push(mark);
|
|
};
|
|
/**
|
|
* Получаем количество орфографических ошибок в данном месте
|
|
* @returns {number}
|
|
*/
|
|
ParagraphLineDrawState.prototype.GetSpellingErrorsCounter = function()
|
|
{
|
|
var nCounter = 0;
|
|
var oSpellChecker = this.Paragraph.GetSpellChecker();
|
|
for (var nIndex = 0, nCount = oSpellChecker.GetElementsCount(); nIndex < nCount; ++nIndex)
|
|
{
|
|
var oSpellElement = oSpellChecker.GetElement(nIndex);
|
|
|
|
if (false !== oSpellElement.Checked || oSpellElement.CurPos)
|
|
continue;
|
|
|
|
var oStartPos = oSpellElement.GetStartPos();
|
|
var oEndPos = oSpellElement.GetEndPos();
|
|
|
|
if (this.CurPos.Compare(oStartPos) > 0 && this.CurPos.Compare(oEndPos) < 0)
|
|
nCounter++;
|
|
}
|
|
|
|
return nCounter;
|
|
};
|
|
ParagraphLineDrawState.prototype.getStartedCustomMarks = function()
|
|
{
|
|
if (!this.customMarks)
|
|
return [];
|
|
|
|
return this.customMarks.getStartedMarks(this.Paragraph, this.CurPos);
|
|
};
|
|
ParagraphLineDrawState.prototype.initCustomMarks = function(run, startPos)
|
|
{
|
|
if (!this.customMarks)
|
|
return;
|
|
|
|
this.currentCustomMarks = this.customMarks.getStartedMarks(this.Paragraph, this.CurPos);
|
|
this.customMarkInRun = this.customMarks.flatRunMarks(run.GetId());
|
|
this.customMarkPos = 0;
|
|
|
|
if (this.customMarkInRun)
|
|
{
|
|
while (this.customMarkPos < this.customMarkInRun.length && startPos > this.customMarkInRun[this.customMarkPos].getPos())
|
|
{
|
|
++this.customMarkPos;
|
|
}
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.checkCustomMarks = function(pos)
|
|
{
|
|
if (!this.customMarkInRun)
|
|
return this.currentCustomMarks;
|
|
|
|
while (this.customMarkPos < this.customMarkInRun.length && pos >= this.customMarkInRun[this.customMarkPos].getPos())
|
|
{
|
|
let mark = this.customMarkInRun[this.customMarkPos];
|
|
if (mark.isStart())
|
|
{
|
|
this.currentCustomMarks.push(mark);
|
|
}
|
|
else
|
|
{
|
|
let handlerId = mark.getHandlerId();
|
|
let rangeId = mark.getRangeId();
|
|
for (let i = 0; i < this.currentCustomMarks.length; ++i)
|
|
{
|
|
let _mark = this.currentCustomMarks[i];
|
|
if (handlerId === _mark.getHandlerId() && rangeId === _mark.getRangeId())
|
|
{
|
|
if (i === this.currentCustomMarks)
|
|
this.currentCustomMarks.length--;
|
|
else
|
|
this.currentCustomMarks.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
++this.customMarkPos;
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.GetLogicDocument = function()
|
|
{
|
|
return this.Paragraph.GetLogicDocument();
|
|
};
|
|
ParagraphLineDrawState.prototype.isActivePermRanges = function()
|
|
{
|
|
return this.activePermRanges;
|
|
};
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Private area
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/**
|
|
* @param run {AscWord.CRun}
|
|
*/
|
|
ParagraphLineDrawState.prototype.handleRun = function(run)
|
|
{
|
|
if (run === this.run)
|
|
return;
|
|
|
|
this.run = run;
|
|
|
|
this.isFormPlaceholder = false;
|
|
|
|
let form = run.GetParentForm();
|
|
let formBorder = null;
|
|
let combMax = -1;
|
|
if (form)
|
|
{
|
|
if (form.IsTextForm() && form.GetTextFormPr().IsComb())
|
|
combMax = form.GetTextFormPr().GetMaxCharacters();
|
|
|
|
if (!form.IsMainForm() && form.GetMainForm() && !form.GetMainForm().IsLabeledCheckBox())
|
|
form = form.GetMainForm();
|
|
|
|
if (form.IsFormRequired() && !form.IsLabeledCheckBox() && form.CheckOFormUserMaster() && this.logicDocument.IsHighlightRequiredFields() && !this.Graphics.isPrintMode)
|
|
formBorder = this.logicDocument.GetRequiredFieldsBorder();
|
|
else if (form.GetFormPr().GetBorder())
|
|
formBorder = form.GetFormPr().GetBorder();
|
|
|
|
this.isFormPlaceholder = (form.IsPlaceHolder() && this.Graphics.isPrintMode);
|
|
|
|
let isForceDrawPlaceHolders = this.logicDocument.ForceDrawPlaceHolders;
|
|
if (true === isForceDrawPlaceHolders)
|
|
this.isFormPlaceholder = false;
|
|
else if (false === isForceDrawPlaceHolders && form.IsPlaceHolder())
|
|
this.isFormPlaceholder = true;
|
|
}
|
|
|
|
this.form = form;
|
|
this.combMax = combMax;
|
|
|
|
this.formBorderWidth = 0;
|
|
this.formBorderColor = null;
|
|
|
|
if (this.form && formBorder)
|
|
{
|
|
this.formBorderWidth = formBorder.GetWidth();
|
|
this.formBorderColor = AscWord.CDocumentColorA.fromObjectRgb(formBorder.GetColor());
|
|
}
|
|
else
|
|
{
|
|
// TODO: It's better to handle CC stack on the fly instead of getting it for each run
|
|
let contentControls = run.GetParentContentControls();
|
|
for (let i = contentControls.length - 1; i >= 0; --i)
|
|
{
|
|
let cc = contentControls[i];
|
|
if (cc instanceof AscWord.CInlineLevelSdt && cc.getBorderColor())
|
|
{
|
|
this.form = cc;
|
|
this.formBorderWidth = 0;
|
|
this.formBorderColor = cc.getBorderColor();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.yOffset = run.getYOffset();
|
|
|
|
let textPr = run.getCompiledPr();
|
|
|
|
this.updateStrikeoutUnderlinePos(run, textPr.FontSize, textPr.VertAlign);
|
|
this.updateColor(textPr);
|
|
this.updateReviewState(run);
|
|
|
|
this.isUnderline = textPr.Underline;
|
|
this.isStrikeout = textPr.Strikeout;
|
|
this.isDStrikeout = textPr.DStrikeout;
|
|
|
|
if (run.IsMathRun() && run.IsPlaceholder())
|
|
{
|
|
this.isUnderline = false;
|
|
|
|
let ctrPrp = run.Parent.GetCtrPrp();
|
|
this.isStrikeout = ctrPrp.Strikeout;
|
|
this.isDStrikeout = ctrPrp.DStrikeout;
|
|
}
|
|
|
|
this.collPrChangeColor = run.getCollPrChangeColor();
|
|
|
|
this.textPr = textPr;
|
|
};
|
|
ParagraphLineDrawState.prototype.handleFormBorder = function(item, run, inRunPos)
|
|
{
|
|
let itemWidth = item.GetWidthVisible();
|
|
if (!this.form || itemWidth <= 0.001 || !this.formBorderColor)
|
|
return;
|
|
|
|
let borderW = this.formBorderWidth;
|
|
let borderColor = this.formBorderColor;
|
|
|
|
let Y = this.Baseline;
|
|
let X = this.X;
|
|
|
|
let formBounds = this.form.GetRangeBounds(this.Line, this.Range);
|
|
let additional = {
|
|
Form : this.form,
|
|
Comb : this.combMax,
|
|
Y : formBounds.Y,
|
|
H : formBounds.H,
|
|
BorderL : 0 === inRunPos
|
|
|| item.IsSpace()
|
|
|| (item.IsText() && !item.IsCombiningMark()),
|
|
BorderR : run.Content.length - 1 === inRunPos
|
|
|| item.IsSpace()
|
|
|| (item.IsText()
|
|
&& inRunPos < run.Content.length - 1
|
|
&& (run.Content[inRunPos + 1].IsSpace()
|
|
|| (run.Content[inRunPos + 1].IsText() && !run.Content[inRunPos + 1].IsCombiningMark())))
|
|
};
|
|
|
|
if (item.RGapCount)
|
|
{
|
|
var nGapEnd = X + itemWidth;
|
|
this.FormBorder.addWithAlpha(Y, Y, X, nGapEnd - item.RGapCount * item.RGapShift,
|
|
borderW,
|
|
borderColor.r,
|
|
borderColor.g,
|
|
borderColor.b,
|
|
borderColor.a,
|
|
additional
|
|
);
|
|
|
|
for (var nGapIndex = 0; nGapIndex < item.RGapCount; ++nGapIndex)
|
|
{
|
|
this.FormBorder.addWithAlpha(Y, Y, nGapEnd - (item.RGapCount - nGapIndex) * item.RGapShift, nGapEnd - (item.RGapCount - nGapIndex - 1) * item.RGapShift,
|
|
borderW,
|
|
borderColor.r,
|
|
borderColor.g,
|
|
borderColor.b,
|
|
borderColor.a,
|
|
additional
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.FormBorder.addWithAlpha(Y, Y, X, X + itemWidth,
|
|
borderW,
|
|
borderColor.r,
|
|
borderColor.g,
|
|
borderColor.b,
|
|
borderColor.a,
|
|
additional
|
|
);
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.updateStrikeoutUnderlinePos = function(run, fontSize, vertAlign)
|
|
{
|
|
let fontSizeMM = fontSize * g_dKoef_pt_to_mm;
|
|
if (run.IsMathRun())
|
|
fontSizeMM *= MatGetKoeffArgSize(fontSize, run.Parent.Compiled_ArgSz.value);
|
|
|
|
let strikeoutShift = 0.27;
|
|
if (AscCommon.vertalign_SubScript === vertAlign)
|
|
strikeoutShift = AscCommon.vaKSize * 0.27 + AscCommon.vaKSub;
|
|
else if (AscCommon.vertalign_SuperScript === vertAlign)
|
|
strikeoutShift = AscCommon.vaKSize * 0.27 + AscCommon.vaKSuper;
|
|
|
|
let strikeoutY = this.Baseline - this.yOffset - fontSizeMM * strikeoutShift;
|
|
let underlineY = this.Baseline - this.yOffset + this.UnderlineOffset;
|
|
|
|
if (AscCommon.vertalign_SubScript === vertAlign)
|
|
underlineY -= AscCommon.vaKSub * fontSizeMM;
|
|
|
|
let lineW = (fontSize / 18) * g_dKoef_pt_to_mm;
|
|
|
|
this.Strikeout.set(strikeoutY, lineW);
|
|
this.DStrikeout.set(strikeoutY, lineW);
|
|
this.Underline.set(underlineY, lineW);
|
|
this.DUnderline.set(underlineY, lineW);
|
|
this.Spelling.set(underlineY, lineW);
|
|
};
|
|
ParagraphLineDrawState.prototype.updateColor = function(textPr)
|
|
{
|
|
if (this.VisitedHyperlink)
|
|
{
|
|
AscFormat.G_O_VISITED_HLINK_COLOR.check(this.Paragraph.getTheme(), this.Paragraph.getColorMap());
|
|
let RGBA = AscFormat.G_O_VISITED_HLINK_COLOR.getRGBAColor();
|
|
this.color = new CDocumentColor(RGBA.R, RGBA.G, RGBA.B, RGBA.A);
|
|
}
|
|
else if (textPr.Color.IsAuto() && !textPr.Unifill)
|
|
{
|
|
if (textPr.FontRef && textPr.FontRef.Color)
|
|
{
|
|
textPr.FontRef.Color.check(this.Paragraph.getTheme(), this.Paragraph.getColorMap());
|
|
let RGBA = textPr.FontRef.Color.RGBA;
|
|
this.color = new CDocumentColor(RGBA.R, RGBA.G, RGBA.B, RGBA.A);
|
|
}
|
|
else
|
|
{
|
|
let bgColor = this.drawState.getBgColor();
|
|
if (textPr.Shd && !textPr.Shd.IsNil())
|
|
bgColor = textPr.Shd.GetSimpleColor(this.Paragraph.getTheme(), this.Paragraph.getColorMap());
|
|
|
|
this.color = bgColor && !bgColor.isBlackAutoColor() ? AscWord.WHITE_COLOR : AscWord.BLACK_COLOR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.isSlideEditor() && this.Hyperlink)
|
|
{
|
|
AscFormat.G_O_HLINK_COLOR.check(this.Paragraph.getTheme(), this.Paragraph.getColorMap());
|
|
let RGBA = AscFormat.G_O_HLINK_COLOR.getRGBAColor();
|
|
this.color = new CDocumentColor(RGBA.R, RGBA.G, RGBA.B, RGBA.A);
|
|
}
|
|
else if (textPr.Unifill)
|
|
{
|
|
textPr.Unifill.check(this.Paragraph.getTheme(), this.Paragraph.getColorMap());
|
|
let RGBA = textPr.Unifill.getRGBAColor();
|
|
this.color = new CDocumentColor(RGBA.R, RGBA.G, RGBA.B);
|
|
}
|
|
else
|
|
{
|
|
this.color = textPr.Color;
|
|
}
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.updateReviewState = function(run)
|
|
{
|
|
this.reviewAdd = false;
|
|
this.reviewRem = false;
|
|
this.reviewRemAdd = false;
|
|
this.reviewMove = false;
|
|
|
|
this.reviewColor = REVIEW_COLOR;
|
|
this.reviewRemAddColor = REVIEW_COLOR;
|
|
this.reviewPrColor = run.Pr.HavePrChange() && !run.IsMathRun() ? run.GetPrReviewColor() : null;
|
|
|
|
let reviewType = run.GetReviewType();
|
|
if (reviewType !== reviewtype_Common)
|
|
{
|
|
this.reviewAdd = reviewtype_Add === reviewType;
|
|
this.reviewRem = reviewtype_Remove === reviewType;
|
|
this.reviewColor = run.GetReviewColor();
|
|
this.reviewMove = reviewtype_Add === reviewType ? run.GetReviewInfo().IsMovedTo() : run.GetReviewInfo().IsMovedFrom();
|
|
|
|
let prevInfo = run.GetReviewInfo().GetPrevAdded();
|
|
if (prevInfo)
|
|
{
|
|
this.reviewRemAdd = true;
|
|
this.reviewRemAddColor = prevInfo.GetColor();
|
|
}
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.isSlideEditor = function()
|
|
{
|
|
return this.Paragraph && !this.Paragraph.bFromDocument;
|
|
};
|
|
/**
|
|
* @param startX {number}
|
|
* @param endX {number}
|
|
* @param drawStrikeout {boolean}
|
|
*/
|
|
ParagraphLineDrawState.prototype.addLines = function(startX, endX, drawStrikeout, oTextDrawerInfo)
|
|
{
|
|
if (endX - startX < 0.001)
|
|
return;
|
|
|
|
if (false !== drawStrikeout)
|
|
{
|
|
if (this.reviewRem)
|
|
{
|
|
if (this.reviewMove)
|
|
this.DStrikeout.Add(startX, endX, this.reviewColor, oTextDrawerInfo);
|
|
else
|
|
this.Strikeout.Add(startX, endX, this.reviewColor, oTextDrawerInfo);
|
|
|
|
if (this.reviewRemAdd)
|
|
this.Underline.Add(startX, endX, this.reviewRemAddColor, oTextDrawerInfo);
|
|
}
|
|
else if (this.isDStrikeout)
|
|
{
|
|
this.DStrikeout.Add(startX, endX, this.color, oTextDrawerInfo, this.textPr);
|
|
}
|
|
else if (this.isStrikeout)
|
|
{
|
|
this.Strikeout.Add(startX, endX, this.color, oTextDrawerInfo, this.textPr);
|
|
}
|
|
}
|
|
|
|
if (this.reviewAdd)
|
|
{
|
|
if (this.reviewMove)
|
|
this.DUnderline.Add(startX, endX, this.reviewColor, oTextDrawerInfo);
|
|
else
|
|
this.Underline.Add(startX, endX, this.reviewColor, oTextDrawerInfo);
|
|
}
|
|
else if (this.isUnderline)
|
|
{
|
|
this.Underline.Add(startX, endX, this.color, oTextDrawerInfo, this.textPr);
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.addCompositeInputLine = function(element, run, inRunPos)
|
|
{
|
|
if (para_Text !== element.Type || !run.CompositeInput || !run.CompositeInput.isInside(inRunPos))
|
|
return;
|
|
|
|
this.Underline.Add(this.X, this.X + element.GetWidthVisible(), this.color, undefined, this.textPr);
|
|
};
|
|
ParagraphLineDrawState.prototype.addCustomMarkLines = function(startX, endX, customMarks)
|
|
{
|
|
for (let i = 0; i < customMarks.length; ++i)
|
|
{
|
|
let mark = customMarks[i];
|
|
let handlerId = mark.getHandlerId();
|
|
let rangeId = mark.getRangeId();
|
|
|
|
if (!this.CustomLines[handlerId])
|
|
this.CustomLines[handlerId] = {};
|
|
|
|
if (!this.CustomLines[handlerId][rangeId])
|
|
this.CustomLines[handlerId][rangeId] = new CParaDrawingRangeHorizontalLines();
|
|
|
|
this.CustomLines[handlerId][rangeId].Add(startX, endX, {r : 0, g : 0, b : 0});
|
|
}
|
|
};
|
|
ParagraphLineDrawState.prototype.drawCustomMarks = function(graphics, y, h, baseLineY)
|
|
{
|
|
for (let handlerId in this.CustomLines)
|
|
{
|
|
for (let rangeId in this.CustomLines[handlerId])
|
|
{
|
|
let lines = this.CustomLines[handlerId][rangeId];
|
|
let element = lines.getNext();
|
|
while (element)
|
|
{
|
|
graphics.drawCustomRange(handlerId, rangeId, element.x0, y, element.x1 - element.x0, h, baseLineY);
|
|
element = lines.getNext();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
AscWord.ParagraphLineDrawState = ParagraphLineDrawState;
|
|
|
|
})(window);
|