Merge pull request #1163 from JSv4/fix/issue-1155

fix(html): give mixed-direction bordered paragraphs their own boxes when indents differ (#1155)

Author: JSv4

CHANGELOG.md

@@ -163,6 +163,12 @@ All notable changes to this project will be documented in this file.
   unit in the CSS (`in` to `pt`) but not size, beyond the removed rounding. A tab advance that ran out
   of tab stops now falls back to half an inch, as intended, instead of 720 inches. The page-geometry
   `data-*` attributes the paginator reads still carry 0.1pt.
+- Consecutive bordered paragraphs that mix text directions no longer share one border box when their
+  start and end indents differ (issue #1155). The converter joined paragraphs with the same borders
+  and indents into one box, but a right-to-left paragraph mirrors its box (its start indent is on the
+  right), so with `w:start="720" w:end="1440"` one paragraph of the pair got its indents on the wrong
+  sides. Such paragraphs now get a box each, as LibreOffice draws them; paragraphs whose boxes
+  coincide in both directions (equal start and end) still join, with between borders.
 - Table row heights honour `w:hRule` (issue #1122). A minimum (`atLeast`, or omitted) height now
   bounds the row's content and the collapsed horizontal borders are added to it, as in the reference
   layout (a 36pt row with 0.75pt borders advances 36.75pt); an `exact` height is the whole row and

Docxodus.Tests/RightToLeftParagraphBorderTests.cs

@@ -81,4 +81,61 @@ public void RightToLeftIndentsMirrorWhileBordersStayPhysical()
         Assert.Equal("67.25pt", rtl["margin-right"]);
         Assert.Equal("6.5pt", rtl["margin-left"]);
     }
+    // Issue #1155: consecutive bordered paragraphs share a box only when their boxes coincide.
+    private const string SingleBorders =
+        "<w:pBdr><w:top w:val=\"single\" w:sz=\"8\" w:space=\"4\"/><w:left w:val=\"single\" w:sz=\"8\" w:space=\"4\"/>" +
+        "<w:bottom w:val=\"single\" w:sz=\"8\" w:space=\"4\"/><w:right w:val=\"single\" w:sz=\"8\" w:space=\"4\"/>" +
+        "<w:between w:val=\"single\" w:sz=\"8\" w:space=\"4\"/></w:pBdr>";
+
+    private static string Boxed(string text, string ind, bool bidi) =>
+        $"<w:p><w:pPr>{(bidi ? "<w:bidi/>" : "")}{SingleBorders}{ind}</w:pPr><w:r><w:t>{text}</w:t></w:r></w:p>";
+
+    private const string Unequal = "<w:ind w:start=\"720\" w:end=\"1440\"/>";
+
+    [Fact]
+    public void MixedDirectionsWithUnequalIndentsGetMirroredBoxes()
+    {
+        var html = Convert(Boxed("Eastward", Unequal, bidi: false), Boxed("Westward", Unequal, bidi: true));
+
+        Assert.Equal(2, Wrappers(html).Count);
+        var ltr = Style(WrapperOf(html, "Eastward"));
+        var rtl = Style(WrapperOf(html, "Westward"));
+        // Start 36pt and end 72pt, each less the 4pt space and the 0.75pt border.
+        Assert.Equal("31.25pt", ltr["margin-left"]);
+        Assert.Equal("67.25pt", ltr["margin-right"]);
+        Assert.Equal("31.25pt", rtl["margin-right"]);
+        Assert.Equal("67.25pt", rtl["margin-left"]);
+    }
+
+    [Fact]
+    public void MixedDirectionsWithEqualIndentsStillShareOneBox()
+    {
+        var equal = "<w:ind w:start=\"720\" w:end=\"720\"/>";
+        var html = Convert(Boxed("Eastward", equal, bidi: false), Boxed("Westward", equal, bidi: true),
+            Boxed("Onward", equal, bidi: false));
+
+        var wrapper = Assert.Single(Wrappers(html));
+        Assert.Equal(3, wrapper.Descendants().Count(e => e.Name.LocalName == "p"));
+    }
+
+    [Fact]
+    public void RightToLeftParagraphsWithUnequalIndentsShareOneBox()
+    {
+        var html = Convert(Boxed("Westward", Unequal, bidi: true), Boxed("Seaward", Unequal, bidi: true));
+
+        var wrapper = Assert.Single(Wrappers(html));
+        Assert.Equal("31.25pt", Style(wrapper)["margin-right"]);
+        Assert.Equal("67.25pt", Style(wrapper)["margin-left"]);
+    }
+    [Fact]
+    public void MixedDirectionsShareOneBoxWhenAHangingIndentMakesTheBoxSymmetric()
+    {
+        // Start 72pt less a 36pt hanging indent puts the box's leading edge 36pt in, the same as the
+        // 36pt end: the box is the same in either direction, so the paragraphs join (as LibreOffice joins them).
+        var hanging = "<w:ind w:start=\"1440\" w:hanging=\"720\" w:end=\"720\"/>";
+        var html = Convert(Boxed("Eastward", hanging, bidi: false), Boxed("Westward", hanging, bidi: true));
+
+        var wrapper = Assert.Single(Wrappers(html));
+        Assert.Equal(2, wrapper.Descendants().Count(e => e.Name.LocalName == "p"));
+    }
 }

Docxodus/WmlToHtmlConverter.cs

@@ -10006,11 +10006,31 @@ internal static string BorderGroupKey(XElement e, XElement? pPr)
                 var ind = pPr!.Element(W.ind);
                 if (ind != null)
                     indStr = WithoutUnids(ind);
-                return WithoutUnids(pBdr) + indStr;
+                // A right-to-left paragraph mirrors its box (leading indent on the right), so with unequal
+                // leading and trailing indents it cannot share a box with a left-to-right paragraph. The
+                // direction joins the key only then: paragraphs whose boxes coincide still join, with
+                // between borders, as LibreOffice joins them (issue #1155).
+                var direction = HasBidi(pPr) && !BorderBoxIsMirrorSymmetric(ind) ? "|rtl" : string.Empty;
+                return WithoutUnids(pBdr) + indStr + direction;
             }
             return e.Name == W.tbl ? "table" : string.Empty;
         }
 
