From c8006182992e9b0653fa594302758cdd1658d7c6 Mon Sep 17 00:00:00 2001 From: Steffen Becker Date: Sat, 15 Aug 2026 11:13:46 +0200 Subject: [PATCH] feat: a text box can run its text top-to-bottom MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Word's Text Direction and LibreOffice's, on the frame's own toolbar: the browser lays the vertical flow out, so the box needs nothing but the mode. ODF keeps it in the frame style's *paragraph* properties — probed: in the graphic properties LibreOffice drops it, there it keeps it and lays the box out — and Word in the shape body's `vert`, the VML fallback's `layout-flow:vertical` read too. Both survive a LibreOffice re-save. --- CHANGELOG.md | 5 ++- docs/architecture/frames.md | 2 +- src/lib/components/Editor.svelte | 6 ++- src/lib/components/TextBoxToolbar.svelte | 15 ++++++++ src/lib/editor/extensions/textBox.ts | 11 ++++++ src/lib/export/CLAUDE.md | 2 +- src/lib/export/docx.ts | 5 ++- src/lib/export/odt.ts | 9 ++++- src/lib/i18n/locales/de.ts | 1 + src/lib/i18n/locales/en.ts | 1 + src/lib/import/CLAUDE.md | 1 + src/lib/import/docx.ts | 10 ++++- src/lib/import/odt.ts | 4 ++ src/lib/import/styleResolver.ts | 6 +++ tests/unit/vertical-text-box.test.ts | 49 ++++++++++++++++++++++++ 15 files changed, 118 insertions(+), 9 deletions(-) create mode 100644 tests/unit/vertical-text-box.test.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index f076a2e..b28497b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -59,6 +59,7 @@ - Word completion (the same dialog's own section, as LibreOffice keeps it): every word of at least eight letters is remembered as it is typed, and typing its first three letters offers the rest in grey after the caret — Enter takes the offer, Esc drops it. It is offered while typing only, so an Enter meant to split a paragraph never completes a word instead, and the offer stays outside the document until it is accepted. Minimum length, an appended space and clearing the collected words are all settable - AutoText (LibreOffice's Tools ▸ AutoText, Word's Insert ▸ Quick Parts): keep a selected block of text under a name and a shortcut, then insert it from the library or by typing the shortcut and pressing F3 — LibreOffice's own key. An entry keeps its formatting, and the library belongs to the app rather than to a document, as it does in both products - Ruby annotations (Insert ▸ Phonetic guide — LibreOffice's Format ▸ Asian Phonetic Guide, Word's Phonetic Guide): the reading printed over its base text, the selected text proposed as the base. Round-trips as ODF `text:ruby` with its ruby-family style and as Word's `w:ruby` run — verified through LibreOffice both ways, including our `.docx` converted to `.odt` by it +- A text box can run its text top-to-bottom (its toolbar's ⇊ button — LibreOffice's Format ▸ Text Attributes ▸ Text direction, Word's Text Direction): the browser lays the vertical flow out itself. Round-trips as the frame style's own writing mode in ODF — its *paragraph* properties, probed: in the graphic properties LibreOffice drops it — and as Word's `w:bodyPr vert`, with the VML fallback's `layout-flow:vertical` read too. Both verified through a LibreOffice re-save; converting our `.docx` to `.odt` LibreOffice itself loses the direction - Automatic hyphenation for the whole document (Layout ▸ Hyphenation): the browser hyphenates in the document's own language, which shortens a justified paragraph the way LibreOffice does. Round-trips as ODF `fo:hyphenate` on the base style — where LibreOffice keeps it, in its *text* properties — and Word's `w:autoHyphenation` - Manual line breaks (Shift+Enter) @@ -155,7 +156,7 @@ The gap against Word/LibreOffice, most valuable first. Reviewed 2026-08-14. **Content an imported document loses** - Charts are **drawn** from the file (`import/chart.ts`: DrawingML `chartN.xml` and ODF `chart:chart`), but as a picture, not a chart object — a re-export carries the drawing and the numbers behind it are no longer editable. The same holds for an **EMF** metafile (`import/emf.ts`): it is drawn, but as the SVG picture it was rebuilt into, and only from the record set a plot consists of — a hatched brush, a clipping region or a rotated bitmap is skipped. **WMF/SVM** metafiles and OLE objects still keep their box and a placeholder label, and export writes that back out: WMF is a different (16-bit) record format, SVM is StarOffice-proprietary, and an OLE object cannot be rendered without its application -- Connectors that attach to other shapes, and freeform curves — a connector is an anchoring model rather than a shape, and a freeform needs a drawing tool. Rotated shape text (`w:bodyPr vert`) too. All still dropped on import with a warning +- Connectors that attach to other shapes, and freeform curves — a connector is an anchoring model rather than a shape, and a freeform needs a drawing tool. Both still dropped on import with a warning **Missing while writing** - Hyphenation's zone and ladder count (`fo:hyphenation-ladder-count`, `w:hyphenationZone`) — CSS exposes neither @@ -165,7 +166,7 @@ The gap against Word/LibreOffice, most valuable first. Reviewed 2026-08-14. - Find & Replace by font, size or colour — the weight/slant/underline and paragraph-style half is implemented, but LibreOffice's Format dialog is the whole character dialog - Multi-document management: one document is open at a time, so there is no window list and no side-by-side compare - Thesaurus and grammar check -- Vertical writing modes (ODF `tb-rl`), and a ruby annotation's own alignment and position — both products' defaults are what we write +- A vertical writing mode for the **page** (ODF `tb-rl` on the page layout): a text box can run its text top-to-bottom, the body cannot — pagination fills a page downwards. A ruby annotation's own alignment and position are not offered either; both products' defaults are what we write - Password-protected ODT/DOCX; digital signatures - Split view: two views of one document, scrolled independently - A committed corpus of documents we author ourselves, so CI can test against real files diff --git a/docs/architecture/frames.md b/docs/architecture/frames.md index d38bc1d..d77a4da 100644 --- a/docs/architecture/frames.md +++ b/docs/architecture/frames.md @@ -4,7 +4,7 @@ Covers `src/lib/editor/extensions/image.ts` and `textBox.ts` — node views, res handles, wrap modes, frame offsets — and their ODF/DOCX legs. - **`image.ts`** (`Image`) — inline, as-character image atom (Word's "in line with text"). Attrs: `src` (data-URI), `alt`, `width`/`height` (**unscaled doc px @96dpi**, like `rowHeight`, and **fractional** — rounding a page-wide picture to whole px costs 0.3mm of height; `framePx` snaps back to a whole one within 0.05px, which is where our own export's 0.001cm quantization lands, so the round trip stays exact), `rotation` (CW degrees). The node view nests an `` in a rotated "rotor" inside an axis-aligned wrapper that reserves the rotated bounding box (so text reflows around it). The rotor's transform makes it a stacking context, so a selected `.image-node` is given a `z-index` above the header/footer layer to keep handles that poke into a margin grabbable. It has eight zoom-aware resize handles — corners aspect-locked, edges single-axis (width- or height-only) — plus a rotation-arrow grip, and shows a live "Width … × Height …" (cm) badge while resizing; resize deltas are un-rotated onto the image's own axes so handles track the pointer at any angle (drag math mirrors `tableRowResize.ts`; width cap = the cell or page-text-column, height cap = the page text height). `setImage` command inserts it; the toolbar button (ToolbarExpanded), drag-drop and paste (Editor.svelte) read the file via `FileReader` → data-URI and clamp the initial size to the page text box. **Text wrap:** the `wrap` attr (`'inline'|'left'|'right'|'topBottom'`) makes the image a *floating* frame — `ImageToolbar.svelte` (a per-image floating toolbar wired in `Editor.svelte` like `TableToolbar`) sets the mode; `left`/`right` float the wrapper at its anchor paragraph (text flows on the open side via CSS `float`), `topBottom` is a **full-width `float`** (text only above/below). All modes use `float` deliberately: an in-flow `display:block` on an inline-atom node view splits the paragraph's inline content into anonymous block boxes, which desyncs ProseMirror's inline view descriptor and makes it drop the following page-break spacer widget; a float is out-of-flow and avoids that. Dragging an **inline** image runs ProseMirror's native node move (the `dropCursor` plugin shows the caret). Dragging a **floating** image runs a custom drag (`ImageView.startReposition`) that **live re-anchors** the node to the text position under the cursor, so the float and text reflow in real time as you drag; it's rAF-throttled and only moves when the cursor's line changes (a float can't move within a line), and stays a single undo step (first move records history, later moves are `addToHistory:false` and get rebased on undo). A paragraph that contains an image paginates **atomically** (`pageBreaks.ts` — pushed whole to the next page, spacer placed before it) so a page break never splits the paragraph next to the image's float (where ProseMirror drops the spacer widget). **Wrap distance:** `wrapDist` is the gap the file keeps beside a float, in cm (Word's `distL`/`distR`, ODF's `fo:margin-left`/`-right` on the graphic style) — only the side the text flows on, since the other one is the frame's own offset. A frame that declares none reserves **nothing**, beside it or above/below it: probed, LibreOffice wraps flush against it, and a gap of our own put every figure in a text box 3mm too tall and broke a line a word early. `setImageWrap` gives a frame the file never floated the 0.32cm a word processor's own wrap command writes. **Vertical alignment (as-char):** `vAlign` carries ODF's `style:vertical-pos`/`-rel` pair for an inline frame — `null` (LibreOffice's `top`/`baseline` and Word's only mode) stands the frame on the text baseline, `middle`/`below` centre it on the baseline or hang it below, and `text-top`/`text-middle`/`text-bottom` measure against the character area instead (CSS `vertical-align: text-top`/`text-bottom`; nothing in CSS centres on that area, so `text-middle` uses 0.36em for half of ascent − descent, which Liberation Serif/Sans, Times and Arial share). `from-top` becomes `vAlign: 'offset'` and puts the frame's top `wrapOffsetY` cm below the baseline whatever the relation says — all probed against LibreOffice, whose formula images use `middle`/`text` and `from-top` almost exclusively. A line an as-char frame has to itself — nothing beside it but whitespace — is as tall as the frame or the block's line height, whichever is more, with **no text descent below it** (probed); `image.ts` gives such a frame an `image-line` class, since CSS cannot ask whether a line holds real text. Hard breaks are the only line boundaries the model shows, so the run between two of them is what gets tested — which covers the frame-break-caption idiom LibreOffice's own guides are full of; a frame alone on a *soft-wrapped* line is invisible from there. A frame that shares its line with text keeps the baseline and the descent. **Frame offsets:** `wrapOffset` is the frame's left edge in the text column (Word's `positionH` posOffset, ODF `svg:x`), rendered as the float's near/far margin against the live column vars — an indented anchor paragraph can't skew it — and shared with `textBox.ts` through `frameMargins`. A `topBottom` float spans the column, so its own x moves the *rotor* inside the wrapper instead. `wrapOffsetY` (`positionV`, `svg:y`) is the frame's top below the anchor paragraph's, drawn for `topBottom` only — no text sits beside such a frame, where a side float's top margin would push away lines Word keeps. Chromium places **every** line after a full-width float below it, even the ones the float's top margin leaves room for, so a frame set below the paragraph top is sunk behind that paragraph's text at import (`sinkOffsetFrames`, both importers) and `ImageView.sinkToOffset` measures what the lines above it already cover, adding only the rest. Two `topBottom` frames set against **opposite ends** of nearby paragraphs (`wrapAlign`, from Word's `positionH` align / ODF `style:horizontal-pos`) share one band and float to their own sides instead: `pairAlignedFrames` (import/odt.ts, both importers) keeps the attr only for such a pair — a lone one reserves the whole band, which is what the wrap means — and scales a pair up to 15% wider than the column down to it, since Word lets the two overlap in the middle and two floats cannot. A frame Word puts *inside* running text still lands after it: browsers can't wrap text around a freely-positioned box (CSS Exclusions are unimplemented). Inline images stay as-char. Works inside table cells. Not available while editing a header/footer (the HF schema has no image node). Images live as data-URIs in the autosaved JSON; `autosave.ts` warns once if that exceeds the localStorage quota. -- **`textBox.ts`** (`TextBox`) — block-level text box / basic shape with editable block content (`content: '(paragraph|heading|bulletList|orderedList)+'`, `isolating`). Attrs: `width`/`height` (px @96dpi; height renders as **min-height** — content grows the box), `rotation` (CW deg), `wrap` (image's `WrapMode`; `inline` renders in-flow, floats via CSS `float` like `ImageView.applyWrap`), `shapeKind` (see the shape table below), `fillColor`/`strokeColor` (`null` = transparent/no border), `strokeWidthPt`. Padding is the fixed `TEXTBOX_PADDING_CM` (0.15cm). The node has its **own group** (`group: 'textBox'`) so only the document admits it (`extensions.ts` widens Document to `'(block | textBox)+'`) — never in table cells, lists, header/footer, or other boxes; imports found there are flattened with a warning. `TextBoxView` mirrors `ImageView` (wrapper reserving the rotated bbox → rotor carrying fill/stroke/rotation → `contentDOM`); the rotor is out of flow and auto-grows, so a ResizeObserver refits the wrapper. **Click model (Word-like):** `stopEvent`/`isFrameHit` claim mouse events on a ~6px frame ring (rotation-/zoom-aware) → NodeSelection + handles (the shared `image-*` handle classes/CSS); clicks further inside pass to ProseMirror (caret). The box is browser-`draggable` only while node-selected, so PM's native block drag moves it without hijacking text selection. Commands: `insertTextBox()` (after the current top-level block, cursor inside), `setTextBoxAttrs()` (NodeSelection *or* cursor inside; helper `findTextBox`). `TextBoxToolbar.svelte` (wired in `Editor.svelte` like the image toolbar, also shown while the caret is inside a box) sets wrap/shape/fill/stroke. `trailingNode.ts` appends a paragraph after a trailing box; `pageBreaks.ts` paginates `.textbox-node` atomically. **Spacing:** a box lifted out of an anchor paragraph that held nothing else stands in for it, so it takes that paragraph's resolved `fo:margin-top`/`-bottom` as `spaceBefore`/`spaceAfter` (`ParagraphSpacing` covers `textBox` for that). Space above is padding — it adds to the block above rather than collapsing against it — which means the node is `content-box` and the rotor, centred in the padding box, gets half of it back. +- **`textBox.ts`** (`TextBox`) — block-level text box / basic shape with editable block content (`content: '(paragraph|heading|bulletList|orderedList)+'`, `isolating`). Attrs: `width`/`height` (px @96dpi; height renders as **min-height** — content grows the box), `rotation` (CW deg), `wrap` (image's `WrapMode`; `inline` renders in-flow, floats via CSS `float` like `ImageView.applyWrap`), `shapeKind` (see the shape table below), `fillColor`/`strokeColor` (`null` = transparent/no border), `strokeWidthPt`. Padding is the fixed `TEXTBOX_PADDING_CM` (0.15cm). The node has its **own group** (`group: 'textBox'`) so only the document admits it (`extensions.ts` widens Document to `'(block | textBox)+'`) — never in table cells, lists, header/footer, or other boxes; imports found there are flattened with a warning. `TextBoxView` mirrors `ImageView` (wrapper reserving the rotated bbox → rotor carrying fill/stroke/rotation → `contentDOM`); the rotor is out of flow and auto-grows, so a ResizeObserver refits the wrapper. **Click model (Word-like):** `stopEvent`/`isFrameHit` claim mouse events on a ~6px frame ring (rotation-/zoom-aware) → NodeSelection + handles (the shared `image-*` handle classes/CSS); clicks further inside pass to ProseMirror (caret). The box is browser-`draggable` only while node-selected, so PM's native block drag moves it without hijacking text selection. Commands: `insertTextBox()` (after the current top-level block, cursor inside), `setTextBoxAttrs()` (NodeSelection *or* cursor inside; helper `findTextBox`). `TextBoxToolbar.svelte` (wired in `Editor.svelte` like the image toolbar, also shown while the caret is inside a box) sets wrap/shape/fill/stroke and `textVertical` — the box's text running **top-to-bottom, right-to-left** (`writing-mode: vertical-rl` on the content area, which is all the browser needs). It round-trips as the frame style's own writing mode in ODF (in its *paragraph* properties — probed: in the graphic properties LibreOffice drops it) and Word's `w:bodyPr vert`; ODF's bottom-to-top and Word's `vert270` read as the same one direction the browser lays out. `trailingNode.ts` appends a paragraph after a trailing box; `pageBreaks.ts` paginates `.textbox-node` atomically. **Spacing:** a box lifted out of an anchor paragraph that held nothing else stands in for it, so it takes that paragraph's resolved `fo:margin-top`/`-bottom` as `spaceBefore`/`spaceAfter` (`ParagraphSpacing` covers `textBox` for that). Space above is padding — it adds to the block above rather than collapsing against it — which means the node is `content-box` and the rotor, centred in the padding box, gets half of it back. ## Clicking a float diff --git a/src/lib/components/Editor.svelte b/src/lib/components/Editor.svelte index 107652c..a10f884 100644 --- a/src/lib/components/Editor.svelte +++ b/src/lib/components/Editor.svelte @@ -611,8 +611,8 @@ import { EMPTY_PAGE_DECOR, type PageDecor } from '../storage/pageDecor'; let textBoxUi = $state<{ visible: boolean; top: number; left: number; wrap: WrapMode; shapeKind: ShapeKind; fillColor: string | null; - strokeColor: string | null; strokeWidthPt: number; - }>({ visible: false, top: 0, left: 0, wrap: 'inline', shapeKind: 'textbox', fillColor: '#FFFFFF', strokeColor: '#000000', strokeWidthPt: 1 }); + strokeColor: string | null; strokeWidthPt: number; textVertical: boolean; + }>({ visible: false, top: 0, left: 0, wrap: 'inline', shapeKind: 'textbox', fillColor: '#FFFFFF', strokeColor: '#000000', strokeWidthPt: 1, textVertical: false }); function recomputeTextBoxUi() { const ed = editor; @@ -639,6 +639,7 @@ import { EMPTY_PAGE_DECOR, type PageDecor } from '../storage/pageDecor'; fillColor: (a.fillColor as string | null) ?? null, strokeColor: (a.strokeColor as string | null) ?? null, strokeWidthPt: (a.strokeWidthPt as number) ?? 1, + textVertical: a.textVertical === true, }; } @@ -1174,6 +1175,7 @@ import { EMPTY_PAGE_DECOR, type PageDecor } from '../storage/pageDecor'; fillColor={textBoxUi.fillColor} strokeColor={textBoxUi.strokeColor} strokeWidthPt={textBoxUi.strokeWidthPt} + textVertical={textBoxUi.textVertical} /> {/if} {#if ctxMenu} diff --git a/src/lib/components/TextBoxToolbar.svelte b/src/lib/components/TextBoxToolbar.svelte index b59f134..ab11abe 100644 --- a/src/lib/components/TextBoxToolbar.svelte +++ b/src/lib/components/TextBoxToolbar.svelte @@ -15,6 +15,7 @@ fillColor, strokeColor, strokeWidthPt, + textVertical, }: { editor: Editor | null; top: number; @@ -24,6 +25,7 @@ fillColor: string | null; strokeColor: string | null; strokeWidthPt: number; + textVertical: boolean; } = $props(); let fillOpen = $state(false); @@ -100,6 +102,19 @@ + + set({ shapeKind: k })} compact /> diff --git a/src/lib/editor/extensions/textBox.ts b/src/lib/editor/extensions/textBox.ts index 94fd4f9..f29c530 100644 --- a/src/lib/editor/extensions/textBox.ts +++ b/src/lib/editor/extensions/textBox.ts @@ -47,6 +47,7 @@ export interface TextBoxAttrs { paddingCm: number; // inset ring around the text (ODF fo:padding) shapeKind: ShapeKind; flipV: boolean; // a line runs bottom-left → top-right instead + textVertical: boolean; // text runs top-to-bottom, right-to-left fillColor: string | null; strokeColor: string | null; strokeWidthPt: number; @@ -160,6 +161,13 @@ export const TextBox = Node.create({ parseHTML: el => (el as HTMLElement).getAttribute('data-flip-v') === 'true', renderHTML: () => ({}), }, + // The text runs top-to-bottom, right-to-left instead of across (Word's + // `w:bodyPr vert`, ODF's tb-rl writing mode on the frame's style). + textVertical: { + default: false, + parseHTML: el => (el as HTMLElement).getAttribute('data-text-vertical') === 'true', + renderHTML: () => ({}), + }, fillColor: { default: '#FFFFFF', parseHTML: el => (el as HTMLElement).getAttribute('data-fill') || null, @@ -206,6 +214,7 @@ export const TextBox = Node.create({ ...(a.wrap !== 'inline' ? { 'data-wrap': a.wrap } : {}), ...(a.shapeKind !== 'textbox' ? { 'data-shape': a.shapeKind } : {}), ...(a.flipV ? { 'data-flip-v': 'true' } : {}), + ...(a.textVertical ? { 'data-text-vertical': 'true' } : {}), ...(a.fillColor ? { 'data-fill': a.fillColor } : {}), ...(a.strokeColor ? { 'data-stroke': a.strokeColor } : {}), ...(a.strokeWidthPt !== 1 ? { 'data-stroke-width': String(a.strokeWidthPt) } : {}), @@ -370,6 +379,8 @@ class TextBoxView { // A line holds no text: the paragraph the schema requires stays in the document // (and in both exports' anchor), it just takes no room. this.contentDOM.style.display = line ? 'none' : ''; + // Vertical text: the browser flows it, so the box needs nothing but the mode. + this.contentDOM.style.writingMode = a.textVertical ? 'vertical-rl' : ''; this.applyOutline(); this.applyLine(); this.applyWrap(); diff --git a/src/lib/export/CLAUDE.md b/src/lib/export/CLAUDE.md index c9ecda0..a82ad08 100644 --- a/src/lib/export/CLAUDE.md +++ b/src/lib/export/CLAUDE.md @@ -26,7 +26,7 @@ Frames, tables and pagination have their own deep-dives in `docs/architecture/`. - **Hard breaks & tabs** (`replaceHardBreaks`/`replaceTabs`/`applyInlineSentinels`): `hardBreak` nodes become `LBR`-sentinel text and tab chars become `TAB`-sentinel text so both survive every odf-kit path (a literal `\t` would collapse to a space), then the sentinels are rewritten to ``/`` in content.xml. - **Images** (`replaceImages`/`applyImages`): odf-kit's native image path rounds dimensions to whole cm and doesn't reach our cell path, so images bypass it. `replaceImages` (a pre-pass) swaps each `image` node for an `IMG`-sentinel text run and collects the bytes (decoded data-URI) + cm geometry (px→cm via `round3`); the sentinel rides every odf-kit path including table cells. `applyImages` (after `applyCellBlocks`) rewrites each sentinel to a ``, adds the binary `Pictures/` entries to the zip, and appends a `` per picture to `META-INF/manifest.xml`. Integer px ⇄ round3-cm ⇄ px is sub-pixel exact, so size is unchanged. A rotated image also gets a `draw:transform="rotate() translate(...)"` (ODF rotate is CCW radians, ours CW degrees; the translate re-centres it on the unrotated box). A **floating** image (`wrap !== 'inline'`) instead uses `text:anchor-type="paragraph"` + a minted `` carrying `style:wrap` + `style:horizontal-pos` (image-left → `wrap="right" horizontal-pos="left"`; topBottom → `wrap="none" horizontal-pos="center"`) injected into content.xml automatic-styles. - **Tables:** column widths come from the editor's per-column weights (`tableColumnWidthsCm`, summing exactly to the text width, with `table:align="margins"`). **Table margins:** a table's `marginLeft`/`marginRight` shrink that width and are written by `applyTableMargins` into the table's automatic style (`style:width` + `fo:margin-left`/`-right`; odf-kit names table styles `Table1`, `Table2`, … in document order, matching the descriptor list `exportTable` fills). odf-kit serializes each cell to a single `` of runs; `exportTable` emits all of a cell's content into that paragraph separated by a `SEG` sentinel and records a `CellBlock[]` descriptor, then `applyCellBlocks` splits on `SEG` and rebuilds real ``/``/`` (incl. nested lists) with minted automatic paragraph styles. **Merged cells:** `exportTable` passes each cell's `colspan`/`rowspan` as odf-kit `CellOptions.colSpan`/`rowSpan`; odf-kit emits `table:number-columns/rows-spanned` and auto-generates the `` placeholders (which never match the `applyCellBlocks` cell regex, so `cellBlocks` stays one-per-real-cell aligned). Import already reads spans/covered cells in `convertTable`. **Cell shading:** a cell's `backgroundColor` attr is passed as `CellOptions.backgroundColor` (normalized), which odf-kit mints into the cell style as `fo:background-color`. **Cell borders:** the per-side border attrs (tableCellBorders.ts) are passed as `CellOptions.borderTop/Right/Bottom/Left` (`'none'` or `'pt solid #RRGGBB'`) overriding the table-level default border per side. -- **Text boxes / shapes** (`replaceTextBoxes`/`applyTextBoxes`): a top-level `textBox` is **hoisted** — `replaceTextBoxes` (after `replacePageBreaks`, before the inline passes) swaps it for `TBX`-sentinel marker paragraphs (`S{i}`…`E{i}`, U+E008) bracketing its child blocks at top level, so every existing pass (custom attrs, list styles, inline sentinels, images) serializes them unchanged and document-order-indexed passes stay aligned. `applyTextBoxes` (after `applyImages`) wraps each serialized S…E region into `` (plain box; `svg:height` also emitted for non-auto-grow consumers) or `` + preset `` (`utils/shapes.ts`; see `docs/architecture/frames.md`) inside a fresh anchor paragraph, minting a `TbxFr{n}` graphic style (fill/stroke/padding + the image wrap props; `draw:auto-grow-height="true"` for boxes, both auto-grows explicitly **false** for shapes or LibreOffice's autofit shrinks them to their text). +- **Text boxes / shapes** (`replaceTextBoxes`/`applyTextBoxes`): a top-level `textBox` is **hoisted** — `replaceTextBoxes` (after `replacePageBreaks`, before the inline passes) swaps it for `TBX`-sentinel marker paragraphs (`S{i}`…`E{i}`, U+E008) bracketing its child blocks at top level, so every existing pass (custom attrs, list styles, inline sentinels, images) serializes them unchanged and document-order-indexed passes stay aligned. `applyTextBoxes` (after `applyImages`) wraps each serialized S…E region into `` (plain box; `svg:height` also emitted for non-auto-grow consumers) or `` + preset `` (`utils/shapes.ts`; see `docs/architecture/frames.md`) inside a fresh anchor paragraph, minting a `TbxFr{n}` graphic style (fill/stroke/padding + the image wrap props, plus `` for a box whose text runs top-to-bottom — probed: in the graphic properties LibreOffice drops it; `draw:auto-grow-height="true"` for boxes, both auto-grows explicitly **false** for shapes or LibreOffice's autofit shrinks them to their text). - **A text box's own parts, DOCX** (`applyTextBoxesDocx`): the `docx` package can't emit a DrawingML shape, so the box XML is a hand-built string — and its content needs parts the package never hears about. The pass holds the whole unzipped package, so it mints them itself: a picture becomes `word/media/tbx{n}.{ext}` plus a `Relationship` above the package's highest `rId` (Content_Types already declares the raster defaults), a list an ``/`` pair above its highest id, appended **before** the first `` because every abstract definition has to precede them. The numbering ids only exist once the packed file is in hand, so the paragraphs carry a `TXBX_NUM` sentinel that the same pass substitutes. - **Templates** (`template.ts`): a `.ott`/`.dotx` is the built document with one label changed — ODF's package media type (in `mimetype` **and** in the manifest, the mimetype entry staying first and stored) and OOXML's content type for `/word/document.xml`. `saveAsTemplate` offers both in one picker, so the bytes are only built once the extension is known. - **Formulas** (`replaceFormulas`/`applyFormulas`): an `MTH`-sentinel run becomes an as-char `` plus a `Formula{n}/content.xml` sub-document (MathML root) and its two manifest entries. **No `svg:width`/`svg:height`** — a sized frame makes LibreOffice scale the object instead of typesetting it. DOCX emits `` (or `` when displayed) from the same post-pack pass as the text boxes. See `docs/architecture/formulas.md`. diff --git a/src/lib/export/docx.ts b/src/lib/export/docx.ts index 49555d9..7dd49cf 100644 --- a/src/lib/export/docx.ts +++ b/src/lib/export/docx.ts @@ -688,6 +688,7 @@ type TextBoxDocx = { distCm: number | null; shapeKind: ShapeKind; flipV: boolean; + textVertical: boolean; fill: string | null; stroke: string | null; strokeWidthPt: number; @@ -707,6 +708,7 @@ function textBoxDocxDescriptor(node: TiptapNode): TextBoxDocx { distCm: typeof a.wrapDist === 'number' ? a.wrapDist : null, shapeKind: isShapeKind(a.shapeKind) ? a.shapeKind : 'textbox', flipV: a.flipV === true, + textVertical: a.textVertical === true, fill: typeof a.fillColor === 'string' && a.fillColor ? a.fillColor : null, stroke: typeof a.strokeColor === 'string' && a.strokeColor ? a.strokeColor : null, strokeWidthPt: typeof a.strokeWidthPt === 'number' && a.strokeWidthPt > 0 ? a.strokeWidthPt : 1, @@ -938,7 +940,8 @@ function textBoxDrawingXml(box: TextBoxDocx, index: number, parts: TxbxParts): s `` + `${line ? '' : fill}${ln}` + body + - `${autofit}` + + `${autofit}` + ``; const graphic = `` + diff --git a/src/lib/export/odt.ts b/src/lib/export/odt.ts index fa6ebeb..f081998 100644 --- a/src/lib/export/odt.ts +++ b/src/lib/export/odt.ts @@ -943,6 +943,7 @@ type TextBoxExport = { paddingCm: number; shapeKind: ShapeKind; flipV: boolean; + textVertical: boolean; fill: string | null; stroke: string | null; strokeWidthPt: number; @@ -968,6 +969,7 @@ function textBoxDescriptor(node: TiptapNode): TextBoxExport { paddingCm: typeof a.paddingCm === 'number' ? round3(a.paddingCm) : TEXTBOX_PADDING_CM, shapeKind: isShapeKind(a.shapeKind) ? a.shapeKind : 'textbox', flipV: a.flipV === true, + textVertical: a.textVertical === true, fill: typeof a.fillColor === 'string' && a.fillColor ? a.fillColor : null, stroke: typeof a.strokeColor === 'string' && a.strokeColor ? a.strokeColor : null, strokeWidthPt: typeof a.strokeWidthPt === 'number' && a.strokeWidthPt > 0 ? a.strokeWidthPt : 1, @@ -3860,10 +3862,15 @@ function textBoxGraphicStyle(box: TextBoxExport, index: number): string { ` draw:marker-${side}="${ODF_ARROW}" draw:marker-${side}-width="${arrowHeadCm(box.strokeWidthPt)}cm"`; const arrows = heads === 'end' ? marker('end') : heads === 'both' ? marker('end') + marker('start') : ''; + // Vertical text is a *paragraph* property of the frame's style — probed: in the + // graphic properties LibreOffice drops it, here it keeps it and lays the box out. + const vertical = box.textVertical + ? '' + : ''; return ( `` + `` + + `${grow} draw:textarea-vertical-align="top"${wrap}/>${vertical}` + `` ); } diff --git a/src/lib/i18n/locales/de.ts b/src/lib/i18n/locales/de.ts index 16edb53..198c3e3 100644 --- a/src/lib/i18n/locales/de.ts +++ b/src/lib/i18n/locales/de.ts @@ -326,6 +326,7 @@ const de: Messages = { lineArrow: 'Pfeil', lineDoubleArrow: 'Doppelpfeil', }, + verticalText: 'Senkrechter Text', fillColor: 'Füllfarbe', chooseFillColor: 'Füllfarbe wählen', noFill: 'Keine Füllung', diff --git a/src/lib/i18n/locales/en.ts b/src/lib/i18n/locales/en.ts index 2f1206c..3ed2a0b 100644 --- a/src/lib/i18n/locales/en.ts +++ b/src/lib/i18n/locales/en.ts @@ -330,6 +330,7 @@ const en = { lineArrow: 'Arrow', lineDoubleArrow: 'Double arrow', }, + verticalText: 'Vertical text', fillColor: 'Fill color', chooseFillColor: 'Choose fill color', noFill: 'No fill', diff --git a/src/lib/import/CLAUDE.md b/src/lib/import/CLAUDE.md index 4aaec1d..be97bd9 100644 --- a/src/lib/import/CLAUDE.md +++ b/src/lib/import/CLAUDE.md @@ -32,6 +32,7 @@ The **Open .odt** button (`App.svelte`) parses an uploaded file with `importOdt( - **A header/footer zone is fitted to its schema** (`fitZoneSchema`): the zone editor has fewer marks and nodes than the body, and one it doesn't know makes `generateHTML` throw — which renders the whole zone blank. Unknown marks are dropped, unknown nodes leave their text. - **A hoisted text box keeps what its anchor paragraph gave it**: an as-char figure frame is centred by the paragraph it sits in, so `wrapAlign` carries that (or the frame's own `style:horizontal-pos`) onto the box. Its `fo:padding` is read too — the editor's own 0.15cm ring is only the default. - **A cell's number format** is on its *style* in ODF (`style:data-style-name` → a `number:number-style`/`percentage-style`, read for its decimals, grouping and percent sign) and on the field in DOCX (the `\#` picture, which is not part of the formula and is cut out of it). Only a formula cell keeps one. +- **Vertical text in a box** is the frame style's writing mode in ODF (its *paragraph* properties, both top-to-bottom modes) and `w:bodyPr vert` in DOCX (`vert`/`eaVert`/`mongolianVert`/`wordArtVert`; `vert270` reads bottom-to-top, which the browser cannot lay out, so it is not one). VML says the same as `layout-flow:vertical` on the textbox. - **Ruby**: `text:ruby` and `w:ruby` are one atom here (`ruby.ts`), so only the two texts are read — the base out of `text:ruby-base` / `w:rubyBase`, the reading out of `text:ruby-text` / `w:rt`. A file's own alignment and position are dropped; both products' defaults are what the exports write. - **Bibliography**: a `text:bibliography-mark`'s every `text:` attribute but the identifier and the type is a source field, whatever the file names it, so nothing is lost on a format we have no UI for. Word's `CITATION` names a tag only — the record comes from `customXml/item*.xml` (each is probed for a `b:Sources` root), and a tag no source declares still cites with the field's cached text. `BIBLIOGRAPHY` and `text:bibliography` both become the index node. - **Tracked changes**: ODF points at a registry, so `odfRevisions(body)` reads `` first and the body walk resolves each `text:change-start`/`-end` and `text:change` against it (the open insertions live in `Ctx` — a range may close in a later paragraph). A `text:change` is a deletion whose text is *only* in the registry: it is emitted there and then, marked. Word needs no registry — `w:ins`/`w:del` wrap their runs, whose text sits in `w:delText` rather than `w:t` for a deletion. diff --git a/src/lib/import/docx.ts b/src/lib/import/docx.ts index 4b0e3aa..c212dbd 100644 --- a/src/lib/import/docx.ts +++ b/src/lib/import/docx.ts @@ -1913,6 +1913,11 @@ function convertWpsShape(wsp: Element, root: Element, isAnchor: boolean, ctx: Ct if (nsChild(spPr, A, 'xfrm')?.getAttribute('flipV') === '1') attrs.flipV = true; } + // Vertical text: every one of Word's top-to-bottom flows, the editor having the one + // direction the browser lays out (`vert270` reads bottom-to-top and is not one). + const vert = nsChild(wsp, WPS, 'bodyPr')?.getAttribute('vert') ?? 'horz'; + if (['vert', 'eaVert', 'mongolianVert', 'wordArtVert'].includes(vert)) attrs.textVertical = true; + const txbxContent = nsChild(nsChild(wsp, WPS, 'txbx'), W, 'txbxContent'); const blocks = txbxContent ? convertBlocks(Array.from(txbxContent.children), ctx, 'cell') : []; return { type: 'textBox', attrs, content: blocks.length ? blocks : [{ type: 'paragraph' }] }; @@ -1959,10 +1964,13 @@ function convertPict(pict: Element, ctx: Ctx): Node | null { return { type: 'image', attrs: imgAttrs }; } - const txbxContent = nsChild(shape.getElementsByTagNameNS(VML, 'textbox')[0] ?? null, W, 'txbxContent'); + const textbox = shape.getElementsByTagNameNS(VML, 'textbox')[0] ?? null; + const txbxContent = nsChild(textbox, W, 'txbxContent'); if (!txbxContent) { ctx.warnings.add('Drawings were removed'); return null; } const attrs: Record = {}; + // VML says vertical text in the box's own style, as `layout-flow:vertical`. + if (/layout-flow\s*:\s*vertical/.test(textbox?.getAttribute('style') ?? '')) attrs.textVertical = true; const kind = shape.localName === 'oval' ? 'ellipse' : shape.localName === 'roundrect' ? 'roundRect' : 'textbox'; if (kind !== 'textbox') attrs.shapeKind = kind; if (w) attrs.width = w; diff --git a/src/lib/import/odt.ts b/src/lib/import/odt.ts index e60eaa8..267bc98 100644 --- a/src/lib/import/odt.ts +++ b/src/lib/import/odt.ts @@ -420,6 +420,10 @@ function convertTextBoxFrame(frame: Element, textBoxEl: Element, ctx: Ctx): Node const padCm = lengthToCm(gp['fo:padding']); if (padCm != null && Math.abs(padCm - TEXTBOX_PADDING_CM) > 0.01) attrs.paddingCm = Math.round(padCm * 1000) / 1000; shapeStyleAttrs(gp, attrs, false); + // Vertical text: the frame style's writing mode, both of ODF's top-to-bottom modes + // (the editor has the one direction the browser lays out). + const mode = ctx.resolver.graphicParaProps(frame.getAttributeNS(NS.draw, 'style-name'))['style:writing-mode']; + if (mode === 'tb-rl' || mode === 'tb-lr' || mode === 'tb') attrs.textVertical = true; return { type: 'textBox', attrs, content: textBoxContent(Array.from(textBoxEl.children), ctx) }; } diff --git a/src/lib/import/styleResolver.ts b/src/lib/import/styleResolver.ts index a30735b..b059210 100644 --- a/src/lib/import/styleResolver.ts +++ b/src/lib/import/styleResolver.ts @@ -340,6 +340,12 @@ export class StyleResolver { return styleName ? this.merged('graphic', styleName).misc : {}; } + // A frame style's own paragraph properties, which is where its writing mode lives + // (probed: in the graphic properties LibreOffice drops it). + graphicParaProps(styleName: string | null): PropMap { + return styleName ? this.merged('graphic', styleName).para : {}; + } + // The document's default spell-check language, read from the base Standard // paragraph style (falls back to the paragraph default-style). null when unset. documentLanguage(): { language: string; country: string } | null { diff --git a/tests/unit/vertical-text-box.test.ts b/tests/unit/vertical-text-box.test.ts new file mode 100644 index 0000000..0eb762b --- /dev/null +++ b/tests/unit/vertical-text-box.test.ts @@ -0,0 +1,49 @@ +// A text box whose text runs top-to-bottom. ODF keeps it as the frame style's own +// writing mode (in its *paragraph* properties — probed: in the graphic properties +// LibreOffice drops it), Word as the shape body's `vert`. +import { describe, it, expect } from 'vitest'; +import { unzipSync, strFromU8 } from 'fflate'; +import { buildOdt } from '../../src/lib/export/odt'; +import { buildDocx } from '../../src/lib/export/docx'; +import { importOdt } from '../../src/lib/import/odt'; +import { importDocx } from '../../src/lib/import/docx'; + +type N = any; + +const box = (attrs: N): N => ({ + type: 'textBox', + attrs: { width: 200, height: 160, ...attrs }, + content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Senkrecht' }] }], +}); +const doc: N = { + type: 'doc', + content: [{ type: 'paragraph', content: [{ type: 'text', text: 'davor' }] }, box({ textVertical: true })], +}; +const margins = { top: 2, bottom: 2, left: 2, right: 2 }; + +const boxOf = (r: N): N => ((r.content as N).content ?? []).find((n: N) => n.type === 'textBox'); + +describe('a text box with vertical text', () => { + it('round-trips through ODF', async () => { + const bytes = await buildOdt(doc, margins, 'portrait'); + const xml = strFromU8(unzipSync(bytes)['content.xml']); + expect(xml).toContain(''); + expect(boxOf(importOdt(bytes))?.attrs.textVertical).toBe(true); + }); + + it('round-trips through DOCX', async () => { + const bytes = await buildDocx(doc, margins, 'portrait'); + const xml = strFromU8(unzipSync(bytes)['word/document.xml']); + expect(xml).toContain('vert="vert"'); + expect(boxOf(importDocx(bytes))?.attrs.textVertical).toBe(true); + }); + + it('leaves a horizontal box alone', async () => { + const flat: N = { ...doc, content: [doc.content[0], box({})] }; + const odt = strFromU8(unzipSync(await buildOdt(flat, margins, 'portrait'))['content.xml']); + expect(odt).not.toContain('writing-mode="tb-rl"'); + const docx = strFromU8(unzipSync(await buildDocx(flat, margins, 'portrait'))['word/document.xml']); + expect(docx).toContain('vert="horz"'); + expect(boxOf(importOdt(await buildOdt(flat, margins, 'portrait')))?.attrs.textVertical).toBeUndefined(); + }); +});