sw/CppunitTest_sw_uiwriter10.mk | 14
sw/Module_sw.mk | 1
sw/qa/extras/uiwriter/uiwriter10.cxx | 2078 +++++++++++++++++++++++++++++++++++
sw/qa/extras/uiwriter/uiwriter5.cxx | 2039 ----------------------------------
4 files changed, 2094 insertions(+), 2038 deletions(-)
New commits:
commit ce5527f0fefc74fe1c807fb2330098b6fe79a497
Author: Miklos Vajna <vmik...@collabora.com>
AuthorDate: Tue Mar 11 13:33:09 2025 +0100
Commit: Miklos Vajna <vmik...@collabora.com>
CommitDate: Tue Mar 11 15:26:43 2025 +0100
CppunitTest_sw_uiwriter5: extract CppunitTest_sw_uiwriter10 from this
uiwriter5 is so large that trying to build it by now fails with:
{standard input}: Assembler messages:
{standard input}:327871: Warning: end of file not at end of a line; newline
inserted
{standard input}:328313: Error: no such instruction:
`_zn11__gnu_debug16_error_formatter10_parameterc2in9__gnu_cxx17__normal_iteratoripkpn2sw4mark8markbaseenst9__cxx19986vectoris8_sais8_eeeeenst7__debug6'
g++-12: fatal error: Killed signal terminated program cc1plus
compilation terminated.
make[1]: ***
[/home/vmiklos/git/libreoffice/core/solenv/gbuild/LinkTarget.mk:339:
/home/vmiklos/git/libreoffice/core/workdir/CxxObject/sw/qa/extras/uiwriter/uiwriter5.o]
Error 1
Change-Id: Iede9ef1e4302af7b1d84c35c88b371a57f28b2d5
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/182777
Reviewed-by: Miklos Vajna <vmik...@collabora.com>
Tested-by: Jenkins
diff --git a/sw/CppunitTest_sw_uiwriter10.mk b/sw/CppunitTest_sw_uiwriter10.mk
new file mode 100644
index 000000000000..557c15d2b1ca
--- /dev/null
+++ b/sw/CppunitTest_sw_uiwriter10.mk
@@ -0,0 +1,14 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#*************************************************************************
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+#*************************************************************************
+
+$(eval $(call sw_uiwriter_test,10))
+
+# vim: set noet sw=4 ts=4:
diff --git a/sw/Module_sw.mk b/sw/Module_sw.mk
index fa65cdae1c5e..a849b0fe4660 100644
--- a/sw/Module_sw.mk
+++ b/sw/Module_sw.mk
@@ -130,6 +130,7 @@ $(eval $(call gb_Module_add_slowcheck_targets,sw,\
CppunitTest_sw_uiwriter7 \
CppunitTest_sw_uiwriter8 \
CppunitTest_sw_uiwriter9 \
+ CppunitTest_sw_uiwriter10 \
CppunitTest_sw_layoutwriter \
CppunitTest_sw_layoutwriter2 \
CppunitTest_sw_layoutwriter3 \
diff --git a/sw/qa/extras/uiwriter/uiwriter10.cxx
b/sw/qa/extras/uiwriter/uiwriter10.cxx
new file mode 100644
index 000000000000..c1b59f857212
--- /dev/null
+++ b/sw/qa/extras/uiwriter/uiwriter10.cxx
@@ -0,0 +1,2078 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <swmodeltestbase.hxx>
+
+#include <com/sun/star/chart/XChartDocument.hpp>
+#include <com/sun/star/chart2/XChartDocument.hpp>
+#include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
+#include <com/sun/star/view/XSelectionSupplier.hpp>
+#include <com/sun/star/text/XTextTable.hpp>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/configuration.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+#include <vcl/scheduler.hxx>
+#include <vcl/settings.hxx>
+#include <ndtxt.hxx>
+#include <wrtsh.hxx>
+#include <IDocumentRedlineAccess.hxx>
+#include <UndoManager.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/dispatch.hxx>
+#include <view.hxx>
+#include <fmtcntnt.hxx>
+#include <frameformats.hxx>
+#include <shellio.hxx>
+#include <editeng/fontitem.hxx>
+#include <unotxdoc.hxx>
+#include <IDocumentLayoutAccess.hxx>
+#include <redline.hxx>
+
+/// Second set of tests asserting the behavior of Writer user interface shells.
+class SwUiWriterTest5 : public SwModelTestBase
+{
+public:
+ SwUiWriterTest5()
+ : SwModelTestBase(u"/sw/qa/extras/uiwriter/data/"_ustr)
+ {
+ }
+
+protected:
+ AllSettings m_aSavedSettings;
+};
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testRedlineTableRowDeletionWithExport)
+{
+ // load a 1-row table, and delete the row with enabled change tracking:
+ // now the row is not deleted silently, but keeps the deleted cell
contents,
+ // and only accepting all of them will result the deletion of the table
row.
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // delete table row with enabled change tracking
+ // (HasTextChangesOnly property of the row will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteRows"_ustr, {});
+
+ // Deleted text content with change tracking,
+ // but not table deletion
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // Save it and load it back.
+ saveAndReload(u"writer8"_ustr);
+ pDoc = getSwDoc();
+
+ // accept the deletion of the content of the first cell
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(2),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(0);
+
+ // table row was still not deleted
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // accept last redline
+ pEditShell->AcceptRedline(0);
+
+ // table row (and the 1-row table) was deleted finally
+ // (working export/import of HasTextChangesOnly)
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab", 0);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testRedlineTableRowDeletionWithDOCXExport)
+{
+ // load a 1-row table, and delete the row with enabled change tracking:
+ // now the row is not deleted silently, but keeps the deleted cell
contents,
+ // and only accepting all of them will result the deletion of the table
row.
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // delete table row with enabled change tracking
+ // (HasTextChangesOnly property of the row will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteRows"_ustr, {});
+
+ // Deleted text content with change tracking,
+ // but not table deletion
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // Save it to a DOCX and load it back.
+ // Exporting change tracking of the row wasn't supported.
+ // Also Manage Changes for the import.
+ saveAndReload(u"Office Open XML Text"_ustr);
+ pDoc = getSwDoc();
+
+ // accept the deletion of the content of the first cell
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(2),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(0);
+
+ // table row was still not deleted
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // accept last redline
+ pEditShell->AcceptRedline(0);
+
+ // table row (and the 1-row table) was deleted finally
+ // (working export/import of HasTextChangesOnly)
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab", 0);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testRedlineDOCXTableInsertion)
+{
+ // load a 3-row table inserted with change tracking by text to table
conversion
+ createSwDoc("TC-table-converttotable.docx");
+ SwDoc* pDoc = getSwDoc();
+
+ // check table count (1)
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // reject the text insertions of the table cells (also reject deletion of
the tabulated
+ // text source of the table, which was used by the tracked text to table
conversion)
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(10),
pEditShell->GetRedlineCount());
+ while (pEditShell->GetRedlineCount())
+ pEditShell->RejectRedline(0);
+
+ // rejecting all text insertions must undo the table insertion
+ // This was 1 (remaining empty table after rejecting all table text
insertions)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xTables->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testRedlineDOCXTableMoveToFrame)
+{
+ // load a table with tracked drag & drop: Table1 is the moveFrom,
+ // Table2 is the moveTo - and framed - table
+ createSwDoc("TC-table-DnD-move.docx");
+ SwDoc* pDoc = getSwDoc();
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ uno::Reference<container::XNameAccess> xTableNames =
xTextTablesSupplier->getTextTables();
+ // check table count (2)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTables->getCount());
+
+ // accept tracked table moving, remaining table is Table2
+ IDocumentRedlineAccess& rIDRA(pDoc->getIDocumentRedlineAccess());
+ rIDRA.AcceptAllRedline(true);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+ CPPUNIT_ASSERT(xTableNames->hasByName(u"Table2"_ustr));
+ CPPUNIT_ASSERT(!xTableNames->hasByName(u"Table1"_ustr));
+
+ // Undo and reject tracked table moving, remaining table is Table1
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ rIDRA.AcceptAllRedline(false);
+ // This was 2 (not deleted Table2 – framed)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+ CPPUNIT_ASSERT(xTableNames->hasByName(u"Table1"_ustr));
+ CPPUNIT_ASSERT(!xTableNames->hasByName(u"Table2"_ustr));
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testTdf157662_AcceptInsertRedlineCutWithDeletion)
+{
+ createSwDoc("tdf157662_redlineNestedInsertDelete.odt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(9),
pEditShell->GetRedlineCount());
+
+ // Accept the insert that splitted into 3 parts .. accept all 3 of them
+ pEditShell->AcceptRedline(6);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(7),
pEditShell->GetRedlineCount());
+ // The middle had a delete too, rejecting the delete will remove that
redline too.
+ pEditShell->RejectRedline(6);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(6),
pEditShell->GetRedlineCount());
+
+ // Accept insert that splitted into 4 parts, but separated to 2-2 parts,
with another insert.
+ // It will accept only 2 parts, that is not separated. It leave the
deletion.
+ pEditShell->AcceptRedline(0);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(5),
pEditShell->GetRedlineCount());
+ // Accepting the delete will remove that redline.
+ // (only that one, as its other half is separated from it with an insert)
+ pEditShell->AcceptRedline(0);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(4),
pEditShell->GetRedlineCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testTdf157662_RejectInsertRedlineCutWithDeletion)
+{
+ createSwDoc("tdf157662_redlineNestedInsertDelete.odt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(9),
pEditShell->GetRedlineCount());
+
+ // Reject the insert that splitted into 3 parts. reject all 3 of them
+ // it even remove the deletion, that was on the 2. insert...
+ pEditShell->RejectRedline(6);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(6),
pEditShell->GetRedlineCount());
+
+ // Reject insert that splitted into 4 parts, but separated to 2-2 parts,
with another insert.
+ // It will reject only 2 parts, that is not separated. It remove the
deletion.
+ pEditShell->RejectRedline(0);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(4),
pEditShell->GetRedlineCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf157663_RedlineMoveRecognition)
+{
+ createSwDoc("tdf157663_redlineMove.odt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(23),
pEditShell->GetRedlineCount());
+
+ // Check if move redlines are recognised as moved, during import
+ SwRedlineTable& rTable =
pDoc->getIDocumentRedlineAccess().GetRedlineTable();
+ bool vMovedRedlines[23]
+ = { false, true, true, true, true, true, true, true, true, true,
true, true,
+ true, false, true, false, true, false, false, false, false,
false, false };
+ // 20. and 22. redline is a delete/insert redline with the same text
"three".
+ // they are not recognised as a move, because 22. redline is not a whole
paragraph.
+ // Note: delete/insert redlines that are just a part of a paragraph
decided to be part of
+ // a move, only if it is at least 6 character long and contain a space ""
character.
+ for (SwRedlineTable::size_type i = 0; i < rTable.size(); i++)
+ {
+ CPPUNIT_ASSERT_EQUAL(vMovedRedlines[i], rTable[i]->GetMoved() > 0);
+ }
+
+ // Check if accepting move redlines accept its pairs as well.
+ pEditShell->AcceptRedline(3); // "9 3/4"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(19),
pEditShell->GetRedlineCount());
+
+ pEditShell->AcceptRedline(1); // "sqrt(10)"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(17),
pEditShell->GetRedlineCount());
+
+ pEditShell->AcceptRedline(1); // "four"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(13),
pEditShell->GetRedlineCount());
+
+ pEditShell->AcceptRedline(3); // "six"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(11),
pEditShell->GetRedlineCount());
+
+ pEditShell->AcceptRedline(4); // "sqrt(17)"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(9),
pEditShell->GetRedlineCount());
+
+ // Undo back all the 5 redline accepts
+ for (int i = 0; i < 5; i++)
+ {
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ }
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(23),
pEditShell->GetRedlineCount());
+
+ // Check if rejecting redlines reject its pairs as well.
+ pEditShell->RejectRedline(3); // "9 3/4"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(20),
pEditShell->GetRedlineCount());
+
+ pEditShell->RejectRedline(2); // "sqrt(10)"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(18),
pEditShell->GetRedlineCount());
+
+ pEditShell->RejectRedline(2); // "four"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(15),
pEditShell->GetRedlineCount());
+
+ pEditShell->RejectRedline(2); // "sqrt(17)"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(14),
pEditShell->GetRedlineCount());
+
+ pEditShell->RejectRedline(2); // "six"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(12),
pEditShell->GetRedlineCount());
+
+ const sal_uInt32 nZeroID = 0;
+
+ // Check if there are no more move redlines
+ for (SwRedlineTable::size_type i = 0; i < rTable.size(); i++)
+ {
+ CPPUNIT_ASSERT_EQUAL(nZeroID, rTable[i]->GetMoved());
+ }
+
+ // Check if moving paragraphs generate redline moves
+
+ // move a paragraph that has delete redlines inside of it
+ // original text: "Seve ent teen"
+ // deleted texts: "e " and " t"
+ // moved new text: "Seventeen"
+ pEditShell->GotoRedline(6, true);
+ pEditShell->UpdateCursor();
+ pEditShell->MoveParagraph(SwNodeOffset(1));
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(16),
pEditShell->GetRedlineCount());
+
+ sal_uInt32 nMovedID = rTable[6]->GetMoved();
+ //moved text from here
+ CPPUNIT_ASSERT(nMovedID > 0); // "Sev"
+ CPPUNIT_ASSERT_EQUAL(nZeroID, rTable[7]->GetMoved()); // "e " deleted text
not moved
+ CPPUNIT_ASSERT_EQUAL(nMovedID, rTable[8]->GetMoved()); // "ent"
+ CPPUNIT_ASSERT_EQUAL(nZeroID, rTable[9]->GetMoved()); // " t"
+ CPPUNIT_ASSERT_EQUAL(nMovedID, rTable[10]->GetMoved()); // "teen"
+ // moved text to here
+ CPPUNIT_ASSERT_EQUAL(nMovedID, rTable[11]->GetMoved()); // "Seventeen"
+
+ // move paragraph that has an insert redline inside of it
+ // original text: "Eigen"
+ // inserted text: "hte"
+ // moved new text :"Eighteen"
+ pEditShell->GotoRedline(12, true);
+ pEditShell->UpdateCursor();
+ pEditShell->MoveParagraph(SwNodeOffset(-2));
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(19),
pEditShell->GetRedlineCount());
+
+ nMovedID = rTable[12]->GetMoved();
+ // moved text to here
+ CPPUNIT_ASSERT(nMovedID > 0); // "Eighteen"
+ // moved text from here
+ CPPUNIT_ASSERT_EQUAL(nMovedID, rTable[13]->GetMoved()); // "Eigen"
+ CPPUNIT_ASSERT_EQUAL(nMovedID, rTable[14]->GetMoved()); // "hte"
+ CPPUNIT_ASSERT_EQUAL(nMovedID, rTable[15]->GetMoved()); // "en"
+
+ //Check if accept work on both side of the redlines made by manual move
paragraphs
+ pEditShell->AcceptRedline(13); // "Eigen"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(15),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(11); // "Seventeen"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(10),
pEditShell->GetRedlineCount());
+
+ //undo back the last 2 accept
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(19),
pEditShell->GetRedlineCount());
+
+ //Check if reject work on both side of the redlines made by manual move
paragraphs
+ pEditShell->RejectRedline(13); // "Eigen"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(16),
pEditShell->GetRedlineCount());
+ pEditShell->RejectRedline(11); // "Seventeen"
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(12),
pEditShell->GetRedlineCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf143215)
+{
+ // load a table with tracked insertion of an empty row
+ createSwDoc("TC-table-rowadd.docx");
+ SwDoc* pDoc = getSwDoc();
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ // check table count
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // check table row count
+ uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+
+ // reject insertion of the empty table row
+ IDocumentRedlineAccess& rIDRA(pDoc->getIDocumentRedlineAccess());
+ rIDRA.AcceptAllRedline(false);
+ // This was 4 (remained empty row)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTable->getRows()->getCount());
+
+ // Undo and accept insertion of the table row
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ rIDRA.AcceptAllRedline(true);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+
+ // delete it with change tracking, and accept the deletion
+ dispatchCommand(mxComponent, u".uno:DeleteRows"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+ rIDRA.AcceptAllRedline(true);
+ // This was 4 (remained empty row)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTable->getRows()->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf150666)
+{
+ // load a table with tracked insertion of an empty row
+ createSwDoc("TC-table-rowadd.docx");
+
+ // check table count
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // check table row count
+ uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+
+ // select the second row (tracked table row insertion)
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Down(/*bSelect=*/false);
+
+ // delete it, and accept all tracked changes
+ dispatchCommand(mxComponent, u".uno:DeleteRows"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:AcceptAllTrackedChanges"_ustr, {});
+
+ // This was 4 (it was not possible to delete only the tracked row
insertions)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTable->getRows()->getCount());
+
+ // insert a new table row with track changes
+ dispatchCommand(mxComponent, u".uno:InsertRowsAfter"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+
+ // select and delete it
+ pWrtShell->Down(/*bSelect=*/false);
+ dispatchCommand(mxComponent, u".uno:DeleteRows"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:AcceptAllTrackedChanges"_ustr, {});
+
+ // This was 4 (it was not possible to delete own tracked row insertions)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTable->getRows()->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf150666_regression)
+{
+ // load a table with tracked insertion of an empty row
+ createSwDoc("TC-table-rowadd.docx");
+
+ // check table count
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // check table row count
+ uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+
+ // select the second row (tracked table row insertion)
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Down(/*bSelect=*/false);
+
+ // insert a new table row with track changes
+ dispatchCommand(mxComponent, u".uno:InsertRowsAfter"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(5), xTable->getRows()->getCount());
+
+ dispatchCommand(mxComponent, u".uno:RejectAllTrackedChanges"_ustr, {});
+
+ // This was 4 (the inserted table row wasn't tracked)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTable->getRows()->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf144748)
+{
+ // load a table with an empty row, and an empty line before the table
+ // (to allow the easy selection of the full text with the table)
+ createSwDoc("tdf144748.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ // there is a table in the text
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // delete full text with the table and check Undo
+
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Delete"_ustr, {});
+ // this crashed LibreOffice
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ // redo and check redline usage
+
+ dispatchCommand(mxComponent, u".uno:Redo"_ustr, {});
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ // This was 2 (bad extra redline for the empty row of the deleted table)
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+
+ // accept deletion of the text, including the table with the empty row
+
+ IDocumentRedlineAccess& rIDRA(pDoc->getIDocumentRedlineAccess());
+ rIDRA.AcceptAllRedline(true);
+
+ // no table left in the text
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xTables->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf147180)
+{
+ // load a tracked table insertion (single redline)
+ createSwDoc("tdf147180.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ // there is a table in the text
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // insert a character in the first cell with change tracking
+ SwWrtShell* const pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Insert(u"x"_ustr);
+
+ // reject all the changes, including table insertion
+
+ IDocumentRedlineAccess& rIDRA(pDoc->getIDocumentRedlineAccess());
+ rIDRA.AcceptAllRedline(/*bAccept=*/false);
+
+ // no table left in the text
+
+ // This was 1 (lost tracking of the table after modifying its text content)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xTables->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf147180_empty_rows)
+{
+ // load a tracked table insertion (single redline) with empty rows
+ createSwDoc("tdf150824.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ // there is a table in the text
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // insert a character in the first cell with change tracking
+ SwWrtShell* const pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Insert(u"x"_ustr);
+
+ // reject all the changes, including table insertion
+
+ IDocumentRedlineAccess& rIDRA(pDoc->getIDocumentRedlineAccess());
+ rIDRA.AcceptAllRedline(/*bAccept=*/false);
+
+ // no table left in the text
+
+ // This was 1 (lost tracking of the empty rows after modifying table text
content)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(0), xTables->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testRedlineTableColumnDeletion)
+{
+ // load a table, and delete the first column with enabled change tracking:
+ // now the column is not deleted silently, but keeps the deleted cell
content,
+ // and only accepting it will result the deletion of the table column.
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // delete table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ // This was 1 (deleted cell without change tracking)
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // accept the deletion
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(0);
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ // deleted column
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 1);
+
+ // Undo, and repeat the previous test, but only with deletion of the text
content of the cells
+ // (HasTextChangesOnly property will be removed by Undo)
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ // first column exists again
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // delete table column with enabled change tracking
+ dispatchCommand(mxComponent, u".uno:SelectColumn"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Delete"_ustr, {});
+
+ // Table column still exists
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // accept the deletion of the content of the first cell
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(0);
+
+ // table column was still not deleted
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // Undo, and delete the column without change tracking
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ // table exists again
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // disable change tracking
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+
+ CPPUNIT_ASSERT_MESSAGE("redlining should be off",
+ !pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+
+ // delete table column without change tracking
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ // the table column was deleted
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 1);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf156474)
+{
+ // load a table, and insert a column with change tracking
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+
+ // there is a table in the text with two columns
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+ uno::Reference<text::XTextTable> xTextTable(xTables->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTextTable->getColumns()->getCount());
+
+ // insert table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:InsertColumnsBefore"_ustr, {});
+
+ // 3 columns
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTextTable->getColumns()->getCount());
+
+ // accept tracked changes: remove HasTextChangesOnly = false of the
inserted cells
+ dispatchCommand(mxComponent, u".uno:AcceptAllTrackedChanges"_ustr, {});
+
+ // still 3 columns
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTextTable->getColumns()->getCount());
+
+ // delete the text content (dummy character of the previous text change)
of the newly
+ // inserted cell, and accept tracked changes
+ SwWrtShell* const pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Left(SwCursorSkipMode::Chars, /*bSelect=*/false, 1,
/*bBasicCall=*/false);
+ dispatchCommand(mxComponent, u".uno:SwBackspace"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:AcceptAllTrackedChanges"_ustr, {});
+
+ // This was 2 columns (not removed HasTextChangesOnly = false resulted
column deletion
+ // instead of deleting only content of the cell)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(3), xTextTable->getColumns()->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, tdf156475)
+{
+ // load a table, and insert a row without change tracking,
+ // and delete the first column with the empty cell in the second row with
change tracking
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn off red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be off",
+ !pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // insert table row
+ dispatchCommand(mxComponent, u".uno:InsertRowsAfter"_ustr, {});
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 2);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row[1]/cell", 2);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row[2]/cell", 2);
+
+ // turn on red-lining
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+
+ // delete table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ // go down to the empty cell
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Down(/*bSelect=*/false);
+
+ // Without the fix in place, this couldn't work
+ dispatchCommand(mxComponent, u".uno:AcceptTrackedChange"_ustr, {});
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 2);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row[1]/cell", 1);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row[2]/cell", 1);
+
+ // test Undo/Redo
+ for (sal_Int32 i = 0; i < 4; ++i)
+ {
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ }
+
+ for (sal_Int32 i = 0; i < 4; ++i)
+ {
+ dispatchCommand(mxComponent, u".uno:Redo"_ustr, {});
+ }
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf155747)
+{
+ // load a table, and delete the first column with enabled change tracking:
+ // now the column is not deleted silently, but keeps the deleted cell
content,
+ // and only accepting it will result the deletion of the table column.
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // delete table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ // select table
+ dispatchCommand(mxComponent, u".uno:SelectTable"_ustr, {});
+
+ // Without the fix in place, this test would have crashed here
+ dispatchCommand(mxComponent, u".uno:AcceptTrackedChange"_ustr, {});
+
+ // check removed column
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 1);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf156544)
+{
+ // load a table, and insert a column without change tracking,
+ // and delete the first column with the empty cell in the second row with
change tracking
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn off red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be off",
+ !pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // insert table column without change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:InsertColumnsBefore"_ustr, {});
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row[1]/cell", 3);
+
+ // turn on red-lining
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+
+ // go to the empty column
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Left(SwCursorSkipMode::Chars, /*bSelect=*/false, 1,
/*bBasicCall=*/false);
+
+ // delete table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+
+ // This was 2 (deleted column)
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 3);
+
+ // accept the deletion of the empty column
+ dispatchCommand(mxComponent, u".uno:AcceptTrackedChange"_ustr, {});
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // test Undo/Redo
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 3);
+
+ dispatchCommand(mxComponent, u".uno:Redo"_ustr, {});
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf156487)
+{
+ // load a table, and delete a column in Hide Changes mode
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and hide changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+
+ CPPUNIT_ASSERT_MESSAGE("redlines shouldn't be visible",
+ !IDocumentRedlineAccess::IsShowChanges(
+
pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // delete table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ // Dump the rendering of the first page as an XML file.
+ SwDocShell* pShell = getSwDocShell();
+ std::shared_ptr<GDIMetaFile> xMetaFile = pShell->GetPreviewMetaFile();
+ MetafileXmlDump dumper;
+ xmlDocUniquePtr pXmlDoc = dumpAndParse(dumper, *xMetaFile);
+ CPPUNIT_ASSERT(pXmlDoc);
+
+ // This would be 2 without hiding the first cell
+ assertXPath(pXmlDoc, "/metafile/push/push/push/textarray/text", 1);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf149498)
+{
+ // load a table, and delete the first column with enabled change tracking:
+ // now the column is not deleted silently, but keeps the deleted cell
content,
+ // and only accepting it will result the deletion of the table column.
+ createSwDoc("tdf149498.docx");
+
+ // select table, copy, paste and Undo
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Copy"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Paste"_ustr, {});
+
+ // this would crash due to bookmark over cell boundary
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testTdf150673_RedlineTableColumnDeletionWithExport)
+{
+ // load a table, and delete the first column with enabled change tracking:
+ // now the column is not deleted silently, but keeps the deleted cell
contents,
+ // and only accepting all of them will result the deletion of the table
column.
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // delete table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ // Deleted text content with change tracking,
+ // but not table deletion
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // Save it and load it back.
+ saveAndReload(u"writer8"_ustr);
+ pDoc = getSwDoc();
+
+ // accept the deletion of the content of the first cell
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(0);
+
+ // first table column was deleted finally
+ // (working export/import of HasTextChangesOnly)
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 1);
+
+ // check removing HasTextChangesOnly at acceptance of the deletion
+
+ // Undo, and delete the column without change tracking
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ // table column exists again
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // reject deletion, setting HasTextChangesOnly to TRUE
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+ pEditShell->RejectRedline(0);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(0),
pEditShell->GetRedlineCount());
+
+ // delete table column with enabled change tracking
+ dispatchCommand(mxComponent, u".uno:SelectColumn"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Delete"_ustr, {});
+
+ // Table column still exists
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // reject the deletion of the content of the first cell
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(0);
+
+ // table column is still not deleted
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testRedlineTableColumnDeletionWithDOCXExport)
+{
+ // load a 1-row table, and delete the first column with enabled change
tracking:
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // delete first table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteColumns"_ustr, {});
+
+ // Deleted text content with change tracking,
+ // but not table deletion
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+
+ // Save it to a DOCX and load it back.
+ // Exporting change tracking of the cell wasn't supported.
+ // Also Manage Changes for the import.
+ saveAndReload(u"Office Open XML Text"_ustr);
+ pDoc = getSwDoc();
+
+ // accept the deletion of the content of the first cell
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+ pEditShell->AcceptRedline(0);
+
+ // table column was deleted
+ // (working export/import of HasTextChangesOnly of table cells)
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 1);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testTdf155341_RedlineTableColumnInsertionWithExport)
+{
+ // load a table, and insert a new column with enabled change tracking
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // insert table column with enabled change tracking
+ // (HasTextChangesOnly property of the cell will be false)
+ dispatchCommand(mxComponent, u".uno:InsertColumnsAfter"_ustr, {});
+
+ // text content with change tracking (dummy redline)
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 3);
+
+ // Save it and load it back.
+ saveAndReload(u"writer8"_ustr);
+ pDoc = getSwDoc();
+
+ // reject the insertion of the hidden content of the cell
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(1),
pEditShell->GetRedlineCount());
+ pEditShell->RejectRedline(0);
+
+ // inserted table column was deleted
+ // (working export/import of HasTextChangesOnly)
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row/cell", 2);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf128335)
+{
+ // Load the bugdoc, which has 3 textboxes.
+ createSwDoc("tdf128335.odt");
+
+ // Select the 3rd textbox.
+ SwView* pView = getSwDocShell()->GetView();
+ selectShape(1);
+ SwXTextDocument* pTextDoc = getSwTextDoc();
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYINPUT, 0, KEY_TAB);
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYUP, 0, KEY_TAB);
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYINPUT, 0, KEY_TAB);
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYUP, 0, KEY_TAB);
+ Scheduler::ProcessEventsToIdle();
+
+ // Cut it.
+ pView->GetViewFrame().GetDispatcher()->Execute(SID_CUT,
SfxCallMode::SYNCHRON);
+
+ // Paste it: this makes the 3rd textbox anchored in the 2nd one.
+ pView->GetViewFrame().GetDispatcher()->Execute(SID_PASTE,
SfxCallMode::SYNCHRON);
+
+ selectShape(1);
+
+ // Cut them.
+ // Without the accompanying fix in place, this test would have crashed as
the textboxes were
+ // deleted in an incorrect order.
+ pView->GetViewFrame().GetDispatcher()->Execute(SID_CUT,
SfxCallMode::SYNCHRON);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testRedlineTableRowDeletionWithReject)
+{
+ // load a 1-row table, and delete the row with enabled change tracking:
+ // now the row is not deleted silently, but keeps the deleted cell
contents,
+ // and only accepting all of them will result the deletion of the table
row.
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // delete table row with enabled change tracking
+ // (HasTextChangesOnly property of the row will be false)
+ dispatchCommand(mxComponent, u".uno:DeleteRows"_ustr, {});
+
+ // Deleted text content with change tracking,
+ // but not table deletion
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // Save it and load it back.
+ saveAndReload(u"writer8"_ustr);
+ pDoc = getSwDoc();
+
+ // reject the deletion of the content of the first cell
+ // HasTextChangesOnly property of the table row will be true
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(2),
pEditShell->GetRedlineCount());
+ pEditShell->RejectRedline(0);
+
+ // Select and delete the content of the first cell
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Delete"_ustr, {});
+
+ // table row was still not deleted
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // accept all redlines
+ while (pEditShell->GetRedlineCount())
+ pEditShell->AcceptRedline(0);
+
+ // This was table row deletion instead of remaining the empty row
+ // (HasTextChangesOnly was false)
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // restore HasTextChangesOnly = false
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ // accept all redlines
+ while (pEditShell->GetRedlineCount())
+ pEditShell->AcceptRedline(0);
+
+ // table row (and the 1-row table) was deleted finally
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab", 0);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testRedlineTableRowInsertionWithReject)
+{
+ // load a 1-row table, and insert a row with enabled change tracking
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table and its single row
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+
+ // insert rows before and after with enabled change tracking
+ // (HasTextChangesOnly property of the row will be false, and
+ // add dummy characters CH_TXT_TRACKED_DUMMY_CHAR)
+ dispatchCommand(mxComponent, u".uno:InsertRowsBefore"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:InsertRowsAfter"_ustr, {});
+
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ // This was 0 (not tracked row insertion)
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(2),
pEditShell->GetRedlineCount());
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 3);
+
+ // reject redlines
+ pEditShell->RejectRedline(0);
+ pEditShell->RejectRedline(0);
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ // This was 3 (not rejected row insertion)
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testTdf145089_RedlineTableRowInsertionDOCX)
+{
+ // load a 1-row table, and insert a row with enabled change tracking
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table and its single row
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+
+ // insert rows before and after with enabled change tracking
+ // (HasTextChangesOnly property of the row will be false, and
+ // add dummy characters CH_TXT_TRACKED_DUMMY_CHAR)
+ dispatchCommand(mxComponent, u".uno:InsertRowsBefore"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:InsertRowsAfter"_ustr, {});
+
+ // save it to DOCX
+ saveAndReload(u"Office Open XML Text"_ustr);
+ SwViewShell* pViewShell =
getSwDoc()->getIDocumentLayoutAccess().GetCurrentViewShell();
+ pViewShell->Reformat();
+ pXmlDoc = parseLayoutDump();
+
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 3);
+
+ // reject redlines
+ SwDoc* pDOCXDoc(getSwDoc());
+ SwEditShell* const pEditShell(pDOCXDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(2),
pEditShell->GetRedlineCount());
+ pEditShell->RejectRedline(0);
+ pEditShell->RejectRedline(0);
+
+ pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+
+ // This was 3 (not rejected row insertion)
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 1);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testPasteTrackedTableRow)
+{
+ // load a 1-row table
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table count
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // check table row count
+ uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTable->getRows()->getCount());
+
+ // copy table row and paste it by Paste Special->Rows Above
+ dispatchCommand(mxComponent, u".uno:SelectTable"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Copy"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Escape"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:PasteRowsBefore"_ustr, {});
+
+ // 2-row table
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTable->getRows()->getCount());
+
+ // This was 2 (inserted as a nested table in the first cell of the new row)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // Is it a tracked row insertion? Its rejection results the original 1-row
table
+ dispatchCommand(mxComponent, u".uno:RejectAllTrackedChanges"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTable->getRows()->getCount());
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTable->getRows()->getCount());
+
+ dispatchCommand(mxComponent, u".uno:Redo"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTable->getRows()->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testPasteTrackedTableRowInHideChangesMode)
+{
+ // load a 1-row table
+ createSwDoc("tdf118311.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE("redlines should be invisible",
+ !IDocumentRedlineAccess::IsShowChanges(
+
pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check table count
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ // check table row count
+ uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTable->getRows()->getCount());
+
+ // copy table row and paste it by Paste Special->Rows Above
+ dispatchCommand(mxComponent, u".uno:SelectTable"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Copy"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Escape"_ustr, {});
+
+ // This resulted freezing
+ dispatchCommand(mxComponent, u".uno:PasteRowsBefore"_ustr, {});
+
+ // 2-row table
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTable->getRows()->getCount());
+
+ // This was 2 (inserted as a nested table in the first cell of the new row)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {}); // FIXME Why 3 Undos?
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTable->getRows()->getCount());
+
+ dispatchCommand(mxComponent, u".uno:Redo"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTable->getRows()->getCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf146966)
+{
+ // load a 4-row table, select more than 1 row and copy them
+ // to check insertion of unnecessary empty rows
+ createSwDoc("tdf144748.fodt");
+
+ // check table row count
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xTables(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xTables->getCount());
+ uno::Reference<text::XTextTable> xTable(xTables->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+
+ // copy table row and paste it by Paste Special->Rows Above
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ pWrtShell->Down(/*bSelect=*/false);
+ dispatchCommand(mxComponent, u".uno:SelectTable"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Copy"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Escape"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:PasteRowsBefore"_ustr, {});
+
+ // This was 35 (extra empty rows)
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(8), xTable->getRows()->getCount());
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {}); // FIXME Why 3 Undos?
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(4), xTable->getRows()->getCount());
+
+ dispatchCommand(mxComponent, u".uno:Redo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Redo"_ustr, {});
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(8), xTable->getRows()->getCount());
+ // dispatchCommand(mxComponent, ".uno:Redo", {}); // FIXME assert
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf145091)
+{
+ // load a deleted table, reject them, and delete only its text and export
to DOCX
+ createSwDoc("tdf145091.docx");
+ SwDoc* pDoc = getSwDoc();
+
+ // turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // reject all redlines
+ SwEditShell* const pEditShell(pDoc->GetEditShell());
+ CPPUNIT_ASSERT(pEditShell);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(3),
pEditShell->GetRedlineCount());
+ while (pEditShell->GetRedlineCount() > 0)
+ pEditShell->RejectRedline(0);
+ CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(0),
pEditShell->GetRedlineCount());
+
+ // delete only table text, but not table
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:Delete"_ustr, {});
+ CPPUNIT_ASSERT(pEditShell->GetRedlineCount() > 0);
+
+ // save it to DOCX
+ saveAndReload(u"Office Open XML Text"_ustr);
+ SwViewShell* pViewShell =
getSwDoc()->getIDocumentLayoutAccess().GetCurrentViewShell();
+ pViewShell->Reformat();
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 3);
+
+ // accept all redlines
+ dispatchCommand(mxComponent, u".uno:AcceptAllTrackedChanges"_ustr, {});
+
+ pXmlDoc = parseLayoutDump();
+ // This was false (deleted table with accepting deletions)
+ assertXPath(pXmlDoc, "//page[1]//body/tab");
+ assertXPath(pXmlDoc, "//page[1]//body/tab/row", 3);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf128603)
+{
+ // Load the bugdoc, which has 3 textboxes.
+ createSwDoc("tdf128603.odt");
+ SwDoc* pDoc = getSwDoc();
+
+ // Select the 3rd textbox.
+ SwView* pView = getSwDocShell()->GetView();
+ selectShape(1);
+ SwXTextDocument* pTextDoc = getSwTextDoc();
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYINPUT, 0, KEY_TAB);
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYUP, 0, KEY_TAB);
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYINPUT, 0, KEY_TAB);
+ pTextDoc->postKeyEvent(LOK_KEYEVENT_KEYUP, 0, KEY_TAB);
+ Scheduler::ProcessEventsToIdle();
+
+ // Cut it.
+ pView->GetViewFrame().GetDispatcher()->Execute(SID_CUT,
SfxCallMode::SYNCHRON);
+
+ // Paste it: this makes the 3rd textbox anchored in the 2nd one.
+ pView->GetViewFrame().GetDispatcher()->Execute(SID_PASTE,
SfxCallMode::SYNCHRON);
+
+ // Undo all of this.
+ sw::UndoManager& rUndoManager = pDoc->GetUndoManager();
+ rUndoManager.Undo();
+ rUndoManager.Undo();
+
+ // Make sure the content indexes still match.
+ const auto& rSpzFrameFormats = *pDoc->GetSpzFrameFormats();
+ CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(6), rSpzFrameFormats.size());
+ const SwNodeIndex* pIndex4 =
rSpzFrameFormats[4]->GetContent().GetContentIdx();
+ CPPUNIT_ASSERT(pIndex4);
+ const SwNodeIndex* pIndex5 =
rSpzFrameFormats[5]->GetContent().GetContentIdx();
+ CPPUNIT_ASSERT(pIndex5);
+ // Without the accompanying fix in place, this test would have failed with:
+ // - Expected: 11
+ // - Actual : 14
+ // i.e. the shape content index and the frame content index did not match
after undo, even if
+ // their "other text box format" pointers pointed to each other.
+ CPPUNIT_ASSERT_EQUAL(pIndex4->GetIndex(), pIndex5->GetIndex());
+}
+
+// only care that it doesn't assert/crash
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testOfz18563)
+{
+ OUString
sURL(m_directories.getURLFromSrc(u"/sw/qa/extras/uiwriter/data/ofz18563.docx"));
+ SvFileStream aFileStream(sURL, StreamMode::READ);
+ TestImportDOCX(aFileStream);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf143904)
+{
+ createSwDoc("tdf143904.odt");
+ SwDoc* pDoc = getSwDoc();
+
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ CPPUNIT_ASSERT(pWrtShell);
+
+ SwNodeOffset nIndex = pWrtShell->GetCursor()->GetPointNode().GetIndex();
+
+ dispatchCommand(mxComponent, u".uno:InsertRowsAfter"_ustr, {});
+ pWrtShell->Down(false);
+ pWrtShell->Insert(u"foo"_ustr);
+
+ SwTextNode* pTextNodeA1 =
static_cast<SwTextNode*>(pDoc->GetNodes()[nIndex]);
+ CPPUNIT_ASSERT(pTextNodeA1->GetText().startsWith("Insert"));
+ nIndex = pWrtShell->GetCursor()->GetPointNode().GetIndex();
+ SwTextNode* pTextNodeA2 =
static_cast<SwTextNode*>(pDoc->GetNodes()[nIndex]);
+ CPPUNIT_ASSERT_EQUAL(u"foo"_ustr, pTextNodeA2->GetText());
+ CPPUNIT_ASSERT_EQUAL(false,
pTextNodeA2->GetSwAttrSet().HasItem(RES_CHRATR_FONT));
+ OUString sFontName =
pTextNodeA2->GetSwAttrSet().GetItem(RES_CHRATR_FONT)->GetFamilyName();
+ CPPUNIT_ASSERT_EQUAL(u"Liberation Serif"_ustr, sFontName);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf90069)
+{
+ createSwDoc("tdf90069.docx");
+ SwDoc* pDoc = getSwDoc();
+
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ CPPUNIT_ASSERT(pWrtShell);
+
+ SwNodeOffset nIndex = pWrtShell->GetCursor()->GetPointNode().GetIndex();
+
+ dispatchCommand(mxComponent, u".uno:InsertRowsAfter"_ustr, {});
+ pWrtShell->Down(false);
+ pWrtShell->Insert(u"foo"_ustr);
+
+ SwTextNode* pTextNodeA1 =
static_cast<SwTextNode*>(pDoc->GetNodes()[nIndex]);
+ CPPUNIT_ASSERT(pTextNodeA1->GetText().startsWith("Insert"));
+ nIndex = pWrtShell->GetCursor()->GetPointNode().GetIndex();
+ SwTextNode* pTextNodeA2 =
static_cast<SwTextNode*>(pDoc->GetNodes()[nIndex]);
+ CPPUNIT_ASSERT_EQUAL(u"foo"_ustr, pTextNodeA2->GetText());
+ CPPUNIT_ASSERT_EQUAL(true,
pTextNodeA2->GetSwAttrSet().HasItem(RES_CHRATR_FONT));
+ OUString sFontName =
pTextNodeA2->GetSwAttrSet().GetItem(RES_CHRATR_FONT)->GetFamilyName();
+ CPPUNIT_ASSERT_EQUAL(u"Lohit Devanagari"_ustr, sFontName);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf109266)
+{
+ // transliteration with redlining
+ createSwDoc("lorem.fodt");
+ SwDoc* pDoc = getSwDoc();
+ SwWrtShell* pWrtShell = getSwDocShell()->GetWrtShell();
+ CPPUNIT_ASSERT(pWrtShell);
+
+ SwNodeOffset nIndex = pWrtShell->GetCursor()->GetPointNode().GetIndex();
+ SwTextNode* pTextNode = static_cast<SwTextNode*>(pDoc->GetNodes()[nIndex]);
+
+ CPPUNIT_ASSERT_EQUAL(u"Lorem ipsum..."_ustr, pTextNode->GetText());
+ CPPUNIT_ASSERT_EQUAL(u"Lorem ipsum..."_ustr, pTextNode->GetRedlineText());
+
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:ChangeCaseToTitleCase"_ustr, {});
+
+ CPPUNIT_ASSERT_EQUAL(u"Lorem Ipsum..."_ustr, pTextNode->GetText());
+ CPPUNIT_ASSERT_EQUAL(u"Lorem Ipsum..."_ustr, pTextNode->GetRedlineText());
+
+ //turn on red-lining and show changes
+ RedlineFlags const mode(pWrtShell->GetRedlineFlags() | RedlineFlags::On);
+ CPPUNIT_ASSERT(mode & (RedlineFlags::ShowDelete |
RedlineFlags::ShowInsert));
+ pWrtShell->SetRedlineFlags(mode);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:ChangeCaseToTitleCase"_ustr, {});
+
+ // This was "Lorem Ipsum..." (missing redlining)
+ CPPUNIT_ASSERT_EQUAL(u"Lorem ipsumIpsum..."_ustr, pTextNode->GetText());
+ CPPUNIT_ASSERT_EQUAL(u"Lorem Ipsum..."_ustr, pTextNode->GetRedlineText());
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:ChangeCaseToUpper"_ustr, {});
+
+ // This was "LOREM IPSUM..." (missing redlining)
+ CPPUNIT_ASSERT_EQUAL(u"Lorem ipsum...LOREM IPSUM..."_ustr,
pTextNode->GetText());
+ CPPUNIT_ASSERT_EQUAL(u"LOREM IPSUM..."_ustr, pTextNode->GetRedlineText());
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:ChangeCaseToLower"_ustr, {});
+
+ // This was "lorem ipsum..." (missing redlining)
+ CPPUNIT_ASSERT_EQUAL(u"Lorem ipsum...lorem ipsum..."_ustr,
pTextNode->GetText());
+ CPPUNIT_ASSERT_EQUAL(u"lorem ipsum..."_ustr, pTextNode->GetRedlineText());
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:SelectAll"_ustr, {});
+ dispatchCommand(mxComponent, u".uno:ChangeCaseToToggleCase"_ustr, {});
+
+ // This was "lOREM IPSUM..." (missing redlining)
+ CPPUNIT_ASSERT_EQUAL(u"Lorem ipsum...lOREM IPSUM..."_ustr,
pTextNode->GetText());
+ CPPUNIT_ASSERT_EQUAL(u"lOREM IPSUM..."_ustr, pTextNode->GetRedlineText());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf129655)
+{
+ createSwDoc("tdf129655-vtextbox.odt");
+ xmlDocUniquePtr pXmlDoc = parseLayoutDump();
+ assertXPath(pXmlDoc, "//anchored/fly/txt[@WritingMode='Vertical']", 1);
+}
+
+static uno::Reference<text::XTextRange> getAssociatedTextRange(uno::Any object)
+{
+ // possible cases:
+ // 1. a container of other objects - e.g. selection of 0 to n text
portions, or 1 to n drawing objects
+ try
+ {
+ uno::Reference<container::XIndexAccess> xIndexAccess(object,
uno::UNO_QUERY_THROW);
+ if (xIndexAccess.is() && xIndexAccess->getCount() > 0)
+ {
+ for (int i = 0; i < xIndexAccess->getCount(); ++i)
+ {
+ uno::Reference<text::XTextRange> xRange
+ = getAssociatedTextRange(xIndexAccess->getByIndex(i));
+ if (xRange.is())
+ return xRange;
+ }
+ }
+ }
+ catch (const uno::Exception&)
+ {
+ }
+
+ // 2. another TextContent, having an anchor we can use
+ try
+ {
+ uno::Reference<text::XTextContent> xTextContent(object,
uno::UNO_QUERY_THROW);
+ if (xTextContent.is())
+ {
+ uno::Reference<text::XTextRange> xRange =
xTextContent->getAnchor();
+ if (xRange.is())
+ return xRange;
+ }
+ }
+ catch (const uno::Exception&)
+ {
+ }
+
+ // an object which supports XTextRange directly
+ try
+ {
+ uno::Reference<text::XTextRange> xRange(object, uno::UNO_QUERY_THROW);
+ if (xRange.is())
+ return xRange;
+ }
+ catch (const uno::Exception&)
+ {
+ }
+
+ return nullptr;
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf123218)
+{
+ struct ReverseXAxisOrientationDoughnutChart
+ : public
comphelper::ConfigurationProperty<ReverseXAxisOrientationDoughnutChart, bool>
+ {
+ static OUString path()
+ {
+ return
u"/org.openoffice.Office.Compatibility/View/ReverseXAxisOrientationDoughnutChart"_ustr;
+ }
+ ~ReverseXAxisOrientationDoughnutChart() = delete;
+ };
+
+ struct ClockwisePieChartDirection
+ : public comphelper::ConfigurationProperty<ClockwisePieChartDirection,
bool>
+ {
+ static OUString path()
+ {
+ return
u"/org.openoffice.Office.Compatibility/View/ClockwisePieChartDirection"_ustr;
+ }
+ ~ClockwisePieChartDirection() = delete;
+ };
+ auto batch = comphelper::ConfigurationChanges::create();
+
+ ReverseXAxisOrientationDoughnutChart::set(false, batch);
+ ClockwisePieChartDirection::set(true, batch);
+ batch->commit();
+
+ createSwDoc();
+
+ // create an OLE shape in the document
+ uno::Reference<lang::XMultiServiceFactory> xMSF(mxComponent,
uno::UNO_QUERY_THROW);
+ CPPUNIT_ASSERT(xMSF);
+ uno::Reference<beans::XPropertySet> xShapeProps(
+ xMSF->createInstance(u"com.sun.star.text.TextEmbeddedObject"_ustr),
uno::UNO_QUERY);
+ xShapeProps->setPropertyValue(u"CLSID"_ustr,
+
uno::Any(u"12dcae26-281f-416f-a234-c3086127382e"_ustr));
+ uno::Reference<drawing::XShape> xShape(xShapeProps, uno::UNO_QUERY_THROW);
+ xShape->setSize(awt::Size(16000, 9000));
+ uno::Reference<text::XTextContent> chartTextContent(xShapeProps,
uno::UNO_QUERY_THROW);
+ uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
+ uno::Reference<view::XSelectionSupplier>
xSelSupplier(xModel->getCurrentController(),
+
uno::UNO_QUERY_THROW);
+ uno::Any aSelection = xSelSupplier->getSelection();
+ uno::Reference<text::XTextRange> xTextRange =
getAssociatedTextRange(aSelection);
+ CPPUNIT_ASSERT(xTextRange);
+ xTextRange->getText()->insertTextContent(xTextRange, chartTextContent,
false);
+
+ // insert a doughnut chart
+ uno::Reference<frame::XModel> xDocModel;
+ xShapeProps->getPropertyValue(u"Model"_ustr) >>= xDocModel;
+ CPPUNIT_ASSERT(xDocModel);
+ uno::Reference<chart::XChartDocument> xChartDoc(xDocModel,
uno::UNO_QUERY_THROW);
+ CPPUNIT_ASSERT(xChartDoc);
+ uno::Reference<lang::XMultiServiceFactory> xChartMSF(xChartDoc,
uno::UNO_QUERY_THROW);
+ CPPUNIT_ASSERT(xChartMSF);
+ uno::Reference<chart::XDiagram> xDiagram(
+ xChartMSF->createInstance(u"com.sun.star.chart.DonutDiagram"_ustr),
uno::UNO_QUERY);
+ xChartDoc->setDiagram(xDiagram);
+
+ // test primary X axis Orientation value
+ uno::Reference<chart2::XChartDocument> xChartDoc2(xChartDoc,
uno::UNO_QUERY_THROW);
+ CPPUNIT_ASSERT(xChartDoc2);
+ uno::Reference<chart2::XCoordinateSystemContainer> xCooSysContainer(
+ xChartDoc2->getFirstDiagram(), uno::UNO_QUERY_THROW);
+ uno::Sequence<uno::Reference<chart2::XCoordinateSystem>> xCooSysSequence
+ = xCooSysContainer->getCoordinateSystems();
+ uno::Reference<chart2::XCoordinateSystem> xCoord = xCooSysSequence[0];
+ CPPUNIT_ASSERT(xCoord.is());
+ uno::Reference<chart2::XAxis> xAxis = xCoord->getAxisByDimension(0, 0);
+ CPPUNIT_ASSERT(xAxis.is());
+ chart2::ScaleData aScaleData = xAxis->getScaleData();
+ CPPUNIT_ASSERT_EQUAL(chart2::AxisOrientation_MATHEMATICAL,
aScaleData.Orientation);
+
+ // tdf#108059 test primary Y axis Orientation value
+ uno::Reference<chart2::XAxis> xYAxis = xCoord->getAxisByDimension(1, 0);
+ CPPUNIT_ASSERT(xYAxis.is());
+ aScaleData = xYAxis->getScaleData();
+ CPPUNIT_ASSERT_EQUAL(chart2::AxisOrientation_REVERSE,
aScaleData.Orientation);
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf93747)
+{
+ createSwDoc();
+ SwWrtShell* pWrtSh = getSwDocShell()->GetWrtShell();
+
+ uno::Sequence<beans::PropertyValue> aArgs(comphelper::InitPropertySequence(
+ { { "Rows", uno::Any(sal_Int32(2)) }, { "Columns",
uno::Any(sal_Int32(2)) } }));
+
+ dispatchCommand(mxComponent, u".uno:InsertTable"_ustr, aArgs);
+
+ pWrtSh->Insert(u"Col1"_ustr);
+
+ // Move the cursor to B1
+ pWrtSh->Right(SwCursorSkipMode::Chars, /*bSelect=*/false, 1,
/*bBasicCall=*/false);
+
+ pWrtSh->Insert(u"Col2"_ustr);
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xIndexAccess(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ uno::Reference<text::XTextTable> xTextTable(xIndexAccess->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTextTable->getRows()->getCount());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTextTable->getColumns()->getCount());
+
+ uno::Reference<text::XTextRange>
xCellA1(xTextTable->getCellByName(u"A1"_ustr), uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(u"Col1"_ustr, xCellA1->getString());
+
+ uno::Reference<text::XTextRange>
xCellB1(xTextTable->getCellByName(u"B1"_ustr), uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(u"Col2"_ustr, xCellB1->getString());
+
+ // Select backwards B1 and A1
+ pWrtSh->Left(SwCursorSkipMode::Chars, /*bSelect=*/true, 5,
/*bBasicCall=*/false);
+
+ // Just select the whole B1
+ pWrtSh->Right(SwCursorSkipMode::Chars, /*bSelect=*/true, 1,
/*bBasicCall=*/false);
+
+ uno::Sequence<beans::PropertyValue> aPropertyValues =
comphelper::InitPropertySequence({
+ { "Style", uno::Any(u"Heading 1"_ustr) },
+ { "FamilyName", uno::Any(u"ParagraphStyles"_ustr) },
+ });
+ dispatchCommand(mxComponent, u".uno:StyleApply"_ustr, aPropertyValues);
+
+ // Without the fix in place, this test would have failed with
+ // - Expected: Table Contents
+ // - Actual : Heading 1
+ CPPUNIT_ASSERT_EQUAL(
+ u"Table Contents"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellA1->getText()),
u"ParaStyleName"_ustr));
+
+ CPPUNIT_ASSERT_EQUAL(
+ u"Heading 1"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellB1->getText()),
u"ParaStyleName"_ustr));
+
+ // Now select A1 again
+ pWrtSh->Left(SwCursorSkipMode::Chars, /*bSelect=*/true, 1,
/*bBasicCall=*/false);
+
+ dispatchCommand(mxComponent, u".uno:StyleApply"_ustr, aPropertyValues);
+
+ CPPUNIT_ASSERT_EQUAL(
+ u"Heading 1"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellA1->getText()),
u"ParaStyleName"_ustr));
+
+ CPPUNIT_ASSERT_EQUAL(
+ u"Heading 1"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellB1->getText()),
u"ParaStyleName"_ustr));
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ CPPUNIT_ASSERT_EQUAL(
+ u"Table Contents"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellA1->getText()),
u"ParaStyleName"_ustr));
+
+ CPPUNIT_ASSERT_EQUAL(
+ u"Heading 1"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellB1->getText()),
u"ParaStyleName"_ustr));
+
+ dispatchCommand(mxComponent, u".uno:Undo"_ustr, {});
+
+ CPPUNIT_ASSERT_EQUAL(
+ u"Table Contents"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellA1->getText()),
u"ParaStyleName"_ustr));
+
+ CPPUNIT_ASSERT_EQUAL(
+ u"Table Contents"_ustr,
+ getProperty<OUString>(getParagraphOfText(1, xCellB1->getText()),
u"ParaStyleName"_ustr));
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf145151)
+{
+ createSwDoc();
+ SwWrtShell* pWrtSh = getSwDocShell()->GetWrtShell();
+
+ uno::Sequence<beans::PropertyValue> aArgs(comphelper::InitPropertySequence(
+ { { "Rows", uno::Any(sal_Int32(2)) }, { "Columns",
uno::Any(sal_Int32(2)) } }));
+
+ dispatchCommand(mxComponent, u".uno:InsertTable"_ustr, aArgs);
+
+ pWrtSh->Insert(u"Col1"_ustr);
+
+ // Move the cursor to B1
+ pWrtSh->Right(SwCursorSkipMode::Chars, /*bSelect=*/false, 1,
/*bBasicCall=*/false);
+
+ pWrtSh->Insert(u"Col2"_ustr);
+
+ uno::Reference<text::XTextTablesSupplier> xTextTablesSupplier(mxComponent,
uno::UNO_QUERY);
+ uno::Reference<container::XIndexAccess>
xIndexAccess(xTextTablesSupplier->getTextTables(),
+ uno::UNO_QUERY);
+ uno::Reference<text::XTextTable> xTextTable(xIndexAccess->getByIndex(0),
uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(1), xIndexAccess->getCount());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTextTable->getRows()->getCount());
+ CPPUNIT_ASSERT_EQUAL(sal_Int32(2), xTextTable->getColumns()->getCount());
+
+ uno::Reference<text::XTextRange>
xCellA1(xTextTable->getCellByName(u"A1"_ustr), uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(u"Col1"_ustr, xCellA1->getString());
+
+ uno::Reference<text::XTextRange>
xCellB1(xTextTable->getCellByName(u"B1"_ustr), uno::UNO_QUERY);
+ CPPUNIT_ASSERT_EQUAL(u"Col2"_ustr, xCellB1->getString());
+
+ // Select backwards B1 and A1 (select "2loC<cell>" which ends up selecting
both cells)
+ pWrtSh->Left(SwCursorSkipMode::Chars, /*bSelect=*/true, 5,
/*bBasicCall=*/false);
+
+ // Just select the whole B1
+ pWrtSh->Right(SwCursorSkipMode::Chars, /*bSelect=*/true, 1,
/*bBasicCall=*/false);
+
+ dispatchCommand(mxComponent, u".uno:DefaultNumbering"_ustr, {});
+
+ // B1 should now have a numbering style, but A1 should not be affected.
+ OUString sNumStyleB1 = getProperty<OUString>(getParagraphOfText(1,
xCellB1->getText()),
+ u"NumberingStyleName"_ustr);
+ CPPUNIT_ASSERT(!sNumStyleB1.isEmpty());
+ CPPUNIT_ASSERT_MESSAGE(
+ "Only cell B1 was selected. A1 should not have any numbering.",
+ getProperty<OUString>(getParagraphOfText(1, xCellA1->getText()),
u"NumberingStyleName"_ustr)
+ .isEmpty());
+
+ // Toggle it back off
+ dispatchCommand(mxComponent, u".uno:DefaultNumbering"_ustr, {});
+
+ CPPUNIT_ASSERT_MESSAGE(
+ "Cell B1 must be able to toggle numbering on and off.",
+ getProperty<OUString>(getParagraphOfText(1, xCellB1->getText()),
u"NumberingStyleName"_ustr)
+ .isEmpty());
+
+ // Now test removing numbering/bullets
+ // Add A1 to the current B1 selection
+ pWrtSh->Left(SwCursorSkipMode::Chars, /*bSelect=*/true, 1,
/*bBasicCall=*/false);
+
+ // Toggle on bullet numbering
+ dispatchCommand(mxComponent, u".uno:DefaultBullet"_ustr, {});
+
+ // sanity check - both cells have bullets turned on.
+ OUString sNumStyleA1 = getProperty<OUString>(getParagraphOfText(1,
xCellA1->getText()),
+ u"NumberingStyleName"_ustr);
+ CPPUNIT_ASSERT(!sNumStyleA1.isEmpty());
+ CPPUNIT_ASSERT_EQUAL(sNumStyleA1,
+ getProperty<OUString>(getParagraphOfText(1,
xCellB1->getText()),
+ u"NumberingStyleName"_ustr));
+ CPPUNIT_ASSERT(sNumStyleA1 != sNumStyleB1); // therefore B1 changed from
numbering to bullets
+
+ // Just select cell B1
+ pWrtSh->Right(SwCursorSkipMode::Chars, /*bSelect=*/true, 1,
/*bBasicCall=*/false);
+
+ // Toggle off bullet numbering
+ dispatchCommand(mxComponent, u".uno:DefaultBullet"_ustr, {});
+
+ // B1 should now have removed all numbering, while A1 should still have
the bullet.
+ CPPUNIT_ASSERT(
+ getProperty<OUString>(getParagraphOfText(1, xCellB1->getText()),
u"NumberingStyleName"_ustr)
+ .isEmpty());
+ CPPUNIT_ASSERT_MESSAGE("Only cell B1 was selected. A1 should still have
bullets turned on.",
+ !getProperty<OUString>(getParagraphOfText(1,
xCellA1->getText()),
+ u"NumberingStyleName"_ustr)
+ .isEmpty());
+
+ // Toggle it back on
+ dispatchCommand(mxComponent, u".uno:DefaultBullet"_ustr, {});
+
+ CPPUNIT_ASSERT(!getProperty<OUString>(getParagraphOfText(1,
xCellB1->getText()),
+ u"NumberingStyleName"_ustr)
+ .isEmpty());
+}
+
+CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testTdf126735)
+{
+ createSwDoc("tdf39721.fodt");
+ SwDoc* pDoc = getSwDoc();
+
+ //turn on red-lining and show changes
+ pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
+ |
RedlineFlags::ShowInsert);
+ CPPUNIT_ASSERT_MESSAGE("redlining should be on",
+ pDoc->getIDocumentRedlineAccess().IsRedlineOn());
+ CPPUNIT_ASSERT_MESSAGE(
+ "redlines should be visible",
+
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
+
+ // check next selected tracked change
+ dispatchCommand(mxComponent, u".uno:NextTrackedChange"_ustr, {});
+ uno::Reference<frame::XModel> xModel(mxComponent, uno::UNO_QUERY);
+ uno::Reference<view::XSelectionSupplier>
xSelSupplier(xModel->getCurrentController(),
+
uno::UNO_QUERY_THROW);
+ uno::Any aSelection = xSelSupplier->getSelection();
+ uno::Reference<text::XTextRange> xTextRange =
getAssociatedTextRange(aSelection);
+ CPPUNIT_ASSERT(xTextRange);
+ CPPUNIT_ASSERT_EQUAL(u" ipsu"_ustr, xTextRange->getString());
+
+ // check next selected tracked change
+ dispatchCommand(mxComponent, u".uno:NextTrackedChange"_ustr, {});
+ aSelection = xSelSupplier->getSelection();
+ xTextRange = getAssociatedTextRange(aSelection);
+ CPPUNIT_ASSERT(xTextRange);
+ CPPUNIT_ASSERT_EQUAL(u"or "_ustr, xTextRange->getString());
+
+ // check next selected tracked change at the end of the document:
+ // select the first tracked change of the document
+ dispatchCommand(mxComponent, u".uno:NextTrackedChange"_ustr, {});
+ aSelection = xSelSupplier->getSelection();
+ xTextRange = getAssociatedTextRange(aSelection);
+ CPPUNIT_ASSERT(xTextRange);
+ // This was empty (collapsing at the end of the last tracked change)
+ CPPUNIT_ASSERT_EQUAL(u" ipsu"_ustr, xTextRange->getString());
+
+ // check the previous tracked change at the start of the document:
+ // select the last tracked change of the document
+ dispatchCommand(mxComponent, u".uno:PreviousTrackedChange"_ustr, {});
+ aSelection = xSelSupplier->getSelection();
+ xTextRange = getAssociatedTextRange(aSelection);
+ CPPUNIT_ASSERT(xTextRange);
+ // This was empty (collapsing at the start of the last tracked change)
+ CPPUNIT_ASSERT_EQUAL(u"or "_ustr, xTextRange->getString());
+}
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/qa/extras/uiwriter/uiwriter5.cxx
b/sw/qa/extras/uiwriter/uiwriter5.cxx
index 73c1a95f4395..e37df27fd817 100644
--- a/sw/qa/extras/uiwriter/uiwriter5.cxx
+++ b/sw/qa/extras/uiwriter/uiwriter5.cxx
@@ -14,19 +14,12 @@
#include <com/sun/star/awt/FontSlant.hpp>
#include <com/sun/star/awt/FontUnderline.hpp>
#include <com/sun/star/awt/FontWeight.hpp>
-#include <com/sun/star/chart/XChartDocument.hpp>
-#include <com/sun/star/chart2/XChartDocument.hpp>
-#include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
-#include <com/sun/star/view/XSelectionSupplier.hpp>
-#include <com/sun/star/text/XTextTable.hpp>
#include <comphelper/propertysequence.hxx>
#include <comphelper/propertyvalue.hxx>
-#include <comphelper/configuration.hxx>
-#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+#include <comphelper/processfactory.hxx>
#include <vcl/scheduler.hxx>
#include <vcl/settings.hxx>
#include <ndtxt.hxx>
-#include <swdtflvr.hxx>
#include <wrtsh.hxx>
#include <IDocumentRedlineAccess.hxx>
#include <flyfrm.hxx>
@@ -43,16 +36,12 @@
#include <cmdid.h>
#include <AnnotationWin.hxx>
#include <PostItMgr.hxx>
-#include <fmtcntnt.hxx>
#include <frameformats.hxx>
-#include <shellio.hxx>
-#include <editeng/fontitem.hxx>
#include <tools/json_writer.hxx>
#include <unotxdoc.hxx>
#include <IDocumentLayoutAccess.hxx>
#include <rootfrm.hxx>
#include <com/sun/star/packages/zip/ZipFileAccess.hpp>
-#include <redline.hxx>
/// Second set of tests asserting the behavior of Writer user interface shells.
class SwUiWriterTest5 : public SwModelTestBase
@@ -2054,2032 +2043,6 @@ CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testTdf47979_column)
assertXPathContent(pXmlDoc, "//page[1]//body/tab/row[1]/cell[2]/txt[1]",
u"B1");
}
-CPPUNIT_TEST_FIXTURE(SwUiWriterTest5, testRedlineTableRowDeletionWithExport)
-{
- // load a 1-row table, and delete the row with enabled change tracking:
- // now the row is not deleted silently, but keeps the deleted cell
contents,
- // and only accepting all of them will result the deletion of the table
row.
- createSwDoc("tdf118311.fodt");
- SwDoc* pDoc = getSwDoc();
-
- // turn on red-lining and show changes
- pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
- |
RedlineFlags::ShowInsert);
- CPPUNIT_ASSERT_MESSAGE("redlining should be on",
- pDoc->getIDocumentRedlineAccess().IsRedlineOn());
- CPPUNIT_ASSERT_MESSAGE(
- "redlines should be visible",
-
IDocumentRedlineAccess::IsShowChanges(pDoc->getIDocumentRedlineAccess().GetRedlineFlags()));
-
- // check table
- xmlDocUniquePtr pXmlDoc = parseLayoutDump();
- assertXPath(pXmlDoc, "//page[1]//body/tab");
-
- // delete table row with enabled change tracking
- // (HasTextChangesOnly property of the row will be false)
- dispatchCommand(mxComponent, u".uno:DeleteRows"_ustr, {});
-
- // Deleted text content with change tracking,
- // but not table deletion
- pXmlDoc = parseLayoutDump();
- assertXPath(pXmlDoc, "//page[1]//body/tab");
-
- // Save it and load it back.
- saveAndReload(u"writer8"_ustr);
- pDoc = getSwDoc();
-
- // accept the deletion of the content of the first cell
- SwEditShell* const pEditShell(pDoc->GetEditShell());
- CPPUNIT_ASSERT(pEditShell);
- CPPUNIT_ASSERT_EQUAL(static_cast<SwRedlineTable::size_type>(2),
pEditShell->GetRedlineCount());
- pEditShell->AcceptRedline(0);
-
- // table row was still not deleted
- pXmlDoc = parseLayoutDump();
- assertXPath(pXmlDoc, "//page[1]//body/tab");
-
- // accept last redline
- pEditShell->AcceptRedline(0);
-
- // table row (and the 1-row table) was deleted finally
- // (working export/import of HasTextChangesOnly)
- pXmlDoc = parseLayoutDump();
- assertXPath(pXmlDoc, "//page[1]//body/tab", 0);
-}
-
-CPPUNIT_TEST_FIXTURE(SwUiWriterTest5,
testRedlineTableRowDeletionWithDOCXExport)
-{
- // load a 1-row table, and delete the row with enabled change tracking:
- // now the row is not deleted silently, but keeps the deleted cell
contents,
- // and only accepting all of them will result the deletion of the table
row.
- createSwDoc("tdf118311.fodt");
- SwDoc* pDoc = getSwDoc();
-
- // turn on red-lining and show changes
- pDoc->getIDocumentRedlineAccess().SetRedlineFlags(RedlineFlags::On |
RedlineFlags::ShowDelete
- |
RedlineFlags::ShowInsert);
-e
... etc. - the rest is truncated
