Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.
C# audio-converteravaloniabatch-conversionconvertercsharpdocument-converterdocx-to-pdfdotnetdrag-and-dropfile-conversionfile-converterheic-converterhwphwpximage-converterlinuxmacospdf-convertervideo-converterwindows
// Document body: sections (page setup, columns, headers and footers), paragraphs, runs and tables.
//
// Word keeps a section's properties at its end: in the last paragraph of the section (w:pPr/w:sectPr) and, for the
// last section, as the last child of w:body. Columns that change mid-page (HParagraph.ColumnsChange) become
// continuous section breaks, which is how Word itself does it. Element order follows the schema sequences
// (CT_PPr, CT_RPr, CT_SectPr, CT_TblPr, CT_TcPr), which Word enforces.
using System.Text;
using Filee.Engines.Infrastructure;
namespace Filee.Engines.Hwp.Hwpx.Docx;
internal sealed partial class DocxWriter
{
/// <summary>A4 with one-inch margins and headers/footers 1.5 cm from the edge (Word's A4 default).</summary>
private static readonly HPage DefaultPage = new(59528, 84188, 7200, 7200, 4255, 4255, 2945, 2945, 0);
/// <summary>Word's highlight colours (the ones DocxReader turns into shades), by "#RRGGBB".</summary>
private static readonly Dictionary<string, string> Highlights = new(StringComparer.OrdinalIgnoreCase)
{
["#FFFF00"] = "yellow",
["#00FF00"] = "green",
["#00FFFF"] = "cyan",
["#FF00FF"] = "magenta",
["#0000FF"] = "blue",
["#FF0000"] = "red",
["#000080"] = "darkBlue",
["#008080"] = "darkCyan",
["#008000"] = "darkGreen",
["#800080"] = "darkMagenta",
["#800000"] = "darkRed",
["#808000"] = "darkYellow",
["#808080"] = "darkGray",
["#C0C0C0"] = "lightGray",
["#000000"] = "black",
};
/// <summary>Width (HWPUNIT) available to the content being written: column, table cell or text box.</summary>
private int _width = DefaultPage.TextWidth;
/// <summary>Header / footer types referenced by earlier sections (Word would let later sections inherit them).</summary>
private readonly HashSet<string> _headerTypes = [];
private readonly HashSet<string> _footerTypes = [];
/// <summary>What the paragraph style of the current paragraph already sets (explicit "off" values override it).</summary>
private readonly record struct RunContext(bool StyleBold, bool Link);
// ───────────────────────── Sections ─────────────────────────
private string Body(HDocument document)
{
var sections = document.Sections.Count > 0 ? document.Sections : [new HSection()];
_evenAndOddHeaders = sections.Any(s => s.Headers.Concat(s.Footers).Any(h => h.Pages == HPageType.Even));
var sb = new StringBuilder();
for (var s = 0; s < sections.Count; s++)
{
var section = sections[s];
var page = section.Page ?? DefaultPage;
var parts = SplitAtColumnChanges(section);
for (var p = 0; p < parts.Count; p++)
{
var (columns, blocks) = parts[p];
_width = page.TextWidth;
var sectPr = SectionProperties(section, page, columns, continuous: p > 0);
_width = ColumnWidth(page.TextWidth, columns);
var last = s == sections.Count - 1 && p == parts.Count - 1;
if (last)
sb.Append(Blocks(blocks, requireParagraph: true)).Append(sectPr);
else
sb.Append(Blocks(blocks, sectionEnd: sectPr));
}
}
return sb.ToString();
}
/// <summary>Splits a section where its columns change: each piece becomes a Word section of its own.</summary>
private static List<(HColumns Columns, List<HBlock> Blocks)> SplitAtColumnChanges(HSection section)
{
var parts = new List<(HColumns, List<HBlock>)>();
var columns = section.Columns;
var current = new List<HBlock>();
foreach (var block in section.Blocks)
{
if (block is HParagraph { ColumnsChange: { } change })
{
if (current.Count > 0)
{
parts.Add((columns, current));
current = [];
}
columns = change;
}
current.Add(block);
}
parts.Add((columns, current));
return parts;
}
private static int ColumnWidth(int textWidth, HColumns columns) =>
columns.Count <= 1 ? textWidth : Math.Max(2000, (textWidth - columns.Gap * (columns.Count - 1)) / columns.Count);
/// <summary>w:sectPr in schema order: references, type, pgSz, pgMar, pgNumType, cols, titlePg.</summary>
private string SectionProperties(HSection section, HPage page, HColumns columns, bool continuous)
{
var sb = new StringBuilder("<w:sectPr>");
var titlePage = !continuous && (section.HideFirstHeader || section.HideFirstFooter);
if (!continuous)
{
HeaderFooterReferences(sb, "header", section.Headers, section.HideFirstHeader, titlePage, _headerTypes);
HeaderFooterReferences(sb, "footer", section.Footers, section.HideFirstFooter, titlePage, _footerTypes);
}
else
{
sb.Append("<w:type w:val=\"continuous\"/>");
}
// The model's Top / Bottom run from the paper edge to the header / footer and Header / Footer are their
// heights (as in 한글); Word's top / bottom margins reach the body and header / footer are the distances.
sb.Append($"<w:pgSz w:w=\"{Number(Twips(page.Width))}\" w:h=\"{Number(Twips(page.Height))}\"{(page.Landscape ? " w:orient=\"landscape\"" : "")}/>");
sb.Append($"<w:pgMar w:top=\"{Number(Twips(page.Top + page.Header))}\" w:right=\"{Number(Twips(page.Right))}\" w:bottom=\"{Number(Twips(page.Bottom + page.Footer))}\" w:left=\"{Number(Twips(page.Left))}\" ")
.Append($"w:header=\"{Number(Twips(page.Top))}\" w:footer=\"{Number(Twips(page.Bottom))}\" w:gutter=\"{Number(Twips(page.Gutter))}\"/>");
if (!continuous && section.StartPageNumber is { } start)
sb.Append($"<w:pgNumType w:start=\"{Number(start)}\"/>");
sb.Append(columns.Count > 1
? $"<w:cols w:num=\"{Number(Math.Min(columns.Count, 45))}\" w:space=\"{Number(Twips(columns.Gap))}\"{(columns.Separator ? " w:sep=\"1\"" : "")}/>"
: "<w:cols w:space=\"720\"/>");
if (titlePage)
sb.Append("<w:titlePg/>");
return sb.Append("</w:sectPr>").ToString();
}
/// <summary>
/// Header or footer references of a section. Word lets a section without a reference inherit the previous
/// section's, so a type used before but missing here gets an empty part; "different first page" gets a first
/// header that is empty or a copy of the default one.
/// </summary>
private void HeaderFooterReferences(StringBuilder sb, string kind, List<HHeaderFooter> items, bool hideFirst, bool titlePage, HashSet<string> used)
{
var byType = new Dictionary<string, List<HBlock>>();
foreach (var item in items)
byType[item.Pages == HPageType.Even ? "even" : "default"] = item.Blocks;
// With different odd and even pages, a header for both kinds of page must be given for even pages too.
if (_evenAndOddHeaders && !byType.ContainsKey("even") && items.LastOrDefault(i => i.Pages == HPageType.Both) is { } both)
byType["even"] = both.Blocks;
if (titlePage)
byType["first"] = hideFirst ? [] : byType.GetValueOrDefault("default") ?? [];
foreach (var type in used)
byType.TryAdd(type, []);
foreach (var (type, blocks) in byType)
{
var id = HeaderFooterPart(kind, () => Blocks(blocks, requireParagraph: true));
sb.Append($"<w:{kind}Reference w:type=\"{type}\" r:id=\"{id}\"/>");
used.Add(type);
}
}
// ───────────────────────── Blocks ─────────────────────────
/// <param name="sectionEnd">sectPr to put into the last paragraph (a paragraph is added if the last block is a table).</param>
/// <param name="requireParagraph">The container must end with a paragraph (cells, text boxes, notes, the body).</param>
/// <param name="paragraphStyle">Style of plain paragraphs (footnote text inside notes).</param>
/// <param name="leadingRuns">Runs put first into the first paragraph (the number of a note).</param>
private string Blocks(IReadOnlyList<HBlock> blocks, string? sectionEnd = null, bool requireParagraph = false,
string? paragraphStyle = null, string? leadingRuns = null)
{
var sb = new StringBuilder();
if (leadingRuns is not null && (blocks.Count == 0 || blocks[0] is not HParagraph))
blocks = [new HParagraph(), .. blocks];
for (var i = 0; i < blocks.Count; i++)
{
switch (blocks[i])
{
case HParagraph paragraph:
var isLast = i == blocks.Count - 1;
sb.Append(Paragraph(paragraph, isLast ? sectionEnd : null, paragraphStyle, i == 0 ? leadingRuns : null));
break;
case HTable table:
// Two tables in a row would merge into one in Word.
if (i > 0 && blocks[i - 1] is HTable)
sb.Append("<w:p/>");
sb.Append(Table(table));
break;
}
}
var endsWithParagraph = blocks.Count > 0 && blocks[^1] is HParagraph;
if (sectionEnd is not null && !endsWithParagraph)
sb.Append($"<w:p><w:pPr>{sectionEnd}</w:pPr></w:p>");
else if (requireParagraph && !endsWithParagraph)
sb.Append("<w:p/>");
return sb.ToString();
}
// ───────────────────────── Paragraphs ─────────────────────────
private string Paragraph(HParagraph paragraph, string? sectPr = null, string? style = null, string? leadingRuns = null)
{
var heading = paragraph.HeadingLevel is >= 1 and <= 9 ? paragraph.HeadingLevel : 0;
if (heading > 0)
style = $"Heading{heading}";
var context = new RunContext(StyleBold: heading > 0, Link: false);
var sb = new StringBuilder("<w:p>");
sb.Append(ParagraphProperties(paragraph, style, heading > 0, sectPr, context));
if (paragraph.ColumnBreakBefore)
sb.Append("<w:r><w:br w:type=\"column\"/></w:r>");
sb.Append(leadingRuns);
Inlines(paragraph.Inlines, sb, context);
return sb.Append("</w:p>").ToString();
}
/// <summary>w:pPr in CT_PPr order: pStyle, keepNext, keepLines, pageBreakBefore, widowControl, numPr, tabs, bidi, spacing, ind, jc, rPr, sectPr.</summary>
private string ParagraphProperties(HParagraph paragraph, string? style, bool heading, string? sectPr, RunContext context)
{
var format = paragraph.Format;
var sb = new StringBuilder();
if (style is not null)
sb.Append($"<w:pStyle w:val=\"{style}\"/>");
if (format.KeepWithNext == true)
sb.Append("<w:keepNext/>");
else if (format.KeepWithNext == false && heading)
sb.Append("<w:keepNext w:val=\"0\"/>");
if (format.KeepLines == true)
sb.Append("<w:keepLines/>");
else if (format.KeepLines == false && heading)
sb.Append("<w:keepLines w:val=\"0\"/>");
if (paragraph.PageBreakBefore)
sb.Append("<w:pageBreakBefore/>");
if (format.WidowOrphan == false)
sb.Append("<w:widowControl w:val=\"0\"/>");
if (paragraph.List is { Numbered: true } list)
sb.Append($"<w:numPr><w:ilvl w:val=\"{Number(Math.Clamp(list.Level, 0, 8))}\"/><w:numId w:val=\"{Number(NumberingId(list.Numbering))}\"/></w:numPr>");
if (format.Tabs is { Count: > 0 } tabs)
{
sb.Append("<w:tabs>");
foreach (var tab in tabs.OrderBy(t => t.Position))
{
var kind = tab.Kind switch
{
HTabKind.Right => "right",
HTabKind.Center => "center",
HTabKind.Decimal => "decimal",
_ => "left",
};
var leader = tab.Leader switch
{
"DOT" => " w:leader=\"dot\"",
"DASH" => " w:leader=\"hyphen\"",
"SOLID" => " w:leader=\"underscore\"",
_ => "",
};
sb.Append($"<w:tab w:val=\"{kind}\"{leader} w:pos=\"{Number(Twips(tab.Position))}\"/>");
}
sb.Append("</w:tabs>");
}
// Right to left: w:ind's left / right and w:jc's left / right then mean the start and the end side.
if (format.RightToLeft == true)
sb.Append("<w:bidi/>");
var spacing = new StringBuilder();
if (format.Before is { } before)
spacing.Append($" w:before=\"{Number(Math.Max(0, Twips(before)))}\"");
if (format.After is { } after)
spacing.Append($" w:after=\"{Number(Math.Max(0, Twips(after)))}\"");
if (format.LineSpacing is { } line)
{
// 한글 percentages are of the font size, Word's "auto" lines of the font's line height (≈ 1.3 em):
// the inverse of DocxReader's mapping.
spacing.Append(line.Kind switch
{
HLineSpacingKind.Fixed => $" w:line=\"{Number(Math.Max(20, Twips(line.Value)))}\" w:lineRule=\"exact\"",
HLineSpacingKind.AtLeast => $" w:line=\"{Number(Math.Max(20, Twips(line.Value)))}\" w:lineRule=\"atLeast\"",
_ => $" w:line=\"{Number(Math.Clamp((int)Math.Round(line.Value * 240 / 130.0), 24, 2400))}\" w:lineRule=\"auto\"",
});
}
if (spacing.Length > 0)
sb.Append("<w:spacing").Append(spacing).Append("/>");
var left = format.Left;
var firstLine = format.FirstLine;
if (paragraph.List is { } item && left is null)
{
// Continuation paragraphs of a list item line up with the item's text.
if (!item.Numbered)
sb.Append($"<w:ind w:left=\"{Number(ListIndent(item.Level))}\"/>");
}
else if (left is not null || format.Right is not null || firstLine is not null)
{
if (paragraph.List is not null || (left ?? 0) != 0 || (format.Right ?? 0) != 0 || (firstLine ?? 0) != 0)
{
sb.Append("<w:ind");
if (left is { } l)
sb.Append($" w:left=\"{Number(Twips(l))}\"");
if (format.Right is { } r)
sb.Append($" w:right=\"{Number(Twips(r))}\"");
if (firstLine is < 0)
sb.Append($" w:hanging=\"{Number(Twips(-firstLine.Value))}\"");
else if (firstLine is { } f)
sb.Append($" w:firstLine=\"{Number(Twips(f))}\"");
sb.Append("/>");
}
}
if (format.Align is { } align and not HAlign.Left)
{
sb.Append(align switch
{
HAlign.Center => "<w:jc w:val=\"center\"/>",
HAlign.Right => "<w:jc w:val=\"right\"/>",
HAlign.Distribute => "<w:jc w:val=\"distribute\"/>",
_ => "<w:jc w:val=\"both\"/>",
});
}
var mark = RunProperties(paragraph.MarkFormat, context);
if (mark.Length > 0)
sb.Append("<w:rPr>").Append(mark).Append("</w:rPr>");
sb.Append(sectPr);
return sb.Length == 0 ? "" : $"<w:pPr>{sb}</w:pPr>";
}
// ───────────────────────── Runs ─────────────────────────
private void Inlines(IEnumerable<HInline> inlines, StringBuilder sb, RunContext context)
{
foreach (var inline in inlines)
{
switch (inline)
{
case HText text:
TextRuns(sb, text.Text, text.Format, context);
break;
case HLineBreak lineBreak:
sb.Append("<w:r>").Append(RunPr(lineBreak.Format, context)).Append("<w:br/></w:r>");
break;
case HTab tab:
sb.Append("<w:r>").Append(RunPr(tab.Format, context)).Append("<w:tab/></w:r>");
break;
case HLink link:
Hyperlink(link, sb, context);
break;
case HBookmark bookmark:
{
var id = Number(_nextBookmarkId++);
sb.Append($"<w:bookmarkStart w:id=\"{id}\" w:name=\"{Escape(BookmarkName(bookmark.Name))}\"/><w:bookmarkEnd w:id=\"{id}\"/>");
break;
}
case HField field:
Field(sb, field.Kind == HFieldKind.PageNumber ? "PAGE" : "NUMPAGES", RunPr(field.Format, context));
break;
case HNote note:
sb.Append(NoteReference(note));
break;
case HImage image:
sb.Append(Picture(image));
break;
case HTextBox box:
sb.Append(TextBox(box, context));
break;
case HShape shape:
sb.Append(Shape(shape));
break;
}
}
}
/// <summary>Text runs; line feeds and tabs inside the text become w:br and w:tab.</summary>
private static void TextRuns(StringBuilder sb, string text, HCharFormat format, RunContext context)
{
if (text.Length == 0)
return;
// Arabic or Hebrew text is marked right to left, as Word does: it then takes the complex script font and size.
sb.Append("<w:r>").Append(RunPr(format, context, rightToLeft: ComplexScripts.Direction(text) < 0));
var start = 0;
for (var i = 0; i <= text.Length; i++)
{
if (i < text.Length && text[i] is not ('\n' or '\t' or '\r'))
continue;
if (i > start)
sb.Append("<w:t xml:space=\"preserve\">").Append(Escape(text[start..i])).Append("</w:t>");
if (i < text.Length)
{
if (text[i] == '\t')
sb.Append("<w:tab/>");
else if (text[i] == '\n' || (text[i] == '\r' && (i + 1 >= text.Length || text[i + 1] != '\n')))
sb.Append("<w:br/>");
}
start = i + 1;
}
sb.Append("</w:r>");
}
private static string RunPr(HCharFormat format, RunContext context, string? characterStyle = null, bool rightToLeft = false)
{
var properties = RunProperties(format, context, characterStyle, rightToLeft);
return properties.Length == 0 ? "" : $"<w:rPr>{properties}</w:rPr>";
}
/// <summary>Content of w:rPr in CT_RPr order.</summary>
private static string RunProperties(HCharFormat format, RunContext context, string? characterStyle = null, bool rightToLeft = false)
{
var sb = new StringBuilder();
characterStyle ??= context.Link ? "Hyperlink" : null;
if (characterStyle is not null)
sb.Append($"<w:rStyle w:val=\"{characterStyle}\"/>");
if (format.Font is not null || format.EastAsianFont is not null)
{
sb.Append("<w:rFonts");
if (format.Font is { } latin)
sb.Append($" w:ascii=\"{Escape(latin)}\" w:hAnsi=\"{Escape(latin)}\"");
if ((format.EastAsianFont ?? format.Font) is { } eastAsian)
sb.Append($" w:eastAsia=\"{Escape(eastAsian)}\"");
if (format.Font is { } complex)
sb.Append($" w:cs=\"{Escape(complex)}\"");
sb.Append("/>");
}
if (format.Bold == true)
sb.Append("<w:b/><w:bCs/>");
else if (format.Bold == false && context.StyleBold)
sb.Append("<w:b w:val=\"0\"/><w:bCs w:val=\"0\"/>");
if (format.Italic == true)
sb.Append("<w:i/><w:iCs/>");
if (format.Strike == true)
sb.Append("<w:strike/>");
if (Hex(format.Color) is { } color)
sb.Append($"<w:color w:val=\"{color}\"/>");
var size = format.Size ?? DefaultSize;
if (format.Spacing is { } spacing and not 0)
{
// 한글 letter spacing is a percentage of the font size, Word's an absolute distance in twips.
sb.Append($"<w:spacing w:val=\"{Number((int)Math.Round(spacing * size / 500.0))}\"/>");
}
if (format.Size is { } explicitSize)
{
var halfPoints = Number(Math.Clamp((int)Math.Round(explicitSize / 50.0), 2, 3276));
sb.Append($"<w:sz w:val=\"{halfPoints}\"/><w:szCs w:val=\"{halfPoints}\"/>");
}
var highlight = format.Shade is { } shade ? Highlights.GetValueOrDefault(shade) : null;
if (highlight is not null)
sb.Append($"<w:highlight w:val=\"{highlight}\"/>");
if (format.Underline == true)
sb.Append("<w:u w:val=\"single\"/>");
else if (format.Underline == false && characterStyle == "Hyperlink")
sb.Append("<w:u w:val=\"none\"/>");
if (highlight is null && Hex(format.Shade) is { } fill)
sb.Append($"<w:shd w:val=\"clear\" w:color=\"auto\" w:fill=\"{fill}\"/>");
if (format.Superscript == true)
sb.Append("<w:vertAlign w:val=\"superscript\"/>");
else if (format.Subscript == true)
sb.Append("<w:vertAlign w:val=\"subscript\"/>");
if (rightToLeft)
sb.Append("<w:rtl/>");
return sb.ToString();
}
/// <summary>A complex field (PAGE, NUMPAGES) with a cached result Word updates when it lays out the page.</summary>
private static void Field(StringBuilder sb, string instruction, string runProperties)
{
sb.Append($"<w:r>{runProperties}<w:fldChar w:fldCharType=\"begin\"/></w:r>");
sb.Append($"<w:r>{runProperties}<w:instrText xml:space=\"preserve\"> {instruction} </w:instrText></w:r>");
sb.Append($"<w:r>{runProperties}<w:fldChar w:fldCharType=\"separate\"/></w:r>");
sb.Append($"<w:r>{runProperties}<w:t>1</w:t></w:r>");
sb.Append($"<w:r>{runProperties}<w:fldChar w:fldCharType=\"end\"/></w:r>");
}
/// <summary>
/// A footnote or endnote: the reference in the text, the note itself in footnotes.xml / endnotes.xml. Word only
/// allows notes in the body text (not in notes, headers, footers or text boxes): there the note's text stays in
/// place, in brackets.
/// </summary>
private string NoteReference(HNote note)
{
var (kind, style) = note.Endnote ? ("endnote", "Endnote") : ("footnote", "Footnote");
if (_part != _document || _textBoxDepth > 0)
{
var text = string.Concat(note.Blocks.OfType<HParagraph>().SelectMany(p => p.Inlines).OfType<HText>().Select(t => t.Text));
var sb = new StringBuilder();
TextRuns(sb, $" ({text})", default, default);
return sb.ToString();
}
var part = note.Endnote
? _endnotesPart ??= new Part("word/endnotes.xml", ContentTypeBase + "endnotes+xml")
: _footnotesPart ??= new Part("word/footnotes.xml", ContentTypeBase + "footnotes+xml");
var notes = note.Endnote ? _endnotes : _footnotes;
var id = notes.Count + 1;
notes.Add("");
var number = $"<w:r><w:rPr><w:rStyle w:val=\"{style}Reference\"/></w:rPr><w:{kind}Ref/></w:r><w:r><w:t xml:space=\"preserve\"> </w:t></w:r>";
notes[id - 1] = WithPart(part, () => Blocks(note.Blocks, requireParagraph: true, paragraphStyle: style + "Text", leadingRuns: number));
return $"<w:r><w:rPr><w:rStyle w:val=\"{style}Reference\"/></w:rPr><w:{kind}Reference w:id=\"{Number(id)}\"/></w:r>";
}
// ───────────────────────── Tables ─────────────────────────
private string Table(HTable table)
{
if (table.Rows.Count == 0)
return "";
var (placed, columnCount) = HwpxWriter.PlaceCells(table);
var available = Math.Max(4000, _width - (table.Align == HAlign.Left ? table.Indent : 0));
var widths = HwpxWriter.ColumnWidths(table, columnCount, available);
var borders = table.Borders ?? HBorders.Grid;
var margin = table.CellMargin;
// Cells that span rows: the positions below their first row are continuation cells (w:vMerge).
var continuations = new Dictionary<(int Row, int Column), HCell>();
for (var r = 0; r < placed.Count; r++)
{
foreach (var (cell, column) in placed[r])
{
for (var below = 1; below < cell.RowSpan; below++)
continuations[(r + below, column)] = cell;
}
}
var sb = new StringBuilder("<w:tbl><w:tblPr>");
sb.Append($"<w:tblW w:w=\"{Number(Twips(widths.Sum()))}\" w:type=\"dxa\"/>");
if (table.Align is HAlign.Center or HAlign.Right)
sb.Append($"<w:jc w:val=\"{(table.Align == HAlign.Center ? "center" : "right")}\"/>");
else if (table.Indent != 0)
sb.Append($"<w:tblInd w:w=\"{Number(Twips(table.Indent))}\" w:type=\"dxa\"/>");
sb.Append("<w:tblBorders>")
.Append(Border("top", borders.Top)).Append(Border("left", borders.Left))
.Append(Border("bottom", borders.Bottom)).Append(Border("right", borders.Right))
.Append(Border("insideH", borders.Top)).Append(Border("insideV", borders.Left))
.Append("</w:tblBorders>");
sb.Append("<w:tblLayout w:type=\"fixed\"/>");
if (margin is { } m)
sb.Append($"<w:tblCellMar><w:top w:w=\"{Number(Twips(m.Top))}\" w:type=\"dxa\"/><w:left w:w=\"{Number(Twips(m.Left))}\" w:type=\"dxa\"/><w:bottom w:w=\"{Number(Twips(m.Bottom))}\" w:type=\"dxa\"/><w:right w:w=\"{Number(Twips(m.Right))}\" w:type=\"dxa\"/></w:tblCellMar>");
sb.Append("<w:tblLook w:val=\"04A0\"/></w:tblPr>");
sb.Append("<w:tblGrid>").Append(string.Concat(widths.Select(w => $"<w:gridCol w:w=\"{Number(Twips(w))}\"/>"))).Append("</w:tblGrid>");
var horizontalPadding = margin is { } cellMargin ? cellMargin.Left + cellMargin.Right : 1080;
var outerWidth = _width;
var headerRows = table.Rows.TakeWhile(r => r.Header).Count();
for (var r = 0; r < table.Rows.Count; r++)
{
var row = table.Rows[r];
sb.Append("<w:tr>");
if (row.Height is > 0 || r < headerRows)
{
sb.Append("<w:trPr>");
if (row.Height is > 0 and var height)
sb.Append($"<w:trHeight w:val=\"{Number(Twips(height))}\" w:hRule=\"atLeast\"/>");
if (r < headerRows)
sb.Append("<w:tblHeader/>");
sb.Append("</w:trPr>");
}
var starts = r < placed.Count ? placed[r].GroupBy(p => p.Column).ToDictionary(g => g.Key, g => g.First().Cell) : [];
for (var column = 0; column < columnCount;)
{
if (starts.TryGetValue(column, out var cell))
{
var span = Math.Clamp(cell.ColSpan, 1, columnCount - column);
var width = widths.Skip(column).Take(span).Sum();
_width = Math.Max(1000, width - horizontalPadding);
sb.Append(Cell(cell, width, span, cell.RowSpan > 1 ? "<w:vMerge w:val=\"restart\"/>" : "", Blocks(cell.Blocks, requireParagraph: true)));
column += span;
}
else if (continuations.TryGetValue((r, column), out var origin))
{
var span = Math.Clamp(origin.ColSpan, 1, columnCount - column);
sb.Append(Cell(origin, widths.Skip(column).Take(span).Sum(), span, "<w:vMerge/>", "<w:p/>"));
column += span;
}
else
{
// A gap in a ragged row: an empty cell keeps the grid rectangular.
sb.Append($"<w:tc><w:tcPr><w:tcW w:w=\"{Number(Twips(widths[column]))}\" w:type=\"dxa\"/></w:tcPr><w:p/></w:tc>");
column++;
}
}
sb.Append("</w:tr>");
}
_width = outerWidth;
sb.Append("</w:tbl>");
if (table.Caption.Count > 0)
sb.Append(Blocks(table.Caption));
return sb.ToString();
}
/// <summary>w:tc with w:tcPr in CT_TcPr order: tcW, gridSpan, vMerge, tcBorders, shd, vAlign.</summary>
private static string Cell(HCell cell, int width, int span, string vMerge, string content)
{
var sb = new StringBuilder("<w:tc><w:tcPr>");
sb.Append($"<w:tcW w:w=\"{Number(Twips(width))}\" w:type=\"dxa\"/>");
if (span > 1)
sb.Append($"<w:gridSpan w:val=\"{Number(span)}\"/>");
sb.Append(vMerge);
if (cell.Borders is { } borders)
{
sb.Append("<w:tcBorders>")
.Append(Border("top", borders.Top)).Append(Border("left", borders.Left))
.Append(Border("bottom", borders.Bottom)).Append(Border("right", borders.Right))
.Append("</w:tcBorders>");
}
if (Hex(cell.Fill) is { } fill)
sb.Append($"<w:shd w:val=\"clear\" w:color=\"auto\" w:fill=\"{fill}\"/>");
if (cell.CellMargin is { } m)
sb.Append($"<w:tcMar><w:top w:w=\"{Number(Twips(m.Top))}\" w:type=\"dxa\"/><w:left w:w=\"{Number(Twips(m.Left))}\" w:type=\"dxa\"/><w:bottom w:w=\"{Number(Twips(m.Bottom))}\" w:type=\"dxa\"/><w:right w:w=\"{Number(Twips(m.Right))}\" w:type=\"dxa\"/></w:tcMar>");
if (cell.VerticalAlign != HVerticalAlign.Top)
sb.Append($"<w:vAlign w:val=\"{(cell.VerticalAlign == HVerticalAlign.Center ? "center" : "bottom")}\"/>");
sb.Append("</w:tcPr>").Append(content);
return sb.Append("</w:tc>").ToString();
}
/// <summary>A border edge: style, width in eighths of a point (2..96), colour.</summary>
private static string Border(string edge, HBorder border)
{
if (border.Style == HBorderStyle.None)
return $"<w:{edge} w:val=\"nil\"/>";
var style = border.Style switch
{
HBorderStyle.Dash => "dashed",
HBorderStyle.Dot => "dotted",
HBorderStyle.DashDot => "dotDash",
HBorderStyle.Double => "double",
_ => "single",
};
var eighths = Math.Clamp((int)Math.Round(border.WidthMm / 25.4 * 72 * 8), 2, 96);
return $"<w:{edge} w:val=\"{style}\" w:sz=\"{Number(eighths)}\" w:space=\"0\" w:color=\"{Hex(border.Color) ?? "auto"}\"/>";
}
}