Fix empty TR tag copying

DEVSIX-5974

Author: Alexander Pliushchou

kernel/src/main/java/com/itextpdf/kernel/pdf/tagging/McrCheckUtil.java

@@ -0,0 +1,65 @@
+package com.itextpdf.kernel.pdf.tagging;
+
+import com.itextpdf.kernel.pdf.PdfDictionary;
+import com.itextpdf.kernel.pdf.tagutils.ITagTreeIteratorHandler;
+import com.itextpdf.kernel.pdf.tagutils.TagTreeIterator;
+
+/**
+ * Class that provides methods for searching mcr in tag tree.
+ */
+public final class McrCheckUtil {
+
+    /**
+     * Creates a new {@link McrCheckUtil} instance.
+     */
+    private McrCheckUtil() {
+        // Empty constructor
+    }
+
+    /**
+     * Checks if tag structure of TR element contains any mcr.
+     *
+     * @param elementTR PdfDictionary of TR element.
+     *
+     * @return true if mcr found.
+     */
+    public static boolean isTrContainsMcr(PdfDictionary elementTR) {
+        TagTreeIterator tagTreeIterator = new TagTreeIterator(new PdfStructElem(elementTR));
+        McrCheckUtil.McrTagHandler handler = new McrCheckUtil.McrTagHandler();
+        tagTreeIterator.addHandler(handler);
+        tagTreeIterator.traverse();
+        return handler.tagTreeHaveMcr();
+    }
+
+    /**
+     * Search for mcr elements in the TagTree.
+     */
+    private static class McrTagHandler implements ITagTreeIteratorHandler {
+
+        private boolean haveMcr = false;
+
+        /**
+         * Method returns if tag tree has mcr in it.
+         */
+        public boolean tagTreeHaveMcr() {
+            return haveMcr;
+        }
+
+        /**
+         * Creates a new {@link  McrTagHandler} instance.
+         */
+        public McrTagHandler() {
+            //empty constructor
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void nextElement(IStructureNode elem) {
+            if ((elem instanceof PdfMcr)) {
+                haveMcr = true;
+            }
+        }
+    }
+}

kernel/src/main/java/com/itextpdf/kernel/pdf/tagging/StructureTreeCopier.java

@@ -244,11 +244,13 @@ private static void copyTo(PdfDocument destDocument, int insertBeforePage, Map<P
      * @param page2page  association between original page and copied page.
      * @param copyFromDestDocument indicates if <code>page2page</code> keys and values represent pages from {@code destDocument}.
      */
-    private static void copyTo(PdfDocument destDocument, Map<PdfPage, PdfPage> page2page, PdfDocument callingDocument, boolean copyFromDestDocument) {
+    private static void copyTo(PdfDocument destDocument, Map<PdfPage, PdfPage> page2page, PdfDocument callingDocument
+            , boolean copyFromDestDocument) {
         copyTo(destDocument, page2page, callingDocument, copyFromDestDocument, -1);
     }
 
-    private static void copyTo(PdfDocument destDocument, Map<PdfPage, PdfPage> page2page, PdfDocument callingDocument, boolean copyFromDestDocument, int insertIndex) {
+    private static void copyTo(PdfDocument destDocument, Map<PdfPage, PdfPage> page2page, PdfDocument callingDocument
+            , boolean copyFromDestDocument, int insertIndex) {
         CopyStructureResult copiedStructure = copyStructure(destDocument, page2page, callingDocument, copyFromDestDocument);
         PdfStructTreeRoot destStructTreeRoot = destDocument.getStructTreeRoot();
         destStructTreeRoot.makeIndirect(destDocument);
@@ -283,7 +285,8 @@ private static void copyTo(PdfDocument destDocument, Map<PdfPage, PdfPage> page2
         }
     }
 
-    private static CopyStructureResult copyStructure(PdfDocument destDocument, Map<PdfPage, PdfPage> page2page, PdfDocument callingDocument, boolean copyFromDestDocument) {
+    private static CopyStructureResult copyStructure(PdfDocument destDocument, Map<PdfPage, PdfPage> page2page
+            , PdfDocument callingDocument, boolean copyFromDestDocument) {
         PdfDocument fromDocument = copyFromDestDocument ? destDocument : callingDocument;
         Map<PdfDictionary, PdfDictionary> topsToFirstDestPage = new HashMap<>();
         Set<PdfObject> objectsToCopy = new HashSet<>();
@@ -380,16 +383,23 @@ private static PdfDictionary copyObject(PdfDictionary source, PdfDictionary dest
         }
 
         PdfObject k = source.get(PdfName.K);
+        PdfDictionary lastCopiedTrPage = null;
         if (k != null) {
             if (k.isArray()) {
                 PdfArray kArr = (PdfArray) k;
                 PdfArray newArr = new PdfArray();
                 for (int i = 0; i < kArr.size(); i++) {
-                    PdfObject copiedKid = copyObjectKid(kArr.get(i), copied, destPage, parentChangePg, copyingParams);
+                    PdfObject copiedKid = copyObjectKid(kArr.get(i), copied, destPage, parentChangePg, copyingParams
+                            , lastCopiedTrPage);
                     if (copiedKid != null) {
                         newArr.add(copiedKid);
+                        if (copiedKid instanceof PdfDictionary
+                                && PdfName.TR.equals(((PdfDictionary) copiedKid).getAsName(PdfName.S))) {
+                            lastCopiedTrPage = destPage;
+                        }
                     }
                 }
+
                 if (!newArr.isEmpty()) {
                     if (newArr.size() == 1) {
                         copied.put(PdfName.K, newArr.get(0));
@@ -398,7 +408,8 @@ private static PdfDictionary copyObject(PdfDictionary source, PdfDictionary dest
                     }
                 }
             } else {
-                PdfObject copiedKid = copyObjectKid(k, copied, destPage, parentChangePg, copyingParams);
+                PdfObject copiedKid = copyObjectKid(k, copied, destPage, parentChangePg, copyingParams
+                        , lastCopiedTrPage);
                 if (copiedKid != null) {
                     copied.put(PdfName.K, copiedKid);
                 }
@@ -407,7 +418,9 @@ private static PdfDictionary copyObject(PdfDictionary source, PdfDictionary dest
         return copied;
     }
 
-    private static PdfObject copyObjectKid(PdfObject kid, PdfDictionary copiedParent, PdfDictionary destPage, boolean parentChangePg, StructElemCopyingParams copyingParams) {
+    private static PdfObject copyObjectKid(PdfObject kid, PdfDictionary copiedParent, PdfDictionary destPage,
+                                           boolean parentChangePg, StructElemCopyingParams copyingParams,
+                                           PdfDictionary lastCopiedTrPage) {
         if (kid.isNumber()) {
             if (!parentChangePg) {
                 copyingParams.getToDocument().getStructTreeRoot().getParentTreeHandler()
@@ -416,11 +429,27 @@ private static PdfObject copyObjectKid(PdfObject kid, PdfDictionary copiedParent
             }
         } else if (kid.isDictionary()) {
             PdfDictionary kidAsDict = (PdfDictionary) kid;
-            // if element is TD and its parent is TR which was copied, then we copy it in any case
+            //if element is TD and its parent is TR which was copied, then we copy it in any case
             if (copyingParams.getObjectsToCopy().contains(kidAsDict) ||
                     shouldTableElementBeCopied(kidAsDict, copiedParent)) {
+                //if TR element is not connected to any page,
+                //it should be copied to the same page as the last copied TR which connected to page
+                PdfDictionary destination = destPage;
+                if (PdfName.TR.equals(kidAsDict.getAsName(PdfName.S))
+                        && !copyingParams.getObjectsToCopy().contains(kidAsDict)) {
+                    if (McrCheckUtil.isTrContainsMcr(kidAsDict)){
+                        return null;
+                    }
+
+                    if (lastCopiedTrPage == null) {
+                        return null;
+                    } else {
+                        destination = lastCopiedTrPage;
+                    }
+                }
                 boolean hasParent = kidAsDict.containsKey(PdfName.P);
-                PdfDictionary copiedKid = copyObject(kidAsDict, destPage, parentChangePg, copyingParams);
+                PdfDictionary copiedKid = copyObject(kidAsDict, destination, parentChangePg, copyingParams);
+
                 if (hasParent) {
                     copiedKid.put(PdfName.P, copiedParent);
                 } else {
@@ -446,8 +475,9 @@ private static PdfObject copyObjectKid(PdfObject kid, PdfDictionary copiedParent
     }
 
     static boolean shouldTableElementBeCopied(PdfDictionary obj, PdfDictionary parent) {
-        return (PdfName.TD.equals(obj.get(PdfName.S)) || PdfName.TH.equals(obj.get(PdfName.S)))
-                && PdfName.TR.equals(parent.get(PdfName.S));
+        PdfName role = obj.getAsName(PdfName.S);
+        return ((PdfName.TD.equals(role) || PdfName.TH.equals(role)) && PdfName.TR.equals(parent.get(PdfName.S)))
+                || PdfName.TR.equals(role);
     }
 
     private static PdfDictionary copyNamespaceDict(PdfDictionary srcNsDict, StructElemCopyingParams copyingParams) {

kernel/src/test/java/com/itextpdf/kernel/pdf/tagging/StructureTreeCopierUnitTest.java

@@ -76,15 +76,15 @@ public void shouldTableElementBeCopiedTrTdTest() {
         PdfDictionary obj = new PdfDictionary(tr);
         PdfDictionary parent = new PdfDictionary(td);
 
-        Assert.assertFalse(StructureTreeCopier.shouldTableElementBeCopied(obj, parent));
+        Assert.assertTrue(StructureTreeCopier.shouldTableElementBeCopied(obj, parent));
     }
 
     @Test
     public void shouldTableElementBeCopiedTrTrTest() {
         PdfDictionary obj = new PdfDictionary(tr);
         PdfDictionary parent = new PdfDictionary(tr);
 
-        Assert.assertFalse(StructureTreeCopier.shouldTableElementBeCopied(obj, parent));
+        Assert.assertTrue(StructureTreeCopier.shouldTableElementBeCopied(obj, parent));
     }
 
     @Test

kernel/src/test/java/com/itextpdf/kernel/utils/PdfMergerTest.java

@@ -275,11 +275,78 @@ public void tdInsideTdTableTest() throws ParserConfigurationException, SAXExcept
     }
 
     @Test
-    // TODO DEVSIX-5974 Empty tr isn't copied.
     public void emptyTrTableTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
         mergeAndCompareTagStructures("emptyTrTable.pdf", 1, 1);
     }
 
+    @Test
+    public void splitEmptyTrTableFirstPageTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("splitTableWithEmptyTrFirstPage.pdf", 1, 1);
+    }
+
+    @Test
+    public void splitEmptyTrTableSecondPageTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("splitTableWithEmptyTrSecondPage.pdf", 2, 2);
+    }
+
+    @Test
+    public void splitEmptyTrTableFullTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("splitTableWithEmptyTrFull.pdf", 1, 2);
+    }
+
+    @Test
+    public void emptyFirstTrTableTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("emptyFirstTrTable.pdf", 1, 1);
+    }
+
+    @Test
+    public void emptyLastTrTableTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("emptyLastTrTable.pdf", 1, 1);
+    }
+
+    @Test
+    public void emptyTwoAdjacentTrTableTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("emptyTwoAdjacentTrTable.pdf", 1, 1);
+    }
+
+    @Test
+    public void emptyAllTrTableTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("emptyAllTrTable.pdf", 1, 1);
+    }
+
+    @Test
+    public void emptySingleTrTableTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        mergeAndCompareTagStructures("emptySingleTrTable.pdf", 1, 1);
+    }
+
+    @Test
+    public void splitAndMergeEmptyTrTableTest() throws ParserConfigurationException, SAXException, IOException, InterruptedException {
+        String sourceFilename = sourceFolder + "splitTableWithEmptyTrFull.pdf";
+        String firstPageFilename = destinationFolder + "firstPageDoc.pdf";
+        String secondPageFilename = destinationFolder + "secondPageDoc.pdf";
+        String resultFilename = destinationFolder + "splitAndMergeEmptyTrTable.pdf";
+        String cmpFilename = sourceFolder + "cmp_splitAndMergeEmptyTrTable.pdf";
+
+        PdfDocument sourceDoc = new PdfDocument(new PdfReader(sourceFilename));
+
+        PdfDocument firstPageDoc = new PdfDocument(new PdfWriter(firstPageFilename));
+        PdfMerger mergerFirstPage =  new PdfMerger(firstPageDoc);
+        mergerFirstPage.merge(sourceDoc, 1, 1);
+        mergerFirstPage.close();
+
+        PdfDocument secondPageDoc = new PdfDocument(new PdfWriter(secondPageFilename));
+        PdfMerger mergerSecondPage = new PdfMerger(secondPageDoc);
+        mergerSecondPage.merge(sourceDoc, 2, 2);
+        mergerSecondPage.close();
+
+        List<File> sources = new ArrayList<File>();
+        sources.add(new File(firstPageFilename));
+        sources.add(new File(secondPageFilename));
+        mergePdfs(sources, resultFilename, new PdfMergerProperties(), false);
+
+        Assert.assertNull(new CompareTool().compareTagStructures(resultFilename, cmpFilename));
+    }
+
     @Test
     @LogMessages(messages = {@LogMessage(messageTemplate = IoLogMessageConstant.NAME_ALREADY_EXISTS_IN_THE_NAME_TREE, count = 2)})
     public void mergeOutlinesNamedDestinations() throws IOException, InterruptedException {