+        private static bool HasBidi(XElement pPr) =>
+            pPr.Elements(W.bidi).Any(b => b.Attribute(W.val) == null || b.Attribute(W.val).ToBoolean() == true);
+
+        /// <summary>Whether a border box laid out from <paramref name="ind"/> is the same in either
+        /// direction: its leading edge (the leading indent less any hanging indent, as
+        /// <see cref="CreateBorderDivs"/> places it) and its trailing edge are equally far in.</summary>
+        private static bool BorderBoxIsMirrorSymmetric(XElement? ind)
+        {
+            if (ind == null) return true;
+            var leading = WordprocessingMLUtil.AttributeToDecimalTwips(WordprocessingMLUtil.IndLeadingAttribute(ind)) ?? 0m;
+            var hanging = WordprocessingMLUtil.AttributeToDecimalTwips(ind.Attribute(W.hanging)) ?? 0m;
+            var trailing = WordprocessingMLUtil.AttributeToDecimalTwips(WordprocessingMLUtil.IndTrailingAttribute(ind)) ?? 0m;
+            return Math.Max(0m, leading - hanging) == Math.Max(0m, trailing);
+        }
+
         /// <summary>The element's markup with the projector's per-element Unid bookkeeping
         /// removed. Two paragraphs with the same borders must key alike whether or not a session
         /// has stamped their property elements — otherwise a document rendered from a session

docs/ooxml_corner_cases.md

@@ -3069,6 +3069,21 @@ Docxodus already behaved this way; `RightToLeftParagraphBorderTests` pins it. `C
 the sides the paragraph's direction gives them, so each margin subtracts the outset of the border that
 is physically on that side. A Word reference for this fixture would settle the last row.
 
+### Mixed directions in one bordered group (issue #1155)
+
+Consecutive paragraphs with identical borders and indents join into one box with `w:between` borders.
+With unequal start and end indents, a left-to-right and a right-to-left paragraph have mirror-image
+boxes, so they cannot share one.
+
+| Two paragraphs, `w:ind w:start="720"`, second `w:bidi` | LibreOffice 25.8.7.3 | Docxodus before | Docxodus after |
+|---|---|---|---|
+| `w:end="720"` (equal) | one box, between border | one box | one box |
+| `w:end="1440"` (unequal) | a box per paragraph, each mirrored | one box: one paragraph's indents on the wrong sides | a box per paragraph, each mirrored |
+
+`BorderGroupKey` adds the direction to the key only when the box is not mirror-symmetric
+(`BorderBoxIsMirrorSymmetric`), so grouping is otherwise unchanged. Word's grouping for this case has
+not been measured.
+
 ## Contributing
 
 When adding new corner cases to this document: