340 lines
11 KiB
JavaScript
340 lines
11 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2025
|
|
*
|
|
* 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 () {
|
|
|
|
let logicDocument = AscTest.CreateLogicDocument();
|
|
|
|
const charWidth = AscTest.CharWidth * AscTest.FontSize;
|
|
|
|
const L_FIELD = 20 * charWidth;
|
|
const R_FIELD = 30 * charWidth;
|
|
const PAGE_W = 150 * charWidth;
|
|
|
|
|
|
function addFlowImageToParagraph(p, w, h, x, y)
|
|
{
|
|
let d = AscTest.CreateImage(w, h);
|
|
let run = new AscWord.CRun();
|
|
p.AddToContent(0, run);
|
|
run.AddToContent(0, d);
|
|
|
|
d.Set_DrawingType(drawing_Anchor);
|
|
d.Set_Distance(0, 0, 0, 0);
|
|
d.Set_WrappingType(WRAPPING_TYPE_SQUARE);
|
|
d.Set_PositionH(Asc.c_oAscRelativeFromH.Page, false, x);
|
|
d.Set_PositionV(Asc.c_oAscRelativeFromV.Page, false, y);
|
|
return d;
|
|
}
|
|
|
|
function initDocument()
|
|
{
|
|
AscTest.ClearDocument();
|
|
logicDocument.AddToContent(0, AscTest.CreateParagraph());
|
|
|
|
let sectPr = AscTest.GetFinalSection();
|
|
sectPr.SetPageSize(PAGE_W, 1000);
|
|
sectPr.SetPageMargins(L_FIELD, 50, R_FIELD, 50);
|
|
}
|
|
|
|
function checkText(assert, para, lines)
|
|
{
|
|
assert.strictEqual(para.getLineCount(), lines.length, "Check number of lines");
|
|
|
|
for (let i = 0, lineCount = Math.min(lines.length, para.GetLinesCount()); i < lineCount; ++i)
|
|
{
|
|
assert.strictEqual(para.getRangeCount(i), lines[i].length, "Check number of ranges in " + (i + 1) + " line");
|
|
for (let j = 0, rangeCount = Math.min(lines[i].length, para.getRangeCount(i)); j < rangeCount; ++j)
|
|
{
|
|
assert.strictEqual(para.getTextInLineRange(i, j), lines[i][j], "Check text in range " + j);
|
|
}
|
|
}
|
|
}
|
|
function checkRangeBounds(assert, para, lines)
|
|
{
|
|
for (let i = 0, lineCount = Math.min(lines.length, para.GetLinesCount()); i < lineCount; ++i)
|
|
{
|
|
for (let j = 0, rangeCount = Math.min(lines[i].length, para.getRangeCount(i)); j < rangeCount; ++j)
|
|
{
|
|
let range = para.getRange(i, j);
|
|
assert.close(range.X, lines[i][j][0], 0.001, "Check x for " + j + "range");
|
|
assert.close(range.XEnd, lines[i][j][1], 0.001, "Check x for " + j + "range");
|
|
}
|
|
}
|
|
}
|
|
|
|
QUnit.module("Test paragraph wrap", {
|
|
beforeEach : function()
|
|
{
|
|
initDocument();
|
|
AscTest.SetCompatibilityMode(AscCommon.document_compatibility_mode_Current);
|
|
}
|
|
});
|
|
|
|
QUnit.test("Test simple wrap", function(assert)
|
|
{
|
|
let imageX0 = 45 * charWidth;
|
|
let imageX1 = imageX0 + 30 * charWidth;
|
|
let imageY0 = 40;
|
|
let imageY1 = imageY0 + 50;
|
|
|
|
let p1 = logicDocument.GetElement(0);
|
|
|
|
let p2 = AscTest.CreateParagraph();
|
|
|
|
logicDocument.AddToContent(0, p2);
|
|
|
|
addFlowImageToParagraph(p2, imageX1 - imageX0, imageY1 - imageY0, imageX0, imageY0);
|
|
|
|
AscTest.AddTextToParagraph(p1, "VeryLongWord The quick brown fox jumps over the lazy dog");
|
|
AscTest.Recalculate();
|
|
|
|
checkText(assert, p1, [
|
|
["VeryLongWord The quick ", "brown fox jumps over the lazy dog\r\n"]
|
|
]);
|
|
checkRangeBounds(assert, p1, [
|
|
[[L_FIELD, imageX0], [imageX1, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
// Check ranges order for RTL paragraph
|
|
p1.SetParagraphBidi(true);
|
|
AscTest.Recalculate();
|
|
checkText(assert, p1, [
|
|
["VeryLongWord The quick brown fox jumps over ", "the lazy dog\r\n"]
|
|
]);
|
|
checkRangeBounds(assert, p1, [
|
|
[[imageX1, PAGE_W - R_FIELD], [L_FIELD, imageX0]]
|
|
]);
|
|
});
|
|
|
|
QUnit.test("Test the first line indent", function(assert)
|
|
{
|
|
let imageX0 = 45 * charWidth;
|
|
let imageX1 = imageX0 + 10 * charWidth;
|
|
let imageY0 = 40;
|
|
let imageY1 = 90;
|
|
let firstLine = 5 * charWidth;
|
|
let leftInd = 5 * charWidth;
|
|
let rightInd = 0;
|
|
|
|
let text = "VeryLongWord The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.";
|
|
|
|
function initParagraphWithImage()
|
|
{
|
|
initDocument();
|
|
|
|
let p1 = logicDocument.GetElement(0);
|
|
let p2 = AscTest.CreateParagraph();
|
|
logicDocument.AddToContent(0, p2);
|
|
|
|
addFlowImageToParagraph(p2, imageX1 - imageX0, imageY1 - imageY0, imageX0, imageY0);
|
|
|
|
p1.SetParagraphIndent({FirstLine : firstLine, Left : leftInd, Right : rightInd});
|
|
p1.SetParagraphSpacing({Line : 1, LineRule : Asc.linerule_Auto, Before : 0, After : 0});
|
|
AscTest.AddTextToParagraph(p1, text);
|
|
AscTest.Recalculate();
|
|
return p1;
|
|
}
|
|
|
|
function test(textLines, ranges)
|
|
{
|
|
let p = initParagraphWithImage();
|
|
checkText(assert, p, textLines);
|
|
checkRangeBounds(assert, p, ranges);
|
|
}
|
|
|
|
AscTest.SetCompatibilityMode(AscCommon.document_compatibility_mode_Word15);
|
|
|
|
// Simple situation
|
|
test([
|
|
["VeryLongWord ", "The quick brown fox jumps over the lazy dog. The quick brown fox "],
|
|
["jumps over the lazy ", "dog.\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1, PAGE_W - R_FIELD]],
|
|
[[L_FIELD + leftInd, imageX0], [imageX1, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
AscTest.SetCompatibilityMode(AscCommon.document_compatibility_mode_Word14);
|
|
|
|
text = "VeryLongWord The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.";
|
|
|
|
firstLine = 5 * charWidth;
|
|
leftInd = 15 * charWidth;
|
|
test([
|
|
["", "VeryLongWord The quick brown fox jumps over the lazy dog. "],
|
|
["The quick ", "brown fox jumps over the lazy dog. The quick brown fox jumps over "],
|
|
["the lazy dog.\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + firstLine, PAGE_W - R_FIELD]],
|
|
[[L_FIELD + leftInd, imageX0], [imageX1, PAGE_W - R_FIELD]],
|
|
[[L_FIELD + leftInd, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = 15 * charWidth;
|
|
leftInd = 0;
|
|
test([
|
|
["", "VeryLongWord The quick brown fox jumps over the "],
|
|
["lazy dog. The quick brown ", "fox jumps over the lazy dog. The quick brown fox jumps over the "],
|
|
["lazy dog.\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + firstLine, PAGE_W - R_FIELD]],
|
|
[[L_FIELD + leftInd, imageX0], [imageX1, PAGE_W - R_FIELD]],
|
|
[[L_FIELD + leftInd, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
|
|
AscTest.SetCompatibilityMode(AscCommon.document_compatibility_mode_Word15);
|
|
|
|
firstLine = 5 * charWidth;
|
|
leftInd = 15 * charWidth;
|
|
test([
|
|
["", "VeryLongWord The quick brown fox jumps over the lazy dog. "],
|
|
["The quick ", "brown fox jumps over the lazy dog. The quick brown fox jumps over "],
|
|
["the lazy dog.\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + firstLine, PAGE_W - R_FIELD]],
|
|
[[L_FIELD + leftInd, imageX0], [imageX1, PAGE_W - R_FIELD]],
|
|
[[L_FIELD + leftInd, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
|
|
// Check the indentation when the first range is empty
|
|
AscTest.SetCompatibilityMode(AscCommon.document_compatibility_mode_Word14);
|
|
|
|
firstLine = 0;
|
|
leftInd = 0;
|
|
text = "VeryLongLongLongLongLongLongLongWord"
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + firstLine, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = 10 * charWidth;
|
|
leftInd = 0;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + firstLine, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = 10 * charWidth;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + firstLine, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = -5 * charWidth;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + leftInd + firstLine, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = -15 * charWidth;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + leftInd + firstLine, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = -5 * charWidth;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + leftInd + firstLine, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = 0;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1, PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
// Check the indentation when the first range is empty
|
|
AscTest.SetCompatibilityMode(AscCommon.document_compatibility_mode_Word15);
|
|
|
|
firstLine = 0;
|
|
leftInd = 0;
|
|
text = "VeryLongLongLongLongLongLongLongWord"
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + Math.max(0, firstLine), PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = 10 * charWidth;
|
|
leftInd = 0;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + Math.max(0, firstLine), PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = 10 * charWidth;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + Math.max(0, firstLine), PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = -5 * charWidth;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + Math.max(0, firstLine), PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
firstLine = -15 * charWidth;
|
|
leftInd = 10 * charWidth;
|
|
test([
|
|
["", "VeryLongLongLongLongLongLongLongWord\r\n"],
|
|
], [
|
|
[[L_FIELD + firstLine + leftInd, imageX0], [imageX1 + Math.max(0, firstLine), PAGE_W - R_FIELD]]
|
|
]);
|
|
|
|
AscTest.SetCompatibilityMode(AscCommon.document_compatibility_mode_Current);
|
|
|
|
});
|
|
});
|