It fails closed, on positive signals rather than on the absence of a complaint. A fixture * built for the case must come back named, so a detector that stops seeing its target fails here - * rather than reporting a clean corpus ({@link #aDrawingOverAPaintedNeighbourIsAlwaysNamed}). The + * rather than reporting a clean corpus ({@link #aDrawingAPaintedNeighbourIsLaidOverInTurnIsAlwaysNamed}, + * {@link #aDrawingOverAPaintedNeighbourIsCarriedInFrontOfIt}). The * corpus must come back with its documents laid out and with the hundreds of drawings it paints. * A note that says a shape was drawn and that this test cannot classify is a failure rather than a * silence: the export has four notes whose wording begins that way and only two of them are a @@ -77,31 +78,39 @@ * a rail drawn as a line, a picture drawn over the badge holding it — which the export judges and * this test checks one by one instead ({@link #NAMED_BUT_UNPLACEABLE}).
* - *The list is a ledger of work still to do, not a licence: the export has no drawing it is - * content to leave under a neighbour's fill. The entry goes when the stack's order is carried into - * the document, and this test then fails until the ledger is brought down to match.
+ *The ledger is empty. The stack's order is carried into the document — a drawing on a layer the + * page paints after a painted layer of the same stack stands in front of the text — and the one + * instance the corpus held, the icon over a card's corner, is drawn in front and covered by + * nothing. An entry coming back is a drawing the export has gone back to losing under a + * neighbour's fill, and this test then fails until either the export or the ledger is put right. + * What keeps a drawing behind the text on purpose — a painted layer the page lays over it in turn, + * a box holding a line of the flow, another drawing of the stack that one of those keeps there — + * the export names, and the corpus holds no instance of the first two (so the fixtures below carry + * the positive signal that it still can).
+ * + *What this corpus can and cannot say is written down in numbers rather than left to a reader of + * empty lists: it lifts one drawing ({@link #LIFTED_IN_THE_CORPUS}) and offers no pair at all to + * judge the two lists of {@link #PAIRS_THE_CORPUS_OFFERS} over. Those rules are held by the + * fixtures of {@code DocxDrawingUnderANeighboursFillTest}, and what is held here is that the + * corpus has not started asking something new.
* * @author Artem Demchyshyn */ class DocxNeighbourFillGuardTest { /** - * The icon laid over a card's top right corner through a layer stack: the card is a painted - * panel on the layer below, and the icon's 18pt box stands wholly inside it. Both editors - * paint the card's fill over it, and neither draws one pixel of its ink. + * Empty: no drawing of the corpus is left under a neighbour's fill. * - *It is the corpus's only instance, and it is a synthetic document rather than a shipped - * preset: of the seventy-one, sixty-four are presets — twenty-six CVs, seventeen invoices, - * fifteen letters, four proposals, a receipt and a rota — and not one of them lays a drawing - * over a painted neighbour. The synthetic document was not written for this case either. It - * joined the corpus to hold a band's space above and below the panel that opens it, and the - * commit that added it says in as many words that the fidelity gate reads lines of text, so - * where the icon stands it does not see. The case is therefore measured and real, and no - * preset is known to reach it.
+ *It held one entry — the icon laid over a card's top right corner in + * {@code synthetic-icon_over_card}, whose 18pt box stands wholly inside the card painted on the + * layer below, and of which neither editor drew one pixel. Carrying the stack's order into the + * document draws that icon in front of the text, where the card's shading does not reach it, + * and the export names nothing for it. That was the corpus's only instance: of the seventy-one + * documents, sixty-four are presets — twenty-six CVs, seventeen invoices, fifteen letters, four + * proposals, a receipt and a rota — and not one of them lays a drawing over a painted + * neighbour.
*/ - private static final MapZero. Measured, and said out loud rather than left for a reader to take + * the two empty lists for a clean corpus: of the drawings the export lifts here, not one has a + * painted panel or a drawing left behind that the page paints after it, so neither list can + * have anything in it whatever the export does. The rules those lists stand for are held by + * the unit fixtures written for them in {@code DocxDrawingUnderANeighboursFillTest}; the + * number is asserted exactly so that a corpus which starts offering a pair is seen here + * instead of quietly making the lists mean something new.
+ */ + private static final int PAIRS_THE_CORPUS_OFFERS = 0; + + /** + * The drawings of the corpus the export lifts in front of the text over a painted layer under + * them. + * + *One, in one document: the icon over the card, which is the case this was + * measured on. A shape is lifted only where it is the only drawing over that painted layer, + * and the seventy other documents hold no such stack — {@code cv-sidebar_portrait} draws + * thirty-seven times over its painted sidebar, so none of those is lifted and that document is + * byte for byte what the export wrote before. Asserted exactly rather than as a floor, so that + * a corpus which starts lifting more, or stops lifting this one, is seen here.
+ */ + private static final int LIFTED_IN_THE_CORPUS = 1; + @Test void everyDrawingUnderANeighboursFillIsLedgered() throws Exception { MapA panel is written as a shaded cell, and a cell's fill belongs to the text layer, which + * both editors paint over everything drawn behind that layer. A shape drawn behind the text + * under such a neighbour is therefore not seen at all, however the page stacks the two: + * measured at 300 dpi on the one document of the fidelity corpus that holds the case, an 18pt + * icon laid over a card's corner through a layer stack, the engine's PDF draws 4308 pixels of + * the icon's own ink and Word 16.0.20527 and LibreOffice 24.2 draw none — not one pixel + * anywhere on the page. With the card unpainted, the one difference, Word draws every pixel + * the engine does. So the order is taken from the tree: a layer the page paints after a + * painted one stands in front of the text.
+ * + *A painted layer the page paints after the node needs no clause of its own: a + * layer that paints is drawn, so the test below catches it along with everything else painted + * after the node. It was written as its own check first and removed when breaking it reddened + * no test — there the page covers the node, and a shape in front would cover that layer's + * shading instead, which is the same loss the other way round and the same answer.
+ * + *So does anything of any overlay it stands in that the page paints after it + * ({@code drawnOverThatLayer}): a shape is lifted where nothing is drawn over it, and + * otherwise not. Word draws every shape in front over every shape behind, so lifting a shape + * the page covers with another drawing puts the lower of the two over the higher — the loss + * this fixes, made worse. Asked at every overlay of the climb, painted or not: a sibling in + * an outer stack is painted after the inner stack whole, so an inner stack's shape lifted + * without asking it would be drawn over the sibling the page draws over the shape. A drawing + * the page paints before the node is not asked about — the file keeps it below, as + * the page does.
+ * + *It asks whether anything else is drawn, not whether that other drawing would stay + * behind, and the reason is a measurement: asking the second question was wrong three times + * over, at a picture drawn where the page puts it, at a badge handed over already in front, + * and at a shape whose node stands at more than one place. Each was a kind of drawing that + * stays behind for a reason of its own, and each had to be remembered here. There is nothing + * to remember about being alone above. The price is that a stack drawing anything over the + * shape keeps the shape behind, where lifting it would sometimes have been safe — over a + * badge handed to the file in front, for one.
+ * + *A node standing inside a painted surface is another case, decided by the surface it is + * in ({@code surfaceBehind}) rather than by its neighbours. Only the shapes a node paints + * itself are asked this ({@code drawAndNameOwnFragments}): a picture drawn where the page puts + * it ({@code drawWhereThePagePutsIt}) and a pass of the layout's own, a timeline's rail, are + * not, and over a painted neighbour they stay behind the text and are named there + * ({@code nameTheDrawingsAPaintedPanelCovers}). The corpus holds no instance of either.
+ * + *So does a picture over that painted layer: a picture is drawn where the page puts it and + * is never lifted, so a shape lifted over one would cover it where the page draws it over the + * shape. Measured before it was counted: a badge's outline came back in front of the photo it + * frames, its own fill over the picture.
+ * + *Where the tree does not say, it does not guess. A layer it cannot find among its + * parent's ends the climb with a false, whatever an inner stack had granted, and a node one + * instance of which stands at more than one place is refused outright, its box and its path + * being one among those places. The climb itself ends at a node the layout gives no parent — + * the top of the tree, and equally a node composed in an authored table cell — with whatever + * the stacks below it answered; that is a defence against guessing at the places it did read, + * not a claim about the ones it did not. The unfound-layer case is defence in depth: no shape + * of this repository's own templates reaches it, and no fixture drives it.
+ * + *Every overlay is read, however it says what it lays over what: a stack's and a + * container's layers by z-index, and a canvas's children in the order it was given them. A + * canvas was climbed past once, on the grounds that it holds no layers, which read as a + * harmless gap and was not. Climbing past is safe for finding a painted layer below, where it + * only costs a lift, and unsafe for finding what is drawn after the shape, where it grants + * one: measured, a canvas holding a shape and a picture over a painted band had the shape + * lifted over the picture the page draws over it.
+ */ + private boolean laidOverAPaintedNeighbour(DocumentNode node) { + if (layout.placedMoreThanOnce(node)) { + // One instance standing at more than one place has one path and one box among them, + // so what lies under it at one place is not what lies under it at another, and the + // answer would be given for all of them from whichever the index kept. + // + // No fixture drives this: which of the places the index keeps is not something a test + // can choose, so a stack built to need the refusal is as likely to be answered from + // the place that refuses anyway. It is kept because it can only refuse a lift, and + // because a shared instance did produce an inversion once, before the rule below took + // its own shape. + return false; + } + boolean over = false; + DocumentNode child = node; + for (DocumentNode parent = layout.parentOf(child); parent != null; + child = parent, parent = layout.parentOf(child)) { + if (!isOverlay(parent)) { + continue; + } + // A stack's and a container's layers by z-index, a canvas's children in the order it + // was given them: what the parent lays over what, however it says so. + ListAsked of the node being lifted and of nothing else. Only the fragments a shape is drawn + * from are read: a paragraph's own fragment, and the decoration fragment the layout gives a + * painted or bordered wrapper, are in the list the test reads from, so asking the test of + * those would find their own centre in their own box.
+ */ + private boolean framesTextWithAShape(DocumentNode node) { + if (Double.isNaN(canvasHeight)) { + return false; + } + for (com.demcha.compose.document.layout.PlacedFragment fragment : layout.ownFragments(node)) { + if (!DocxDrawings.of(fragment, canvasHeight).isEmpty() + && framesText(fragment, layout.textOnPage(fragment.pageIndex()))) { + return true; + } + } + return false; + } + + /** + * Whether a layer, or anything it holds, draws anything. + * + *Asked only of layers the page paints after the one being lifted, so the shape being + * lifted is never among them and needs no excluding.
+ * + *A fragment a shape is drawn from counts, whosever it is: that is what the export draws + * node shapes from, so it covers a node kind the export does not know as well as a shape of + * its own, and it counts a painted wrapper's decoration too, which only refuses a lift. And a + * picture counts, drawn where the page puts it and never lifted — measured: a shape lifted + * over one came back painted over the picture the page draws over it.
+ * + *Two things it cannot see, both of which would leave a drawing behind a lifted shape. A + * pass of the layout's own — a timeline's rail — is drawn from a fragment no node owns, so it + * is in neither walk; no case where that bites could be built, every rail tried bringing a + * marker or a line of text that refused the lift anyway. And the walk is over + * {@code children()}, which a table, a chart, a list and a paragraph do not implement, so what + * they compose is not reached — there the node's own fragments carry the drawing instead and + * are seen, which is why a composed cell's drawing and a chart both refuse a lift when + * measured.
+ */ + private boolean drawnOverThatLayer(DocumentNode node) { + if (node instanceof ImageNode || drawsAShape(node)) { + return true; + } + for (DocumentNode child : node.children()) { + if (drawnOverThatLayer(child)) { + return true; + } + } + return false; + } + + /** Whether the layout gives a node a fragment a shape is drawn from. */ + private boolean drawsAShape(DocumentNode node) { + if (Double.isNaN(canvasHeight)) { + return false; + } + for (com.demcha.compose.document.layout.PlacedFragment fragment : layout.ownFragments(node)) { + if (!DocxDrawings.of(fragment, canvasHeight).isEmpty()) { + return true; + } + } + return false; + } + + /** + * Whether a node, or anything it holds, carries a fill — the paint a cell written for it puts + * in the text layer, over what is drawn behind it. + * + *Read off the tree, as the neighbour's place in the stack is, and so wider than what the + * export actually shades: whether a section, a container or a row that paints becomes a cell + * with shading is decided as it is written — a row's paint goes unwritten where its panel + * cannot hold it, a container's where it is a band's layer or a stack's column — and the tree + * cannot be asked that ({@code rememberShadedPanel}, which the naming pass uses, is the side + * that knows). Wider is the safe way round here: a neighbour counted that writes no shading + * only lifts a drawing that nothing would have covered.
+ * + *It is narrower in one place, and that one is a known loss rather than a safe side: a + * shape container's own fill is not counted, being usually drawn rather than written as a + * cell, so where one is written as a cell — holding text — a drawing above it is + * still covered, and the naming pass names it. A node bearing borders alone writes no shading + * and is not counted at all; a table cell's own shading belongs to a cell and not to a node. + * A fill inside any of those is counted as far as the walk reaches, which is + * {@code children()}: a table, a chart, a list and a paragraph do not implement it, so a fill + * composed inside one of them is not seen. That errs toward fewer lifts.
+ * + *Not to be confused with {@code paintsAPanel}, which asks whether a node paints anything + * at all, borders included, or {@code paintsAPanelOfItsOwn}, which asks whether a row's paint + * can be written as a panel here.
+ */ + private static boolean paintsAFill(DocumentNode node) { + if ((node instanceof SectionNode || node instanceof ContainerNode || node instanceof RowNode) + && paintOf(node).fill() != null) { + return true; + } + for (DocumentNode child : node.children()) { + if (paintsAFill(child)) { + return true; + } + } + return false; + } + /** How far a line set in a text box over the flow may run past its box before Word breaks it. */ private static final double TEXT_BOX_SLACK_RATIO = 0.25; @@ -5086,6 +5335,10 @@ private boolean drawOwnFragments(DocumentNode node) { private boolean drawAndNameOwnFragments(DocumentNode node) { boolean overlayFront = drawsInFront(); + // Beside a layer the page paints under it, not inside one: a cell written for that layer + // puts its fill in the text layer, over what is drawn behind it, just the same + // (laidOverAPaintedNeighbour). Asked once, and only of a node that draws something. + Boolean overAPaintedNeighbour = surfaceBehind == null ? null : Boolean.FALSE; boolean front = false; boolean drew = false; // Whether a box it drew rounds its corners by radii that differ. @@ -5102,16 +5355,21 @@ private boolean drawAndNameOwnFragments(DocumentNode node) { unequalCorners |= !shapes.isEmpty() && roundsCornersUnequally(fragment); continue; } - // On a painted surface — a panel, or a filled cell — whose shading both editors paint - // over what lies behind the text, a shape stands in front unless it frames a line of - // text or a picture on its page: a template sets an icon beside its heading through a - // stack of one layer, which kept every payment panel's heading icon behind its - // shading. Elsewhere the overlays it sits in decide (drawsInFront). A badge whose - // glyph is drawn over it in front (drawnOverItsBadge) stands in front too: the - // picture it frames is its own, not the flow's. + // On a painted surface, whose shading both editors paint over what lies behind the + // text, a shape stands in front unless it frames a line of text or a picture on its + // page: a template sets an icon beside its heading through a stack of one layer, which + // kept every payment panel's heading icon behind its shading. A badge whose glyph is + // drawn over it in front (drawnOverItsBadge) stands in front too: the picture it frames + // is its own, not the flow's. Over a painted neighbour that test is already made, of + // every shape of the stack at once, by laidOverAPaintedNeighbour — so a shape it + // answers for frames nothing, and goes in front. Elsewhere the overlays it sits in + // decide (drawsInFront). + if (overAPaintedNeighbour == null) { + overAPaintedNeighbour = laidOverAPaintedNeighbour(node); + } boolean inFront = surfaceBehind != null && !Double.isNaN(canvasHeight) ? holdsItsDrawnGlyph(node) || !framesText(fragment, layout.textOnPage(fragment.pageIndex())) - : overlayFront; + : overAPaintedNeighbour || overlayFront; if (queueDrawing(fragment, inFront)) { drew = true; front |= inFront; @@ -5126,8 +5384,12 @@ private boolean drawAndNameOwnFragments(DocumentNode node) { if (badgeText != null) { message.append("; its text is held in the shape, which stands in front of the text"); } else if (front) { - message.append("; in front of the text, since the panel's shading is painted over " - + "shapes behind it"); + message.append(surfaceBehind != null + ? "; in front of the text, since the shading of the panel it stands in is " + + "painted over shapes behind it" + : "; in front of the text, since a layer the page paints under it carries a " + + "fill, whose shading a cell written for it would paint over shapes " + + "behind the text"); } else if (surfaceBehind != null) { message.append("; behind the text it frames, where the panel's shading hides it"); } diff --git a/render-docx/src/test/java/com/demcha/compose/document/backend/semantic/docx/DocxDrawingUnderANeighboursFillTest.java b/render-docx/src/test/java/com/demcha/compose/document/backend/semantic/docx/DocxDrawingUnderANeighboursFillTest.java index aedc7a763..48e22afb0 100644 --- a/render-docx/src/test/java/com/demcha/compose/document/backend/semantic/docx/DocxDrawingUnderANeighboursFillTest.java +++ b/render-docx/src/test/java/com/demcha/compose/document/backend/semantic/docx/DocxDrawingUnderANeighboursFillTest.java @@ -11,29 +11,40 @@ import com.demcha.compose.document.style.DocumentColor; import com.demcha.compose.document.style.DocumentInsets; import com.demcha.compose.document.style.DocumentStroke; +import org.apache.poi.xwpf.usermodel.XWPFDocument; import org.junit.jupiter.api.Test; +import java.io.ByteArrayInputStream; +import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Consumer; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import static org.assertj.core.api.Assertions.assertThat; /** - * A shaded cell's fill is part of the text layer in both Word and LibreOffice, and both paint it - * over whatever is drawn behind that layer. So a drawing that stands beside a painted panel — - * not inside it — and whose box reaches into that panel is covered by the panel's shading, and - * the reader never sees that much of it. + * A panel is written as a shaded cell, and a cell's fill belongs to the text layer, which Word and + * LibreOffice both paint over everything drawn behind that layer. So a drawing that stands beside + * a painted panel — on a layer above it, not inside it — and is drawn behind the text is covered + * by that panel's shading, and the reader never sees it. * *Measured on the fidelity corpus in Word 16.0.20527 and LibreOffice 24.2, at 300 dpi: the one - * document of the seventy-one that holds the case lays an 18pt icon over a card's top right - * corner through a layer stack. The engine's PDF draws 4308 pixels of the icon's own ink; Word's - * draws none, and LibreOffice's draws none — not one pixel anywhere on the page, the icon's whole - * box coming back the card's colour. Until the stack's order is carried into the document, the - * export says so rather than losing it in silence.
+ * document of the seventy-one that holds the case lays an 18pt icon over a card's top right corner + * through a layer stack. Drawn behind the text, the engine's PDF draws 4308 pixels of the icon's + * own ink, Word's draws none, and LibreOffice's draws none — not one pixel anywhere on the page, + * the icon's whole box coming back the card's colour. With the card unpainted, the one difference, + * Word draws every pixel the engine does. * - *A drawing standing inside a painted panel is a different case with its own note: - * there the export already puts it in front wherever it frames no text of the flow. Measured the + *
So the stack's order is carried into the document: a layer the page paints after a painted one + * is drawn in front of the text ({@code laidOverAPaintedNeighbour}). What stays behind the text is + * what the order or the flow keeps there — a drawing a painted layer is laid over in turn, and one + * whose box holds a line of the flow, which in front it would cover — and that the export names, + * rather than losing it in silence.
+ * + *A drawing standing inside a painted panel is a different case with its own note and + * its own tests ({@code DocxDrawingsTest}): there the surface it stands on decides. Measured the * same way, that case has no instance at all in the corpus — its branch is taken 55 times over 14 * documents and goes in front every one of them.
* @@ -43,53 +54,560 @@ class DocxDrawingUnderANeighboursFillTest { private static final DocumentColor BAND = DocumentColor.rgb(90, 120, 200); private static final DocumentColor ACCENT = DocumentColor.rgb(26, 86, 148); + private static final DocumentColor OVER = DocumentColor.rgb(10, 170, 90); + + /** The ink of the pin, as a shape's fill is written: what to pick its anchor out by. */ + private static final String PIN_INK = "1A5694"; private static final String COVERED = "a panel painted beside it"; @Test - void aShapeOverAPaintedNeighbourIsNamedAsCoveredByIt() throws Exception { - DocxExportReport report = export(session -> session.pageFlow(page -> page + void aShapeOverAPaintedNeighbourStandsInFrontOfIt() throws Exception { + Export export = export(session -> session.pageFlow(page -> page.add(pinOverABand(BAND, 150, 2)))); + + assertThat(pinAnchor(export)) + .as("the stack paints the pin over the band, so the document draws it in front") + .contains("behindDoc=\"0\""); + assertThat(covered(export.report())) + .as("nothing to name: the pin is not behind the text at all") + .isEmpty(); + assertThat(detailsOf(export.report(), "/Pin")) + .anySatisfy(detail -> assertThat(detail).contains( + "in front of the text, since a layer the page paints under it carries a fill")); + } + + @Test + void aShapeOverAnUnpaintedNeighbourStaysBehindTheText() throws Exception { + // The one difference from the fixture above. With no fill beside it nothing is painted over + // the pin, and Word draws all 3237 pixels of it against the engine's 3237 with the anchor + // behind the text — which is why behindDoc alone says nothing about whether it is seen. + Export export = export(session -> session.pageFlow(page -> page .add(new LayerStackBuilder().name("Stack") - .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) - .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + .layer(new SectionBuilder().name("Band").fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"1\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void aShapeOverANeighbourHoldingAPaintedPanelStandsInFrontOfIt() throws Exception { + // The fill is a card inside the neighbour rather than the layer itself: the cell written + // for that card paints over the pin just the same, so the neighbour counts as painted by + // what it holds and not only by what it is. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fixedWidth(200) + .addSection("Card", card -> card.fillColor(BAND) + .addParagraph(p -> p.name("Stage").text("Stage two"))) + .build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"0\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void aShapeOverANeighbourBearingBordersAloneStaysBehindTheText() throws Exception { + // A neighbour covers only where a fill is written for it. One bearing borders alone writes + // no shading, so there is nothing to paint over the pin: it keeps the place the overlays + // round it give it, and nothing is named. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band") + .stroke(DocumentStroke.of(ACCENT, 1)).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), LayerAlign.TOP_LEFT, 0) - .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), 150, 2, LayerAlign.TOP_LEFT, 1) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"1\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void aShapeAPaintedNeighbourIsLaidOverInTurnStaysBehindAndIsNamed() throws Exception { + // The page paints a third layer, painted, over the pin. There the pin belongs behind that + // layer's shading, and in front it would cover the shading instead — the same loss the + // other way round. So it stays behind the text, where the layer under it covers it, and + // the export says so. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Lower").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .layer(new SectionBuilder().name("Upper").fillColor(OVER).fixedWidth(200) + .addParagraph(p -> p.name("Over").text("Over it")).build(), + LayerAlign.TOP_LEFT, 2) .build()))); - assertThat(covered(report)).singleElement().asString() + assertThat(pinAnchor(export)).contains("behindDoc=\"1\""); + assertThat(covered(export.report())).singleElement().asString() .as("the pin, and the panel that covers it, both named") + .contains("Pin").contains("Lower[0]").contains(COVERED); + } + + @Test + void aShapeOverAPaintedNeighbourFramingALineOfTheFlowStaysBehindAndIsNamed() throws Exception { + // In front it would be painted over the band's own line of text. A drawing that frames a + // line of the flow stays behind it, as it does inside a painted panel, and what the + // neighbour's shading then takes of it is named. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(190, 30).fillColor(ACCENT).build(), + 2, 0, LayerAlign.TOP_LEFT, 1) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"1\""); + assertThat(covered(export.report())).singleElement().asString() .contains("Pin").contains("Band[0]").contains(COVERED); } @Test - void aShapeOverAnUnpaintedNeighbourIsNotNamed() throws Exception { - // The one difference from the fixture above. Without the fill there is nothing to paint - // over the pin, and Word draws all 3237 pixels of it against the engine's 3237. - DocxExportReport report = export(session -> session.pageFlow(page -> page + void aStackWhoseUpperShapeMustStayBehindKeepsEveryShapeOfItThere() throws Exception { + // Two shapes over one painted band: the lower clear of the band's line of text, the upper + // holding it. Word draws every shape in front over every shape behind, so lifting the + // lower one alone would draw it over the upper one, which the page draws over it — the + // loss this rule fixes, made worse. The stack's order is kept whole: neither is lifted, + // and the panel beside them is named for both. + Export export = export(session -> session.pageFlow(page -> page .add(new LayerStackBuilder().name("Stack") - .layer(new SectionBuilder().name("Band").fixedWidth(200) - .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .position(new ShapeBuilder().name("Over").size(190, 30).fillColor(OVER).build(), + 2, 0, LayerAlign.TOP_LEFT, 2) + .build()))); + + assertThat(pinAnchor(export)) + .as("the lower shape stays behind with the upper one, not over it") + .contains("behindDoc=\"1\""); + assertThat(covered(export.report())) + .as("both named as covered by the band, since both are behind the text") + .hasSize(2); + } + + @Test + void aLayerBearingTextOverThePaintedOneDoesNotKeepTheShapeBehind() throws Exception { + // What keeps a shape behind is another DRAWING painted over it, not any layer that + // happens to carry text. The words are a layer above the pin, so they are asked — and + // they draw nothing, so they cover nothing. Counting their own fragment as one a shape is + // drawn from refused the lift for stacks of the shape `[painted background, text, icons]`, + // which is the ordinary layer stack, so the rule fired almost nowhere. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .position(new SectionBuilder().name("Words").fixedWidth(90) + .addParagraph(p -> p.name("Note").text("A line of words")).build(), + 2, 40, LayerAlign.TOP_LEFT, 2) + .build()))); + + assertThat(pinAnchor(export)) + .as("the words are painted over the pin but draw nothing, so they cover nothing " + + "and keep it behind nothing") + .contains("behindDoc=\"0\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void anUnpaintedShapeContainerOverThePaintedLayerKeepsNothingBehindIt() throws Exception { + // A shape container that paints nothing draws no shape, so it covers nothing and must not + // refuse the lift. Its box is asked of nothing: only the fragments a shape is actually + // drawn from are, which is what tells this container from the badge of the test above. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeContainerBuilder().name("Clear").rectangle(90, 20) + .center(new ParagraphBuilder().name("Inside").text("Clear").build()) + .build(), + 2, 40, LayerAlign.TOP_LEFT, 1) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 2) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"0\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void aShapeOverABadgeAndAPaintedLayerIsStillLifted() throws Exception { + // What the rule asks is whether anything is drawn OVER the shape, not whether anything is + // drawn at all. The badge is painted before the pin, so the file keeps the pin above it + // just as the page does, and the lift is safe whatever the badge's own place turns out to + // be. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeContainerBuilder().name("Badge").circle(28).fillColor(OVER) + .center(new ParagraphBuilder().text("JR").build()).build(), + 40, 2, LayerAlign.TOP_LEFT, 1) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 2) + .build()))); + + assertThat(pinAnchor(export)) + .as("the pin is lifted, the badge standing under it on the page and in the file") + .contains("behindDoc=\"0\""); + assertThat(covered(export.report())) + .as("nothing covers the pin, so nothing is named for it") + .noneMatch(named -> named.contains("/Pin")); + } + + @Test + void aShapeOverABorderedNeighbourAndAPaintedLayerIsStillLifted() throws Exception { + // The bordered wrapper draws — the layout gives it a fragment a shape is drawn from — but + // it is painted before the pin, so it is not something drawn over the pin and the lift + // stands. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new SectionBuilder().name("Outlined").fixedWidth(90) + .stroke(DocumentStroke.of(ACCENT, 1)) + .addParagraph(p -> p.name("Note").text("In a box")).build(), + 2, 40, LayerAlign.TOP_LEFT, 1) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 2) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"0\""); + assertThat(covered(export.report())).noneMatch(named -> named.contains("/Pin")); + } + + @Test + void aShapeOnACanvasUnderThatCanvasPictureIsNotLifted() throws Exception { + // A canvas lays its children over one another as a stack does, but says so with their + // order rather than with z-indices. Climbed past for want of layers, it granted this + // lift: measured, the pin came back behindDoc="0" and the picture the canvas places after + // it behindDoc="1", their boxes overlapping by 4pt, so Word drew the pin over a picture + // the page draws over it. The band is narrower than the pin reaches, so nothing names it + // either. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(160) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .layer(new com.demcha.compose.document.dsl.CanvasLayerBuilder(200, 40) + .name("Plate") + .position(new ShapeBuilder().name("Pin").size(30, 14) + .fillColor(ACCENT).build(), 150, 2) + .position(new LayerStackBuilder().name("Fact") + .layer(new com.demcha.compose.document.dsl.ImageBuilder() + .name("Icon").source(pngBytes()) + .size(10, 10).build(), + LayerAlign.CENTER_LEFT) + .position(new ParagraphBuilder().name("Label") + .text("Label").build(), + 14, 0, LayerAlign.CENTER_LEFT, 1) + .build(), + 176, 0) + .build(), + LayerAlign.TOP_LEFT, 1) + .build()))); + + assertThat(pinAnchor(export)) + .as("the pin stays behind the picture the canvas places after it") + .contains("behindDoc=\"1\""); + } + + @Test + void aShapeStandingInTwoStacksAtOnceIsNotLifted() throws Exception { + // One instance used in two stacks: the layout keeps one path and one box for it, so an + // answer taken at one of its places is given at both. Here the first place is alone over + // a painted band, where a lift would be right, and the second is under a hood that the + // page paints over it, where the same lift draws the shape over the hood. + com.demcha.compose.document.node.DocumentNode shared = + new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(); + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Painted") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(shared, 150, 2, LayerAlign.TOP_LEFT, 1) + .build()) + .add(new LayerStackBuilder().name("Hooded") + .layer(new SectionBuilder().name("Band two").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Other").text("Stage three")).build(), LayerAlign.TOP_LEFT, 0) - .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), 150, 2, LayerAlign.TOP_LEFT, 1) + .position(shared, 150, 2, LayerAlign.TOP_LEFT, 1) + .position(new ShapeBuilder().name("Hood").size(40, 20).fillColor(OVER).build(), + 145, 0, LayerAlign.TOP_LEFT, 2) .build()))); - assertThat(covered(report)).isEmpty(); + assertThat(anchorsHolding(export, PIN_INK)) + .as("both places behind the text, neither answered from the other's") + .hasSizeGreaterThan(1) + .allSatisfy(anchor -> assertThat(anchor).contains("behindDoc=\"1\"")); } @Test - void aShapeBesideAPaintedNeighbourItDoesNotReachIsNotNamed() throws Exception { - // Set past the band's right edge: the two share a line and no area, and nothing of the - // pin is under the band's shading. This is the geometry doing the deciding — the pin is - // drawn behind the text here exactly as it is in the fixture that is named. - DocxExportReport report = export(session -> session.pageFlow(page -> page + void aShapeOfANestedStackUnderAnOuterStacksDrawingIsNotLifted() throws Exception { + // The painted layer is in the inner stack, and the drawing that would be inverted is a + // layer of the OUTER one — painted after the inner stack whole. Asking only the overlay + // that holds the painted layer left this lifted: measured, the pin came back + // behindDoc="0" with relativeHeight below the hood's, so Word drew the pin over a hood + // the page draws over it. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Outer") + .layer(new LayerStackBuilder().name("Inner") + .layer(new SectionBuilder().name("Band").fillColor(BAND) + .fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")) + .build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(120, 30) + .fillColor(ACCENT).build(), 60, 2, LayerAlign.TOP_LEFT, 1) + .build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Hood").size(70, 30).fillColor(OVER).build(), + 0, 0, LayerAlign.TOP_LEFT, 1) + .build()))); + + assertThat(pinAnchor(export)) + .as("the pin stays behind the hood the outer stack paints over it") + .contains("behindDoc=\"1\""); + assertThat(covered(export.report())) + .as("and the band is named as covering it, so the pin was judged at all") + .anySatisfy(named -> assertThat(named).contains("Pin").contains("Band[0]")); + } + + @Test + void aStackDrawingAPictureBesideItsLabelLiftsNothing() throws Exception { + // A picture drawn beside the text it labels, in a nested layer of the stack, nowhere near + // the pin. The picture is never lifted — the surface it stands on decides, not its + // neighbours — so lifting the pin would paint the pin over a picture the page draws over + // it. Measured on exactly this shape: the pin came back behindDoc="0" and the picture + // behindDoc="1", and they overlap. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 140, 2, LayerAlign.TOP_LEFT, 1) + .position(new LayerStackBuilder().name("Fact") + .layer(new com.demcha.compose.document.dsl.ImageBuilder() + .name("Icon").source(pngBytes()).size(10, 10).build(), + LayerAlign.CENTER_LEFT) + .position(new ParagraphBuilder().name("Label").text("Label").build(), + 14, 0, LayerAlign.CENTER_LEFT, 1) + .build(), + 168, 0, LayerAlign.TOP_LEFT, 2) + .build()))); + + // The icon's centre stands past the pin's right edge, so the pin does not frame it and + // it is not that test keeping the pin behind — the boxes still overlap by two points, + // which is where the file would have drawn the pin over the picture. + assertThat(detailsOf(export.report(), "/Icon")) + .as("the picture is drawn where the page puts it, which is why it cannot be lifted") + .anySatisfy(detail -> assertThat(detail).contains("drawn beside the text it labels")); + assertThat(pinAnchor(export)) + .as("the pin stays behind, the picture above it never being lifted") + .contains("behindDoc=\"1\""); + assertThat(covered(export.report())) + .as("and the band is named as covering the pin, so the pin was judged at all") + .anySatisfy(named -> assertThat(named).contains("Pin").contains("Band[0]")); + } + + @Test + void aShapeTheSameInstanceOfWhichStandsTwiceIsNotLifted() throws Exception { + // One node used as two layers stands at two places, and the layout keeps one path and one + // box for the instance. What lies under it at one place is not what lies under it at the + // other, so an answer taken from whichever place the index kept would be given for both: + // it is refused instead. + com.demcha.compose.document.node.DocumentNode pin = + new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(); + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(pin, 150, 2, LayerAlign.TOP_LEFT, 1) + .position(pin, 150, 30, LayerAlign.TOP_LEFT, 2) + .build()))); + + assertThat(anchorsHolding(export, PIN_INK)) + .as("both places behind the text, neither answered from the other's") + .isNotEmpty() + .allSatisfy(anchor -> assertThat(anchor).contains("behindDoc=\"1\"")); + } + + @Test + void aShapeBesideOneStandingTwiceIsNotLiftedOverIt() throws Exception { + // The refusal above is asked of the node being lifted, so on its own it would let a + // neighbour be lifted over the places it refuses — measured: the lone shape came back + // behindDoc="0" and both of the repeated instance's places behindDoc="1", the lower of + // them drawn over the higher. Being alone is what answers here: the repeated instance is + // a second drawing of the stack. + com.demcha.compose.document.node.DocumentNode shared = + new ShapeBuilder().name("Shared").size(40, 10).fillColor(OVER).build(); + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .position(shared, 140, 8, LayerAlign.TOP_LEFT, 2) + .position(shared, 140, 24, LayerAlign.TOP_LEFT, 3) + .build()))); + + assertThat(pinAnchor(export)) + .as("the lone shape stays behind with the places it would have been drawn over") + .contains("behindDoc=\"1\""); + } + + @Test + void twoPaintedLayersUnderAShapeStillLiftIt() throws Exception { + // The topmost painted layer is the one the shapes above it are judged from; a second + // painted layer below it changes nothing, the page covering it with the first. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Under").fillColor(OVER).fixedWidth(200) + .addParagraph(p -> p.name("Deep").text("Under it all")).build(), + LayerAlign.TOP_LEFT, 0) + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 1) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 2) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"0\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void aShapeInAStackNestedOverAPaintedLayerStandsInFrontOfIt() throws Exception { + // The climb reads every stack the shape stands in, not only the nearest: the pin is a + // layer of an inner stack which is itself a layer over the painted band. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new LayerStackBuilder().name("Inner") + .position(new ShapeBuilder().name("Pin").size(30, 14) + .fillColor(ACCENT).build(), 0, 0, LayerAlign.TOP_LEFT, 0) + .build(), + 150, 2, LayerAlign.TOP_LEFT, 1) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"0\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void aShapeDeclaredBeforeAPaintedLayerOfTheSameZIndexStaysBehindIt() throws Exception { + // Layers sharing a z-index are painted in the order they were given, so the band declared + // after the pin is painted over it: the page covers the pin, and in front the pin would + // cover the band's shading instead. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 0) + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"1\""); + assertThat(covered(export.report())).singleElement().asString() + .contains("Pin").contains("Band").contains(COVERED); + } + + @Test + void aShapeDeclaredAfterAPaintedLayerOfTheSameZIndexStandsInFrontOfIt() throws Exception { + // The same two layers the other way round, both still at z-index 0: the band is painted + // first, so the pin stands over it and goes in front. This and the test above are the pair + // that pins the tie — the sort is stable, and which way it falls is the order given. + Export export = export(session -> session.pageFlow(page -> page + .add(new LayerStackBuilder().name("Stack") + .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + LayerAlign.TOP_LEFT, 0) + .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), + 150, 2, LayerAlign.TOP_LEFT, 0) + .build()))); + + assertThat(pinAnchor(export)).contains("behindDoc=\"0\""); + assertThat(covered(export.report())).isEmpty(); + } + + @Test + void aPictureOverAPaintedNeighbourStaysBehindItAndIsNamed() throws Exception { + // A picture drawn where the page puts it is never lifted — the surface it stands on + // decides, not its neighbours — so over a painted neighbour it is still covered. Not + // silently: the naming pass names it where it stands. + // + // And the badge round it stays behind WITH it. Lifting the badge alone would paint its + // own fill over the photo it frames, which the page draws over the badge: measured, that + // is what happened before the picture was counted among the things that keep a stack + // behind — the badge came back behindDoc="0" and the photo behindDoc="1". Both anchors + // are read here for that reason, not the note alone. + Export export = export(session -> session.pageFlow(page -> page .add(new LayerStackBuilder().name("Stack") .layer(new SectionBuilder().name("Band").fillColor(BAND).fixedWidth(200) - .addParagraph(p -> p.name("Stage").text("Stage two")).build(), + .addParagraph(p -> p.name("Stage").text("Stage two")).build(), LayerAlign.TOP_LEFT, 0) - .position(new ShapeBuilder().name("Pin").size(30, 14).fillColor(ACCENT).build(), 210, 2, LayerAlign.TOP_LEFT, 1) + .position(new ShapeContainerBuilder().name("Frame").circle(40) + .fillColor(ACCENT) + .center(new com.demcha.compose.document.dsl.ImageBuilder() + .name("Photo").source(pngBytes()).size(36, 36).build()) + .build(), + 150, 2, LayerAlign.TOP_LEFT, 1) .build()))); - assertThat(covered(report)).isEmpty(); + assertThat(detailsOf(export.report(), "/Photo")) + .as("the picture is drawn where the page puts it, which is the path in question") + .isNotEmpty(); + assertThat(anchorsHolding(export, PIN_INK)) + .as("the badge's own outline, behind the text with the photo it frames") + .singleElement().asString().contains("behindDoc=\"1\""); + assertThat(anchorsHolding(export, "