4062 lines
137 KiB
Markdown
4062 lines
137 KiB
Markdown
# OpenXML SDK 3.x Complete Reference Encyclopedia
|
||
|
||
**Target:** DocumentFormat.OpenXml 3.x / .NET 8+ / C# 12
|
||
**Last Updated:** 2026-03-22
|
||
|
||
This document serves as an exhaustive reference for building DOCX files with the OpenXML SDK. Every code block is ready to copy-paste.
|
||
|
||
---
|
||
|
||
## Namespace Aliases Used Throughout
|
||
|
||
```csharp
|
||
using DocumentFormat.OpenXml;
|
||
using DocumentFormat.OpenXml.Packaging;
|
||
using DocumentFormat.OpenXml.Wordprocessing;
|
||
```
|
||
|
||
---
|
||
|
||
## Table of Contents
|
||
|
||
1. [Document Creation Skeleton](#1-document-creation-skeleton)
|
||
2. [Style System Deep Dive](#2-style-system-deep-dive)
|
||
3. [Character Formatting (RunProperties)](#3-character-formatting-runproperties--exhaustive)
|
||
4. [Paragraph Formatting (ParagraphProperties)](#4-paragraph-formatting-paragraphproperties--exhaustive)
|
||
|
||
---
|
||
|
||
## 1. Document Creation Skeleton
|
||
|
||
### 1.1 Complete Flow: Create to Save
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// DOCUMENT CREATION SKELETON
|
||
// =============================================================================
|
||
// This is the minimal complete flow for creating a valid DOCX from scratch.
|
||
// Follow these steps in order: Create -> AddParts -> AddContent -> Save.
|
||
//
|
||
// Key insight: WordprocessingDocument.Create() adds MainDocumentPart automatically,
|
||
// but all other parts (Styles, Settings, Numbering, Theme) must be added manually.
|
||
|
||
// --- STEP 1: CREATE THE PACKAGE ---
|
||
// The file path can be absolute or relative. WordprocessingDocumentType.Document
|
||
// is the standard choice for .docx files (vs. Template, MacroEnabled, etc.)
|
||
string outputPath = "C:\\Docs\\MyDocument.docx";
|
||
|
||
using var doc = WordprocessingDocument.Create(
|
||
outputPath, // File path
|
||
WordprocessingDocumentType.Document, // Document type enum
|
||
new DocumentOptions // Optional: AutoSave, etc.
|
||
{
|
||
AutoSave = false // true = flush changes automatically
|
||
});
|
||
|
||
// --- STEP 2: GET OR CREATE THE MAIN DOCUMENT PART ---
|
||
// When you call Create(), MainDocumentPart is automatically created and linked.
|
||
// You access it via .MainDocumentPart (not .AddMainDocumentPart, which would add
|
||
// a SECOND main part — illegal). For a fresh document, just use .MainDocumentPart.
|
||
var mainPart = doc.MainDocumentPart!;
|
||
var body = mainPart.Document.Body!; // Body is created automatically with the part
|
||
|
||
// --- STEP 3: ADD ADDITIONAL PARTS ---
|
||
// These are OPTIONAL but recommended for a complete document:
|
||
// - StyleDefinitionsPart: required for styles
|
||
// - NumberingDefinitionsPart: required for bullets/numbers
|
||
// - DocumentSettingsPart: zoom, proof state, tab stops, compatibility
|
||
// - ThemePart: color/theme information
|
||
// Parts are created fresh and linked via relationships.
|
||
|
||
// Example: Add styles part (covered in Section 2)
|
||
var stylesPart = mainPart.AddNewPart<StyleDefinitionsPart>();
|
||
stylesPart.Styles = new Styles();
|
||
stylesPart.Styles.Save();
|
||
|
||
// Example: Add settings part (covered in 1.4)
|
||
var settingsPart = mainPart.AddNewPart<DocumentSettingsPart>();
|
||
settingsPart.Settings = new Settings();
|
||
settingsPart.Settings.Save();
|
||
|
||
// --- STEP 4: ADD CONTENT TO BODY ---
|
||
// Body accepts: Paragraph (w:p), Table (w:tbl), Structured Document Tag (w:sdt)
|
||
// Content is added in document order (no need for explicit index).
|
||
// IMPORTANT: SectionProperties (w:sectPr) MUST be the last child of body.
|
||
body.Append(new Paragraph(
|
||
new Run(new Text("Hello, World!"))));
|
||
|
||
// --- STEP 5: SET SECTION PROPERTIES (PAGE LAYOUT) ---
|
||
// sectPr defines page size, margins, headers/footers, columns, etc.
|
||
// It must be the last child of body. If missing, Word uses defaults (Letter/A4, 1" margins).
|
||
var sectPr = new SectionProperties();
|
||
|
||
// Page Size: Width/Height in DXA (1 inch = 1440 DXA)
|
||
// Letter: 12240 x 15840 DXA (8.5" x 11")
|
||
// A4: 11906 x 16838 DXA (210mm x 297mm)
|
||
sectPr.Append(new PageSize
|
||
{
|
||
Width = 12240u, // 8.5 inches
|
||
Height = 15840u // 11 inches
|
||
});
|
||
|
||
// Page Margins: all four margins in DXA
|
||
// Note: Top+Bottom margins + HeaderDistance = distance from page edge to text
|
||
sectPr.Append(new PageMargin
|
||
{
|
||
Top = 1440, // 1 inch
|
||
Bottom = 1440, // 1 inch
|
||
Left = 1440u, // 1 inch (uint required)
|
||
Right = 1440u, // 1 inch
|
||
Header = 720u, // 0.5 inch from page edge to header
|
||
Footer = 720u // 0.5 inch from page edge to footer
|
||
});
|
||
|
||
// Attach sectPr to body (must be last)
|
||
body.Append(sectPr);
|
||
|
||
// --- STEP 6: SAVE ---
|
||
// Because we use `using`, Dispose() is called automatically when the block exits.
|
||
// Dispose() saves the file. If you forget `using`, call doc.Save() explicitly.
|
||
```
|
||
|
||
### 1.2 Opening an Existing Document
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// OPENING EXISTING DOCUMENTS
|
||
// =============================================================================
|
||
// Open() has multiple overloads:
|
||
// 1. Open(string path, bool isEditable, AutoSave)
|
||
// 2. Open(Stream, bool isEditable, AutoSave)
|
||
// 3. Open(string path, bool isEditable, OpenSettings)
|
||
//
|
||
// isEditable=true means open for read/write. false = read-only.
|
||
// isEditable=false is faster (shared locks avoided) but throws if file is read-only.
|
||
|
||
// --- OPEN FOR EDITING (READ/WRITE) ---
|
||
string inputPath = "C:\\Docs\\Existing.docx";
|
||
using var editDoc = WordprocessingDocument.Open(
|
||
inputPath,
|
||
isEditable: true, // Required for modification
|
||
new OpenSettings
|
||
{
|
||
AutoSave = true // Automatically save on Dispose
|
||
});
|
||
|
||
var body = editDoc.MainDocumentPart!.Document.Body!;
|
||
// ... make changes ...
|
||
// No explicit Save() needed if AutoSave = true
|
||
|
||
// --- OPEN AS READ-ONLY (FASTER) ---
|
||
using var readOnlyDoc = WordprocessingDocument.Open(
|
||
inputPath,
|
||
isEditable: false, // Read-only mode
|
||
new OpenSettings
|
||
{
|
||
// MarkupDeclarationProcess options
|
||
});
|
||
|
||
// --- OPEN FROM STREAM ---
|
||
byte[] fileBytes = File.ReadAllBytes(inputPath);
|
||
using var streamDoc = WordprocessingDocument.Open(
|
||
new MemoryStream(fileBytes),
|
||
isEditable: true,
|
||
new OpenSettings { AutoSave = false });
|
||
|
||
// After editing, you MUST copy the stream back to file if AutoSave=false:
|
||
// streamDoc.MainDocumentPart.Document.Save();
|
||
// File.WriteAllBytes(outputPath, streamStream.ToArray());
|
||
|
||
// --- OPEN FROM HTTP RESPONSE (WEB SCENARIO) ---
|
||
using var httpClient = new HttpClient();
|
||
var response = await httpClient.GetAsync("https://example.com/document.docx");
|
||
using var webStream = await response.Content.ReadAsStreamAsync();
|
||
using var webDoc = WordprocessingDocument.Open(webStream, isEditable: true);
|
||
```
|
||
|
||
### 1.3 Stream-Based Creation (MemoryStream for Web)
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// STREAM-BASED DOCUMENT CREATION
|
||
// =============================================================================
|
||
// Use MemoryStream when you want to:
|
||
// 1. Generate a document in memory before sending to a client
|
||
// 2. Avoid touching the filesystem (ASP.NET Core scenarios)
|
||
// 3. Return a document from an API endpoint
|
||
//
|
||
// CRITICAL: The stream MUST be seekable when you call .Open().
|
||
// After WordprocessingDocument.Create(), the stream position is at the beginning.
|
||
// If you write to the stream BEFORE creating the document, seek to 0 first.
|
||
|
||
// --- CREATE IN MEMORY ---
|
||
MemoryStream memStream = new MemoryStream();
|
||
|
||
// Create directly on a stream (no file path involved)
|
||
using (var doc = WordprocessingDocument.Create(
|
||
memStream,
|
||
WordprocessingDocumentType.Document,
|
||
new DocumentOptions { AutoSave = false }))
|
||
{
|
||
var mainPart = doc.MainDocumentPart!;
|
||
mainPart.Document = new Document(new Body());
|
||
mainPart.Document.Body!.Append(new Paragraph(
|
||
new Run(new Text("Generated in memory"))));
|
||
mainPart.Document.Save(); // Save to the underlying stream
|
||
}
|
||
// At this point, memStream contains the complete DOCX
|
||
|
||
// --- SEND TO HTTP RESPONSE (ASP.NET Core) ---
|
||
// In an API controller:
|
||
[HttpGet("download")]
|
||
public async Task<IActionResult> DownloadDocument()
|
||
{
|
||
var memStream = new MemoryStream();
|
||
|
||
using (var doc = WordprocessingDocument.Create(
|
||
memStream,
|
||
WordprocessingDocumentType.Document))
|
||
{
|
||
var mainPart = doc.MainDocumentPart!;
|
||
mainPart.Document = new Document(new Body());
|
||
mainPart.Document.Body!.Append(new Paragraph(
|
||
new Run(new Text("Download me!"))));
|
||
mainPart.Document.Save();
|
||
}
|
||
|
||
memStream.Position = 0; // IMPORTANT: Reset position for reading
|
||
return File(memStream,
|
||
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
||
"GeneratedDocument.docx");
|
||
}
|
||
|
||
// --- CREATE FROM TEMPLATE IN MEMORY ---
|
||
// Useful for mail-merge style operations
|
||
MemoryStream templateStream = new MemoryStream();
|
||
File.WriteAllBytes("template.docx", templateStream.ToArray()); // Save a template first
|
||
|
||
using var templateSource = new MemoryStream(File.ReadAllBytes("template.docx"));
|
||
using var mergedDoc = (WordprocessingDocument)templateSource.Clone();
|
||
|
||
// Clone() creates an editable copy. Don't forget to set position:
|
||
mergedDoc.MainDocumentPart!.Document.Body!.Append(new Paragraph(
|
||
new Run(new Text("Added content"))));
|
||
```
|
||
|
||
### 1.4 Adding All Standard Parts
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// ADDING ALL STANDARD DOCUMENT PARTS
|
||
// =============================================================================
|
||
// A complete document should have:
|
||
// 1. MainDocumentPart (auto-created)
|
||
// 2. StyleDefinitionsPart
|
||
// 3. NumberingDefinitionsPart
|
||
// 4. DocumentSettingsPart
|
||
// 5. ThemePart (optional)
|
||
// 6. Custom parts (headers, footers, comments, etc.)
|
||
|
||
// --- COMPLETE SETUP METHOD ---
|
||
public static void CreateCompleteDocument(string path)
|
||
{
|
||
using var doc = WordprocessingDocument.Create(path, WordprocessingDocumentType.Document);
|
||
var mainPart = doc.MainDocumentPart!;
|
||
|
||
// Initialize document
|
||
mainPart.Document = new Document(new Body());
|
||
var body = mainPart.Document.Body!;
|
||
|
||
// Add all parts
|
||
AddStylesPart(mainPart);
|
||
AddNumberingPart(mainPart);
|
||
AddSettingsPart(mainPart);
|
||
AddThemePart(mainPart);
|
||
AddHeadersAndFooters(mainPart);
|
||
|
||
// Add sample content
|
||
AddSampleContent(body);
|
||
|
||
// Section properties MUST be last
|
||
body.Append(CreateSectionProperties());
|
||
|
||
mainPart.Document.Save();
|
||
}
|
||
|
||
// --- STYLES PART ---
|
||
// See Section 2 for detailed style creation
|
||
private static void AddStylesPart(MainDocumentPart mainPart)
|
||
{
|
||
var stylesPart = mainPart.AddNewPart<StyleDefinitionsPart>();
|
||
var styles = new Styles();
|
||
|
||
// DocDefaults: document-wide defaults for run and paragraph properties
|
||
// These apply when no explicit style or direct formatting overrides them
|
||
styles.Append(new DocDefaults(
|
||
new RunPropertiesDefault(
|
||
new RunPropertiesBaseStyle(
|
||
new RunFonts { Ascii = "Calibri", HighAnsi = "Calibri" },
|
||
new FontSize { Val = "22" }, // 22 half-points = 11pt
|
||
new FontSizeComplexScript { Val = "22" }
|
||
)
|
||
),
|
||
new ParagraphPropertiesDefault(
|
||
new ParagraphPropertiesBaseStyle(
|
||
new SpacingBetweenLines { After = "200", Line = "276", LineRule = LineSpacingRuleValues.Auto }
|
||
)
|
||
)
|
||
));
|
||
|
||
// Default Normal style
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Normal" },
|
||
new PrimaryStyle()
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Normal", Default = true });
|
||
|
||
stylesPart.Styles = styles;
|
||
stylesPart.Styles.Save();
|
||
}
|
||
|
||
// --- NUMBERING PART ---
|
||
// Required for bulleted and numbered lists
|
||
private static void AddNumberingPart(MainDocumentPart mainPart)
|
||
{
|
||
var numberingPart = mainPart.AddNewPart<NumberingDefinitionsPart>();
|
||
var numbering = new Numbering();
|
||
|
||
// AbstractNum defines the list format (bullet, number, multilevel)
|
||
// Creates a bullet list definition with 3 levels
|
||
var abstractNum = new AbstractNum { AbstractNumberId = 1 };
|
||
|
||
// Level 0: Bullet (dot)
|
||
abstractNum.Append(new Level(
|
||
new StartNumberingValue { Val = 1 },
|
||
new NumberingFormat { Val = NumberFormatValues.Bullet },
|
||
new LevelText { Val = "•" },
|
||
new LevelJustification { Val = LevelJustificationValues.Left },
|
||
new PreviousParagraphProperties(
|
||
new Indentation { Left = "720", Hanging = "360" }) // 720 DXA indent, 360 DXA hanging
|
||
)
|
||
{ LevelIndex = 0 });
|
||
|
||
// Level 1: Dash
|
||
abstractNum.Append(new Level(
|
||
new StartNumberingValue { Val = 1 },
|
||
new NumberingFormat { Val = NumberFormatValues.Bullet },
|
||
new LevelText { Val = "–" },
|
||
new LevelJustification { Val = LevelJustificationValues.Left },
|
||
new PreviousParagraphProperties(
|
||
new Indentation { Left = "1440", Hanging = "360" })
|
||
)
|
||
{ LevelIndex = 1 });
|
||
|
||
// Level 2: Circle
|
||
abstractNum.Append(new Level(
|
||
new StartNumberingValue { Val = 1 },
|
||
new NumberingFormat { Val = NumberFormatValues.Bullet },
|
||
new LevelText { Val = "◦" },
|
||
new LevelJustification { Val = LevelJustificationValues.Left },
|
||
new PreviousParagraphProperties(
|
||
new Indentation { Left = "2160", Hanging = "360" })
|
||
)
|
||
{ LevelIndex = 2 });
|
||
|
||
numbering.Append(abstractNum);
|
||
|
||
// NumberingInstance links to AbstractNum and assigns a numId
|
||
numbering.Append(new NumberingInstance(
|
||
new AbstractNumId { Val = 1 }
|
||
)
|
||
{ NumberID = 1 });
|
||
|
||
numberingPart.Numbering = numbering;
|
||
numberingPart.Numbering.Save();
|
||
}
|
||
|
||
// --- SETTINGS PART ---
|
||
// Contains document-level settings: zoom, proof state, default tab stop, etc.
|
||
private static void AddSettingsPart(MainDocumentPart mainPart)
|
||
{
|
||
var settingsPart = mainPart.AddNewPart<DocumentSettingsPart>();
|
||
var settings = new Settings();
|
||
|
||
// Zoom: document zoom percentage (default 100%)
|
||
// Val is a percentage value (e.g., "100" = 100%)
|
||
settings.Append(new Zoom { Val = "100", Percent = true, SnapToGrid = true });
|
||
|
||
// ProofState: spelling/grammar check state
|
||
// Val combines bits: 1=grammar, 2=spelling, 3=both
|
||
settings.Append(new ProofState { Val = ProofingStateValues.Clean });
|
||
|
||
// Default tab stop interval in DXA
|
||
// Word inserts tab stops every 720 DXA (0.5 inch) by default
|
||
settings.Append(new DefaultTabStop { Val = 720 });
|
||
|
||
// Character spacing control: automatically adjust character spacing
|
||
// to maintain consistent line spacing (similar to InDesign)
|
||
settings.Append(new CharacterSpacingControl { Val = CharacterSpacingValues.CompressPunctuation });
|
||
|
||
// Compatibility settings: controls how Word handles certain formatting
|
||
// to ensure compatibility with different Word versions
|
||
settings.Append(new Compatibility(
|
||
new UseFELayout(), // Use formatted East Asian layout
|
||
new UseAsianDigraphicLineBreakRules(), // CJK line breaking rules
|
||
new AllowSpaceOfSameStyleInTable(), // Table cell spacing
|
||
new DoNotUseIndentAsPercentageForTabStops(), // Legacy tab behavior
|
||
new ProportionalOtherIndents(), // Proportional indents
|
||
new LayoutTableRawTextInTable() // Raw text in layout tables
|
||
));
|
||
|
||
// Revision tracking view settings
|
||
settings.Append(new RevisionView { DocPart = false, Formatting = true, Ink = true, Markup = true });
|
||
|
||
settingsPart.Settings = settings;
|
||
settingsPart.Settings.Save();
|
||
}
|
||
|
||
// --- THEME PART ---
|
||
// Defines color scheme, font scheme, and format scheme for the document theme
|
||
private static void AddThemePart(MainDocumentPart mainPart)
|
||
{
|
||
var themePart = mainPart.AddNewPart<ThemePart>();
|
||
var theme = new Theme(
|
||
new ThemeElements(
|
||
// Color scheme: 10 predefined theme colors
|
||
new ColorScheme(
|
||
new Dark1Color(new Color { Val = "000000" }),
|
||
new Light1Color(new Color { Val = "FFFFFF" }),
|
||
new Dark2Color(new Color { Val = "1F497D" }),
|
||
new Light2Color(new Color { Val = "EEECE1" }),
|
||
new Accent1Color(new Color { Val = "4F81BD" }),
|
||
new Accent2Color(new Color { Val = "C0504D" }),
|
||
new Accent3Color(new Color { Val = "9BBB59" }),
|
||
new Accent4Color(new Color { Val = "8064A2" }),
|
||
new Accent5Color(new Color { Val = "4BACC6" }),
|
||
new Accent6Color(new Color { Val = "F79646" }),
|
||
new Hyperlink(new Color { Val = "0000FF" }),
|
||
new FollowedHyperlinkColor(new Color { Val = "800080" })
|
||
),
|
||
// Font scheme: major (headings) and minor (body) fonts
|
||
new FontScheme(
|
||
new MajorFont { Val = "Calibri Light" },
|
||
new MinorFont { Val = "Calibri" }
|
||
),
|
||
// Format scheme: default fill and effect styles
|
||
new FormatScheme(
|
||
new FillStyleList(
|
||
new FillStyle { Fill = new PatternFill { PatternType = PatternValues.Solid } }
|
||
),
|
||
new LineStyleList(
|
||
new LineStyle { Val = LineValues.Single }
|
||
)
|
||
)
|
||
),
|
||
new ThemeName { Val = "Office Theme" },
|
||
new ThemeNames(
|
||
new LanguageBasedString { Val = "en-US", LanguageId = "x-none" }
|
||
)
|
||
);
|
||
|
||
themePart.Theme = theme;
|
||
themePart.Theme.Save();
|
||
}
|
||
|
||
// --- HEADERS AND FOOTERS ---
|
||
private static void AddHeadersAndFooters(MainDocumentPart mainPart)
|
||
{
|
||
// Header
|
||
var headerPart = mainPart.AddNewPart<HeaderPart>();
|
||
headerPart.Header = new Header(
|
||
new Paragraph(
|
||
new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Right }),
|
||
new Run(
|
||
new RunProperties(
|
||
new RunFonts { Ascii = "Calibri Light", HighAnsi = "Calibri Light" },
|
||
new Italic(),
|
||
new FontSize { Val = "20" } // 10pt
|
||
),
|
||
new Text("Document Header"))
|
||
));
|
||
var headerId = mainPart.GetIdOfPart(headerPart);
|
||
|
||
// Footer
|
||
var footerPart = mainPart.AddNewPart<FooterPart>();
|
||
footerPart.Footer = new Footer(
|
||
new Paragraph(
|
||
new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center }),
|
||
new Run(new Text("Page ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.Begin }),
|
||
new Run(new FieldCode(" PAGE ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.End }),
|
||
new Run(new Text(" of ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.Begin }),
|
||
new Run(new FieldCode(" NUMPAGES ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.End })
|
||
));
|
||
var footerId = mainPart.GetIdOfPart(footerPart);
|
||
|
||
// Reference IDs in section properties
|
||
// (added in CreateSectionProperties below)
|
||
}
|
||
|
||
// --- SECTION PROPERTIES (COMPLETE) ---
|
||
private static SectionProperties CreateSectionProperties()
|
||
{
|
||
var sectPr = new SectionProperties();
|
||
|
||
// Header/Footer references (must come before page size/margins)
|
||
var mainPart = doc.MainDocumentPart; // Note: in real code, pass as parameter
|
||
sectPr.Append(new HeaderReference
|
||
{
|
||
Type = HeaderFooterValues.Default,
|
||
Id = mainPart!.GetIdOfPart(mainPart.HeaderParts.First())
|
||
});
|
||
sectPr.Append(new FooterReference
|
||
{
|
||
Type = HeaderFooterValues.Default,
|
||
Id = mainPart.GetIdOfPart(mainPart.FooterParts.First())
|
||
});
|
||
|
||
// Page size
|
||
sectPr.Append(new PageSize { Width = 12240u, Height = 15840u });
|
||
|
||
// Page margins
|
||
sectPr.Append(new PageMargin
|
||
{
|
||
Top = 1440,
|
||
Bottom = 1440,
|
||
Left = 1440u,
|
||
Right = 1440u,
|
||
Header = 720u,
|
||
Footer = 720u
|
||
});
|
||
|
||
// Page numbering format
|
||
sectPr.Append(new PageNumberType { Start = 1, Format = NumberFormatValues.Decimal });
|
||
|
||
// Column settings (default: 1 column)
|
||
sectPr.Append(new Columns { ColumnCount = 1, EqualWidth = true });
|
||
|
||
// Paper source (printer tray)
|
||
// sectPr.Append(new PaperSource { Tray = 1, Paper = 7 });
|
||
|
||
return sectPr;
|
||
}
|
||
```
|
||
|
||
### 1.5 Unit Systems Reference
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// UNIT SYSTEMS IN OPENXML
|
||
// =============================================================================
|
||
// Understanding units is critical. Wrong unit = wrong formatting.
|
||
//
|
||
// DXA (Twentieths of a DXA) - "Standard Document Unit"
|
||
// 1 DXA = 1/20th of a point
|
||
// 1 inch = 1440 DXA
|
||
// 1 cm = 567 DXA (approx)
|
||
// Used for: margins, indents, spacing, tab stops, column widths
|
||
//
|
||
// Half-Points (sz) - Font Size
|
||
// Value is in half-points (1/2 point increments)
|
||
// 24 = 12pt, 28 = 14pt, 36 = 18pt, 48 = 24pt
|
||
// Used for: FontSize.Val, FontSizeComplexScript.Val
|
||
//
|
||
// Points (pt) - Direct Measurements
|
||
// Standard typographic point (72 per inch)
|
||
// Used for: some line spacing values, border widths
|
||
//
|
||
// EMU (English Metric Units) - Drawing Objects
|
||
// 1 inch = 914400 EMU
|
||
// Used for: drawing object sizes, shapes, images
|
||
//
|
||
// STARS (Special Twips Advanced Right-Left) - CJK Indentation
|
||
// Used for: FirstLineChars, HangingChars (special FirstLine/Hanging for CJK)
|
||
// Converts character counts to DXA based on font metrics
|
||
//
|
||
// LINE SPACING SPECIAL VALUES:
|
||
// Line = "240" with LineRule = Auto = single spacing (default)
|
||
// Line = "480" with LineRule = Auto = double spacing
|
||
// Line = "360" with LineRule = Auto = 1.5 spacing
|
||
// Line = "240" with LineRule = Exact = exactly 12pt
|
||
// Line = "288" with LineRule = AtLeast = at least 14.4pt (grows with content)
|
||
|
||
// --- CONVERSION HELPER METHODS ---
|
||
public static class OpenXmlUnits
|
||
{
|
||
// DXA conversions
|
||
public static int InchesToDxa(double inches) => (int)(inches * 1440);
|
||
public static int CmToDxa(double cm) => (int)(cm * 567.0);
|
||
public static int PtToDxa(double pt) => (int)(pt * 20);
|
||
public static double DxaToInches(int dxa) => dxa / 1440.0;
|
||
public static double DxaToCm(int dxa) => dxa / 567.0;
|
||
public static double DxaToPt(int dxa) => dxa / 20.0;
|
||
|
||
// EMU conversions (for drawings)
|
||
public static long InchesToEmu(double inches) => (long)(inches * 914400);
|
||
public static long CmToEmu(double cm) => (long)(cm * 360000);
|
||
public static double EmuToInches(long emu) => emu / 914400.0;
|
||
|
||
// Half-point conversions (font sizes)
|
||
public static int PtToHalfPt(double pt) => (int)(pt * 2);
|
||
public static int FontSizeToSz(double ptSize) => (int)(ptSize * 2);
|
||
public static double SzToPt(int sz) => sz / 2.0;
|
||
|
||
// Line spacing
|
||
public static int SingleSpacing => 240;
|
||
public static int DoubleSpacing => 480;
|
||
public static int OneAndHalfSpacing => 360;
|
||
public static int LineSpacingPt(double pt) => (int)(pt * 20); // Convert to DXA
|
||
}
|
||
|
||
// Example usage:
|
||
var marginInInches = OpenXmlUnits.DxaToInches(1440); // 1.0
|
||
var fontSizeInSz = OpenXmlUnits.FontSizeToSz(12.0); // 24
|
||
var indentInDxa = OpenXmlUnits.InchesToDxa(0.5); // 720
|
||
```
|
||
|
||
---
|
||
|
||
## 2. Style System Deep Dive
|
||
|
||
### 2.1 Style Types and Structure
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// STYLE TYPES OVERVIEW
|
||
// =============================================================================
|
||
// OpenXML defines 4 style types (StyleValues enum):
|
||
// 1. Paragraph (w:p) - controls paragraph-level formatting
|
||
// 2. Character (w:r) - controls inline/run-level formatting
|
||
// 3. Table (w:tbl) - controls table-level formatting
|
||
// 4. Numbering (w:num) - NOT a style type, but a separate numbering system
|
||
//
|
||
// Key insight: A style can be BOTH paragraph and character style (linked style).
|
||
// The "linkedStyle" element links a paragraph style to a character style.
|
||
|
||
// --- MINIMAL PARAGRAPH STYLE ---
|
||
// A paragraph style controls: pPr (paragraph properties) and optionally rPr
|
||
Style minimalParaStyle = new Style(
|
||
new StyleName { Val = "MyParagraphStyle" },
|
||
new PrimaryStyle() // Primary styles appear in Style gallery
|
||
)
|
||
{
|
||
Type = StyleValues.Paragraph,
|
||
StyleId = "MyParagraphStyle"
|
||
};
|
||
|
||
// --- MINIMAL CHARACTER STYLE ---
|
||
// A character style controls: rPr only (no pPr)
|
||
Style minimalCharStyle = new Style(
|
||
new StyleName { Val = "MyCharacterStyle" },
|
||
new PrimaryStyle()
|
||
)
|
||
{
|
||
Type = StyleValues.Character,
|
||
StyleId = "MyCharacterStyle"
|
||
};
|
||
|
||
// Character style with run properties (fonts, size, bold, etc.)
|
||
Style charStyleWithFormatting = new Style(
|
||
new StyleName { Val = "Emphasis" },
|
||
new PrimaryStyle(),
|
||
new StyleRunProperties(
|
||
new Italic(),
|
||
new Color { Val = "C00000" } // Dark red
|
||
)
|
||
)
|
||
{
|
||
Type = StyleValues.Character,
|
||
StyleId = "Emphasis"
|
||
};
|
||
|
||
// --- LINKED STYLE (Paragraph + Character) ---
|
||
// A linked style combines both: it can be applied to a paragraph OR a run.
|
||
// This is how Word's "Heading 1" works — applies to paragraphs, but you can
|
||
// also select text within a heading and apply the same style as character formatting.
|
||
Style linkedStyle = new Style(
|
||
new StyleName { Val = "LinkedStyle" },
|
||
new PrimaryStyle(),
|
||
new LinkedStyle { Val = "LinkedStyleChar" }, // Links to character style
|
||
new StyleParagraphProperties(
|
||
new SpacingBetweenLines { After = "120" }
|
||
),
|
||
new StyleRunProperties(
|
||
new Bold(),
|
||
new FontSize { Val = "24" }
|
||
)
|
||
)
|
||
{
|
||
Type = StyleValues.Paragraph,
|
||
StyleId = "LinkedStyle"
|
||
};
|
||
|
||
// Corresponding character style (normally same name + "Char" suffix by convention)
|
||
Style linkedStyleChar = new Style(
|
||
new StyleName { Val = "LinkedStyle Char" }, // Word convention: adds " Char"
|
||
new PrimaryStyle(),
|
||
new StyleRunProperties(
|
||
new Bold(),
|
||
new FontSize { Val = "24" }
|
||
)
|
||
)
|
||
{
|
||
Type = StyleValues.Character,
|
||
StyleId = "LinkedStyleChar"
|
||
};
|
||
|
||
// --- TABLE STYLE ---
|
||
Style tableStyle = new Style(
|
||
new StyleName { Val = "MyTableStyle" },
|
||
new PrimaryStyle(),
|
||
new StyleTableProperties(
|
||
new TableWidth { Width = "5000", Type = TableWidthUnitValues.Pct }, // 50% width
|
||
new TableBorders(
|
||
new TopBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new BottomBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new LeftBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new RightBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new InsideHorizontalBorder { Val = BorderValues.Single, Size = 2, Color = "CCCCCC" },
|
||
new InsideVerticalBorder { Val = BorderValues.Single, Size = 2, Color = "CCCCCC" }
|
||
),
|
||
new TableCellMarginDefault(
|
||
new TopMargin { Width = "0", Type = TableWidthUnitValues.DXA },
|
||
new StartMargin { Width = "108", Type = TableWidthUnitValues.DXA },
|
||
new BottomMargin { Width = "0", Type = TableWidthUnitValues.DXA },
|
||
new EndMargin { Width = "108", Type = TableWidthUnitValues.DXA }
|
||
)
|
||
)
|
||
)
|
||
{
|
||
Type = StyleValues.Table,
|
||
StyleId = "MyTableStyle"
|
||
};
|
||
```
|
||
|
||
### 2.2 DocDefaults and Document-Wide Defaults
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// DOCDEFAULTS: DOCUMENT-WIDE DEFAULTS
|
||
// =============================================================================
|
||
// DocDefaults lives inside Styles and provides fallback values when:
|
||
// 1. No explicit style is applied
|
||
// 2. No direct formatting is applied
|
||
// It contains RunPropertiesDefault and/or ParagraphPropertiesDefault.
|
||
//
|
||
// CRITICAL: DocDefaults applies to the entire document. Any explicit style
|
||
// or direct formatting will override it.
|
||
|
||
// --- COMPLETE DOCDEFAULTS SETUP ---
|
||
var docDefaults = new DocDefaults(
|
||
// Run properties defaults: default font, size, language for all runs
|
||
new RunPropertiesDefault(
|
||
new RunPropertiesBaseStyle(
|
||
// RunFonts: which font to use for each script
|
||
// Word will fall back through these: ASCII -> HighAnsi -> EastAsia -> ComplexScript
|
||
// Always specify at minimum Ascii and HighAnsi
|
||
new RunFonts
|
||
{
|
||
Ascii = "Calibri", // Western/Latin font (primary)
|
||
HighAnsi = "Calibri", // Latin characters (often same as Ascii)
|
||
EastAsia = "SimSun", // East Asian font (CJK)
|
||
ComplexScript = "Arial", // Complex scripts (Arabic, Hebrew, Thai)
|
||
ASCIITheme = ThemeFontValues.Minor,
|
||
HighAnsiTheme = ThemeFontValues.Minor,
|
||
EastAsiaTheme = ThemeFontValues.Minor,
|
||
ComplexScriptTheme = ThemeFontValues.Minor
|
||
},
|
||
// FontSize: in HALF-POINTS (24 = 12pt, 22 = 11pt, 20 = 10pt)
|
||
new FontSize { Val = "22" }, // 11pt for body
|
||
new FontSizeComplexScript { Val = "22" },
|
||
// Languages: required for proper hyphenation and spell checking
|
||
new Languages { Val = "en-US" }, // Default language
|
||
new Languages { EastAsia = "zh-CN", Val = "en-US" } // Can set multiple
|
||
)
|
||
),
|
||
// Paragraph properties defaults: default spacing, etc.
|
||
new ParagraphPropertiesDefault(
|
||
new ParagraphPropertiesBaseStyle(
|
||
// SpacingBetweenLines: default paragraph spacing
|
||
// After = "200" = 200 DXA = 10pt after each paragraph
|
||
new SpacingBetweenLines
|
||
{
|
||
After = "200",
|
||
Line = "276",
|
||
LineRule = LineSpacingRuleValues.Auto // Auto = 1.15x line height
|
||
}
|
||
)
|
||
)
|
||
);
|
||
|
||
// --- LAYOUT LUNCTIONS (LATENT STYLES) ---
|
||
// Latent styles are hidden styles that exist in Word but aren't in styles.xml.
|
||
// They provide fast-access defaults for formatting (e.g., Normal, Heading 1-6, etc.)
|
||
// when the user hasn't explicitly customized them.
|
||
//
|
||
// DocDefaults can define LatentStyleCountOverride to adjust count,
|
||
// but true latent styles are controlled by Normal.dotm (Word's global template).
|
||
Styles CreateStylesWithDocDefaults()
|
||
{
|
||
var styles = new Styles();
|
||
|
||
// DocDefaults with run and paragraph properties defaults
|
||
styles.Append(new DocDefaults(
|
||
new RunPropertiesDefault(
|
||
new RunPropertiesBaseStyle(
|
||
new RunFonts { Ascii = "Calibri", HighAnsi = "Calibri" },
|
||
new FontSize { Val = "22" },
|
||
new Languages { Val = "en-US" }
|
||
)
|
||
),
|
||
new ParagraphPropertiesDefault(
|
||
new ParagraphPropertiesBaseStyle(
|
||
new SpacingBetweenLines { After = "160", Line = "276", LineRule = LineSpacingRuleValues.Auto }
|
||
)
|
||
)
|
||
));
|
||
|
||
// LatentStyles: override defaults for built-in latent styles
|
||
// These control Word's "fast-styles" like Heading 1-6 before they're customized
|
||
styles.Append(new LatentStyles(
|
||
new Count { Val = 159 }, // Total latent style count
|
||
new FirstLineChars { Val = 352 }, // Default first line char count
|
||
new HorizontalOverflow { Val = HorizontalOverflowValues.Overflow },
|
||
new VerticalOverflow { Val = VerticalOverflowValues.Overflow },
|
||
new KoreanSpaceAdjust { Val = true },
|
||
// Each LatentStyleException overrides ONE attribute of ONE latent style
|
||
// StyleID = the built-in style name (e.g., "Normal", "heading 1")
|
||
// Attribute: what to change (bold, italic, font, color, etc.)
|
||
// The defaults for built-in headings: font=Calibri, size=24, bold
|
||
new LatentStyleException(
|
||
new Primary烙,
|
||
new StyleName { Val = "Normal" },
|
||
new UIPriority { Val = 1 },
|
||
new PrimaryZone(),
|
||
new QuickStyle()
|
||
),
|
||
new LatentStyleException(
|
||
new Primary烙,
|
||
new StyleName { Val = "heading 1" },
|
||
new UIPriority { Val = 9 },
|
||
new PrimaryZone(),
|
||
new QuickStyle(),
|
||
new Bold(),
|
||
new BoldComplexScript(),
|
||
new FontSize { Val = "48" }, // 24pt = 48 half-pts
|
||
new FontSizeComplexScript { Val = "48" }
|
||
)
|
||
));
|
||
|
||
return styles;
|
||
}
|
||
```
|
||
|
||
### 2.3 Complete Heading Styles Hierarchy
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// HEADING STYLES WITH PROPER INHERITANCE CHAIN
|
||
// =============================================================================
|
||
// Word's built-in heading system uses style inheritance:
|
||
// Normal (base) -> Heading1 -> Heading2 -> Heading3 -> Heading4 -> Heading5 -> Heading6
|
||
//
|
||
// Why this matters:
|
||
// - Each heading INHERITS from its parent (basedOn)
|
||
// - Define common properties in Normal, override in each heading
|
||
// - Change body font once in Normal, all headings inherit it
|
||
// - Heading-specific properties override as needed
|
||
|
||
// --- HEADING STYLE FACTORY ---
|
||
public static Style CreateHeadingStyle(int level, FontConfig fonts)
|
||
{
|
||
// Validate level (1-9 are valid, 1-6 are standard)
|
||
if (level < 1 || level > 9)
|
||
throw new ArgumentOutOfRangeException(nameof(level));
|
||
|
||
double[] headingSizes = [26.0, 20.0, 16.0, 14.0, 12.0, 11.0, 11.0, 11.0, 11.0];
|
||
string[] outlineLevels = ["0", "1", "2", "3", "4", "5", "6", "7", "8"};
|
||
|
||
var style = new Style(
|
||
new StyleName { Val = $"heading {level}" }, // Display name
|
||
new BasedOn { Val = level == 1 ? "Normal" : $"Heading{level - 1}" }, // Parent style
|
||
new NextParagraphStyle { Val = "Normal" }, // After heading -> Normal
|
||
new PrimaryStyle(), // Show in Styles gallery
|
||
new UIPriority { Val = 9 - level }, // Priority in gallery (H1 = 8, H2 = 7, etc.)
|
||
new QuickStyle(), // Appears in Quick Styles gallery
|
||
// Paragraph properties: spacing, keep options, outline level
|
||
new StyleParagraphProperties(
|
||
new KeepNext(), // Keep heading with next paragraph
|
||
new KeepLines(), // Keep all lines of heading together
|
||
new SpacingBetweenLines // Spacing before/after
|
||
{
|
||
Before = level == 1 ? "480" : "240", // H1 = 240pt before, others = 120pt
|
||
After = "120"
|
||
},
|
||
new OutlineLevel { Val = level - 1 } // 0-indexed for H1=0, H2=1, etc.
|
||
),
|
||
// Run properties: font, size, bold
|
||
new StyleRunProperties(
|
||
new RunFonts
|
||
{
|
||
Ascii = fonts.HeadingFont,
|
||
HighAnsi = fonts.HeadingFont,
|
||
EastAsia = "SimHei" // Bold heading font for CJK
|
||
},
|
||
new FontSize { Val = UnitConverter.FontSizeToSz(headingSizes[level - 1]) },
|
||
new FontSizeComplexScript { Val = UnitConverter.FontSizeToSz(headingSizes[level - 1]) },
|
||
new Bold(),
|
||
new BoldComplexScript()
|
||
)
|
||
)
|
||
{
|
||
Type = StyleValues.Paragraph,
|
||
StyleId = $"Heading{level}"
|
||
};
|
||
|
||
return style;
|
||
}
|
||
|
||
// --- ADD ALL HEADING STYLES TO STYLES COLLECTION ---
|
||
public static void AddHeadingStyles(Styles styles, FontConfig fonts)
|
||
{
|
||
for (int i = 1; i <= 6; i++)
|
||
{
|
||
styles.Append(CreateHeadingStyle(i, fonts));
|
||
}
|
||
|
||
// Also add Heading 7-9 (valid in Word, less commonly used)
|
||
for (int i = 7; i <= 9; i++)
|
||
{
|
||
styles.Append(CreateHeadingStyle(i, fonts));
|
||
}
|
||
}
|
||
|
||
// --- HEADING STYLES INHERITANCE VISUALIZATION ---
|
||
// When you apply "Heading2" (basedOn="Heading1"):
|
||
//
|
||
// Normal style:
|
||
// - Font: Calibri 11pt
|
||
// - Spacing: 0 before, 200 after
|
||
// - No bold
|
||
//
|
||
// Heading1 (basedOn="Normal"):
|
||
// - Inherits: Calibri 11pt
|
||
// - Overrides: Calibri Light 26pt, Bold, Spacing 480 before/120 after
|
||
// - Adds: KeepNext, KeepLines, OutlineLevel=0
|
||
//
|
||
// Heading2 (basedOn="Heading1"):
|
||
// - Inherits: Calibri Light 26pt, Bold, KeepNext, KeepLines
|
||
// - Overrides: 20pt
|
||
// - Inherits: OutlineLevel=1
|
||
//
|
||
// Effective result: Heading2 = Calibri Light 20pt Bold, KeepNext+KeepLines, 480/120 spacing, OL=1
|
||
```
|
||
|
||
### 2.4 Style Inheritance Chain Resolution
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// STYLE INHERITANCE RESOLUTION
|
||
// =============================================================================
|
||
// OpenXML styles resolve properties through the basedOn chain at RENDER TIME.
|
||
// The document.xml stores only the styleId, not the resolved properties.
|
||
// Word (or this library) walks the chain at load/display time.
|
||
//
|
||
// Example: Applying "Heading2" to a paragraph
|
||
//
|
||
// 1. Start with Heading2 style definition
|
||
// 2. Walk basedOn chain: Heading2 -> Heading1 -> Normal -> (null)
|
||
// 3. Collect properties in reverse order (most generic first):
|
||
// a. Normal: Ascii=Calibri, sz=22, no bold
|
||
// b. Heading1: Ascii=Calibri Light, sz=48, bold (override Calibri, sz, bold)
|
||
// c. Heading2: sz=40 (override sz only)
|
||
// 4. Final resolved style: Ascii=Calibri Light, sz=40, bold (bold from H1)
|
||
//
|
||
// IMPORTANT: Style override is COMPLETE for each element type:
|
||
// - If Normal has rPr with Fonts, and Heading1 has pPr only,
|
||
// Heading1 still inherits Normal's rPr fully.
|
||
// - StyleRunProperties (rPr) and StyleParagraphProperties (pPr) are separate.
|
||
|
||
// --- RESOLVING STYLE PROPERTIES MANUALLY ---
|
||
// For debugging or custom rendering, you may need to resolve style chains
|
||
public static class StyleResolver
|
||
{
|
||
public record ResolvedStyle(
|
||
StyleName? Name,
|
||
RunProperties? RunProps,
|
||
ParagraphProperties? ParaProps,
|
||
string? BasedOn,
|
||
string Type);
|
||
|
||
public static ResolvedStyle Resolve(Styles styles, string styleId)
|
||
{
|
||
var styleMap = styles.Elements<Style>().ToDictionary(s => s.StyleId?.Value ?? "");
|
||
|
||
var resolvedRpr = new List<RunProperties>();
|
||
var resolvedPpr = new List<ParagraphProperties>();
|
||
string? currentId = styleId;
|
||
string? name = null;
|
||
string type = "paragraph";
|
||
|
||
// Walk the chain
|
||
while (currentId != null && styleMap.TryGetValue(currentId, out var style))
|
||
{
|
||
name ??= style.Name?.Val?.Value;
|
||
type = style.Type?.Value?.ToString() ?? "paragraph";
|
||
|
||
// Collect rPr (style-level run properties)
|
||
var rpr = style.StyleRunProperties;
|
||
if (rpr != null) resolvedRpr.Add(rpr);
|
||
|
||
// Collect pPr (style-level paragraph properties)
|
||
var ppr = style.StyleParagraphProperties;
|
||
if (ppr != null) resolvedPpr.Add(ppr);
|
||
|
||
// Move to parent
|
||
currentId = style.BasedOn?.Val?.Value;
|
||
}
|
||
|
||
// Merge in reverse order (base styles first, derived last)
|
||
// This is a simplified merge — real Word merging is more complex
|
||
var mergedRpr = MergeRunProperties(resolvedRpr);
|
||
var mergedPpr = MergeParagraphProperties(resolvedPpr);
|
||
|
||
return new ResolvedStyle(
|
||
name != null ? new StyleName { Val = name } : null,
|
||
mergedRpr,
|
||
mergedPpr,
|
||
styleId,
|
||
type);
|
||
}
|
||
|
||
private static RunProperties MergeRunProperties(List<RunProperties> chain)
|
||
{
|
||
var merged = new RunProperties();
|
||
// In real implementation, copy each child element from chain[0] first,
|
||
// then chain[1], etc., overriding as you go
|
||
foreach (var rpr in chain)
|
||
{
|
||
foreach (var child in rpr.ChildElements)
|
||
{
|
||
// Skip duplicates, keep derived class's version
|
||
merged.RemoveAll(child.GetType());
|
||
merged.Append(child.CloneNode(true));
|
||
}
|
||
}
|
||
return merged;
|
||
}
|
||
|
||
private static ParagraphProperties MergeParagraphProperties(List<ParagraphProperties> chain)
|
||
{
|
||
var merged = new ParagraphProperties();
|
||
foreach (var ppr in chain)
|
||
{
|
||
foreach (var child in ppr.ChildElements)
|
||
{
|
||
merged.RemoveAll(child.GetType());
|
||
merged.Append(child.CloneNode(true));
|
||
}
|
||
}
|
||
return merged;
|
||
}
|
||
}
|
||
|
||
// --- STYLE ID VS STYLE NAME ---
|
||
// StyleId: the machine-readable identifier (used in w:pStyle val="Heading1")
|
||
// StyleName.Val: the display name shown in Word UI ("Heading 1")
|
||
//
|
||
// Word allows StyleId="Heading1" with StyleName.Val="Custom Heading One"
|
||
// The Id must be unique within the document; the Name can duplicate others.
|
||
//
|
||
// Built-in styles use specific Ids:
|
||
// "Normal", "Heading1"-"Heading9", "Title", "Subtitle", "Quote", "Quote1",
|
||
// "IntenseQuote", "SubtleReference", "Bibliography", "TOC1"-"TOC9", etc.
|
||
```
|
||
|
||
### 2.5 Complete Style Definitions Example
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// COMPLETE STYLE DEFINITIONS FOR A BUSINESS DOCUMENT
|
||
// =============================================================================
|
||
// This creates a complete styles.xml with all recommended styles for a
|
||
// professional document: Normal, Title, Subtitle, Headings 1-6, Quote,
|
||
// IntenseQuote, and linked character styles.
|
||
|
||
public static Styles CreateBusinessDocumentStyles()
|
||
{
|
||
var styles = new Styles();
|
||
|
||
// --- DOCDEFAULTS ---
|
||
styles.Append(new DocDefaults(
|
||
new RunPropertiesDefault(
|
||
new RunPropertiesBaseStyle(
|
||
new RunFonts { Ascii = "Calibri", HighAnsi = "Calibri" },
|
||
new FontSize { Val = "22" },
|
||
new FontSizeComplexScript { Val = "22" },
|
||
new Languages { Val = "en-US" }
|
||
)
|
||
),
|
||
new ParagraphPropertiesDefault(
|
||
new ParagraphPropertiesBaseStyle(
|
||
new SpacingBetweenLines { After = "200", Line = "276", LineRule = LineSpacingRuleValues.Auto }
|
||
)
|
||
)
|
||
));
|
||
|
||
// --- NORMAL STYLE (BASE FOR ALL) ---
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new UIPriority { Val = 10 },
|
||
new Primary烙,
|
||
new StyleRunProperties(
|
||
new RunFonts { Ascii = "Calibri", HighAnsi = "Calibri" },
|
||
new FontSize { Val = "22" },
|
||
new FontSizeComplexScript { Val = "22" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Normal", Default = true });
|
||
|
||
// --- TITLE STYLE ---
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Title" },
|
||
new BasedOn { Val = "Normal" },
|
||
new NextParagraphStyle { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new UIPriority { Val = 1 },
|
||
new QuickStyle(),
|
||
new StyleParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center },
|
||
new SpacingBetweenLines { After = "300", Line = "240", LineRule = LineSpacingRuleValues.Auto },
|
||
new KeepNext(),
|
||
new KeepLines()
|
||
),
|
||
new StyleRunProperties(
|
||
new RunFonts { Ascii = "Calibri Light", HighAnsi = "Calibri Light" },
|
||
new FontSize { Val = "56" }, // 28pt
|
||
new FontSizeComplexScript { Val = "56" },
|
||
new Bold(),
|
||
new BoldComplexScript(),
|
||
new Color { Val = "1F497D" } // Dark blue
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Title" });
|
||
|
||
// --- SUBTITLE STYLE ---
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Subtitle" },
|
||
new BasedOn { Val = "Normal" },
|
||
new NextParagraphStyle { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new UIPriority { Val = 2 },
|
||
new QuickStyle(),
|
||
new StyleParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center },
|
||
new SpacingBetweenLines { After = "200" },
|
||
new KeepNext(),
|
||
new KeepLines()
|
||
),
|
||
new StyleRunProperties(
|
||
new RunFonts { Ascii = "Calibri", HighAnsi = "Calibri" },
|
||
new FontSize { Val = "26" }, // 13pt
|
||
new Color { Val = "5A5A5A" } // Gray
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Subtitle" });
|
||
|
||
// --- HEADING 1-6 STYLES ---
|
||
AddHeadingStyles(styles);
|
||
|
||
// --- QUOTE STYLES ---
|
||
// Quote (indented, italic)
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Quote" },
|
||
new BasedOn { Val = "Normal" },
|
||
new NextParagraphStyle { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new UIPriority { Val = 29 },
|
||
new QuickStyle(),
|
||
new StyleParagraphProperties(
|
||
new Justification { Val = JustificationValues.Both },
|
||
new Indentation { Left = "720", Right = "720" },
|
||
new SpacingBetweenLines { After = "160" },
|
||
new KeepNext(),
|
||
new KeepLines()
|
||
),
|
||
new StyleRunProperties(
|
||
new Italic(),
|
||
new ItalicComplexScript()
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Quote" });
|
||
|
||
// Intense Quote (bold, larger indent)
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Intense Quote" },
|
||
new BasedOn { Val = "Normal" },
|
||
new NextParagraphStyle { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new UIPriority { Val = 30 },
|
||
new QuickStyle(),
|
||
new StyleParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center },
|
||
new Indentation { Left = "1440", Right = "1440" },
|
||
new SpacingBetweenLines { After = "160" },
|
||
new KeepNext(),
|
||
new KeepLines(),
|
||
new ParagraphBorders(
|
||
new LeftBorder { Val = BorderValues.Single, Size = 24, Color = "4472C4", Space = 4 }
|
||
)
|
||
),
|
||
new StyleRunProperties(
|
||
new Bold(),
|
||
new Color { Val = "2F5496" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "IntenseQuote" });
|
||
|
||
// --- LINKED CHARACTER STYLES ---
|
||
// "Emphasis" linked character style (used for <Ctrl+E> in Word)
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Emphasis" },
|
||
new PrimaryStyle(),
|
||
new StyleRunProperties(
|
||
new Italic()
|
||
)
|
||
)
|
||
{ Type = StyleValues.Character, StyleId = "Emphasis", Default = true });
|
||
|
||
// "Strong" linked character style
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Strong" },
|
||
new PrimaryStyle(),
|
||
new StyleRunProperties(
|
||
new Bold()
|
||
)
|
||
)
|
||
{ Type = StyleValues.Character, StyleId = "Strong", Default = true });
|
||
|
||
// --- TOC STYLES (for Table of Contents) ---
|
||
// TOC1-TOC9 are used by Word's TOC field for different heading levels
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "TOC 1" },
|
||
new BasedOn { Val = "Normal" },
|
||
new Primary烙,
|
||
new StyleParagraphProperties(
|
||
new SpacingBetweenLines { After = "0" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "TOC1" });
|
||
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "TOC 2" },
|
||
new BasedOn { Val = "Normal" },
|
||
new Primary烙,
|
||
new StyleParagraphProperties(
|
||
new Indentation { Left = "220" },
|
||
new SpacingBetweenLines { After = "0" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "TOC2" });
|
||
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "TOC 3" },
|
||
new BasedOn { Val = "Normal" },
|
||
new Primary烙,
|
||
new StyleParagraphProperties(
|
||
new Indentation { Left = "440" },
|
||
new SpacingBetweenLines { After = "0" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "TOC3" });
|
||
|
||
return styles;
|
||
}
|
||
|
||
// --- ADDING STYLES TO A DOCUMENT ---
|
||
public static void AddStylesToDocument(WordprocessingDocument doc, Styles styles)
|
||
{
|
||
var mainPart = doc.MainDocumentPart!;
|
||
|
||
// Get existing or create new styles part
|
||
var stylesPart = mainPart.StyleDefinitionsPart;
|
||
if (stylesPart == null)
|
||
{
|
||
stylesPart = mainPart.AddNewPart<StyleDefinitionsPart>();
|
||
stylesPart.Styles = styles;
|
||
}
|
||
else
|
||
{
|
||
// Clear and replace existing styles
|
||
stylesPart.Styles?.RemoveAllChildren();
|
||
stylesPart.Styles = styles;
|
||
}
|
||
stylesPart.Styles.Save();
|
||
}
|
||
```
|
||
|
||
### 2.6 Importing Styles from Another Document
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// IMPORTING STYLES FROM ANOTHER DOCUMENT
|
||
// =============================================================================
|
||
// Word's Organizer functionality allows copying styles between documents.
|
||
// This is useful for templates, branding, or style normalization.
|
||
|
||
public static class StyleImporter
|
||
{
|
||
/// <summary>
|
||
/// Imports styles from a source document into a target document.
|
||
/// Can selectively import by type or name.
|
||
/// </summary>
|
||
public static void ImportStyles(
|
||
WordprocessingDocument targetDoc,
|
||
string sourcePath,
|
||
bool overwriteExisting = false,
|
||
Func<Style, bool>? filter = null)
|
||
{
|
||
// Open source as read-only
|
||
using var sourceDoc = WordprocessingDocument.Open(sourcePath, isEditable: false);
|
||
var sourceStylesPart = sourceDoc.MainDocumentPart?.StyleDefinitionsPart;
|
||
if (sourceStylesPart?.Styles == null) return;
|
||
|
||
var targetStylesPart = targetDoc.MainDocumentPart!.StyleDefinitionsPart;
|
||
if (targetStylesPart == null)
|
||
{
|
||
targetStylesPart = targetDoc.MainDocumentPart.AddNewPart<StyleDefinitionsPart>();
|
||
targetStylesPart.Styles = new Styles();
|
||
}
|
||
|
||
var targetStyles = targetStylesPart.Styles!;
|
||
var existingIds = targetStyles.Elements<Style>()
|
||
.Select(s => s.StyleId?.Value ?? "")
|
||
.ToHashSet();
|
||
|
||
foreach (var sourceStyle in sourceStylesPart.Styles.Elements<Style>())
|
||
{
|
||
// Apply filter if provided
|
||
if (filter != null && !filter(sourceStyle))
|
||
continue;
|
||
|
||
var styleId = sourceStyle.StyleId?.Value ?? "";
|
||
if (string.IsNullOrEmpty(styleId)) continue;
|
||
|
||
// Skip if exists and not overwriting
|
||
if (existingIds.Contains(styleId) && !overwriteExisting)
|
||
continue;
|
||
|
||
// Clone the style (deep copy to avoid shared part issues)
|
||
var clonedStyle = (Style)sourceStyle.CloneNode(true);
|
||
|
||
// If overwriting, remove existing first
|
||
if (existingIds.Contains(styleId))
|
||
{
|
||
var existing = targetStyles.Elements<Style>()
|
||
.FirstOrDefault(s => s.StyleId?.Value == styleId);
|
||
existing?.Remove();
|
||
}
|
||
|
||
targetStyles.Append(clonedStyle);
|
||
existingIds.Add(styleId);
|
||
}
|
||
|
||
targetStylesPart.Styles.Save();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Imports only heading styles from source.
|
||
/// </summary>
|
||
public static void ImportHeadingStyles(WordprocessingDocument targetDoc, string sourcePath)
|
||
{
|
||
ImportStyles(
|
||
targetDoc,
|
||
sourcePath,
|
||
overwriteExisting: true,
|
||
filter: style => style.Name?.Val?.Value?.StartsWith("heading") == true ||
|
||
style.Name?.Val?.Value?.StartsWith("Heading") == true);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Imports all paragraph styles (not character, table, or numbering).
|
||
/// </summary>
|
||
public static void ImportParagraphStyles(WordprocessingDocument targetDoc, string sourcePath)
|
||
{
|
||
ImportStyles(
|
||
targetDoc,
|
||
sourcePath,
|
||
overwriteExisting: false,
|
||
filter: style => style.Type?.Value == StyleValues.Paragraph);
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 3. Character Formatting (RunProperties) — EXHAUSTIVE
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// RUN PROPERTIES (CHARACTER FORMATTING) — COMPLETE REFERENCE
|
||
// =============================================================================
|
||
// RunProperties (w:rPr) controls inline text formatting. It can appear in:
|
||
// 1. Style definitions (w:style/w:rPr) — applies to all text using that style
|
||
// 2. Direct formatting in runs (w:r/w:rPr) — overrides style for specific text
|
||
//
|
||
// CHILD ELEMENT ORDER (w:rPr): MUST be in this order per OpenXML schema:
|
||
// rStyle, rFonts, b, bCs, i, iCs, caps, smallCaps, strike, dstrike, vanish,
|
||
// w:webHidden, color, sz, szCs, highlight, rendition/sz, u, vertAlign, shd,
|
||
// baseTextStyle, eastAsianLayout, ligatures, bg, kern, spc, indent, snapToGrid,
|
||
// glyphs, activeXfrm, legacy, specStyle, shadow, charsetConvert, iFormat,
|
||
// w:templ
|
||
|
||
// --- MINIMAL RUN WITH FORMATTING ---
|
||
// Any run can contain RunProperties to control appearance
|
||
Paragraph minimalFormattedPara = new Paragraph(
|
||
new Run(
|
||
new RunProperties(
|
||
new Bold(),
|
||
new FontSize { Val = "28" } // 14pt (28 half-pts)
|
||
),
|
||
new Text("Bold 14pt text")
|
||
)
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.1 RUNFONTS (Ascii, HighAnsi, EastAsia, ComplexScript)
|
||
// ===========================================================================
|
||
// RunFonts has 4 font "slots" for different scripts. Word uses fallback:
|
||
// ASCII -> HighAnsi -> EastAsia -> ComplexScript
|
||
// IMPORTANT: Always set at least Ascii and HighAnsi (they're often the same).
|
||
|
||
// Basic font specification
|
||
RunProperties fonts1 = new RunProperties(
|
||
new RunFonts
|
||
{
|
||
Ascii = "Calibri", // Western European characters (primary)
|
||
HighAnsi = "Calibri", // Same as ASCII for Western docs
|
||
EastAsia = "SimSun", // Simplified Chinese / East Asian
|
||
ComplexScript = "Arial" // Arabic, Hebrew, Thai, Vietnamese
|
||
}
|
||
);
|
||
|
||
// Using theme fonts (references to theme definitions)
|
||
RunProperties themeFonts = new RunProperties(
|
||
new RunFonts
|
||
{
|
||
ASCIITheme = ThemeFontValues.Minor, // Minor font from theme (body)
|
||
HighAnsiTheme = ThemeFontValues.Minor,
|
||
EastAsiaTheme = ThemeFontValues.Major, // Major font from theme (headings)
|
||
ComplexScriptTheme = ThemeFontValues.Minor,
|
||
// When using theme, you can still override specific slots
|
||
Ascii = "Calibri", HighAnsi = "Calibri" // Override minor with explicit font
|
||
}
|
||
);
|
||
|
||
// Complex script fonts (Arabic example)
|
||
RunProperties arabicFonts = new RunProperties(
|
||
new RunFonts
|
||
{
|
||
ComplexScript = "Traditional Arabic",
|
||
// Word automatically handles Arabic shaping with complex script fonts
|
||
}
|
||
);
|
||
|
||
// East Asian with specific fallback
|
||
RunProperties cjkFonts = new RunProperties(
|
||
new RunFonts
|
||
{
|
||
Ascii = "Microsoft YaHei", // Western: Microsoft YaHei for Chinese
|
||
HighAnsi = "Microsoft YaHei",
|
||
EastAsia = "Microsoft YaHei", // East Asian: same font handles both
|
||
ComplexScript = "Microsoft YaHei"
|
||
}
|
||
);
|
||
|
||
// Font substitution hints (rarely needed, for special cases)
|
||
RunProperties hintFonts = new RunProperties(
|
||
new RunFonts
|
||
{
|
||
Ascii = "Times New Roman",
|
||
HighAnsi = "Times New Roman",
|
||
Hint = FontStringsValues.EastAsia // Hint to Word: treat as East Asian font
|
||
}
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.2 FONTSIZE (sz, szCs) — HALF-POINTS!
|
||
// ===========================================================================
|
||
// CRITICAL: w:sz stores HALF-POINTS. 24 = 12pt, 48 = 24pt.
|
||
// szCs = complex script size (for Arabic, Hebrew, etc.)
|
||
|
||
// Common font sizes
|
||
RunProperties fontSize12pt = new RunProperties(
|
||
new FontSize { Val = "24" }, // 12pt = 24 half-pts
|
||
new FontSizeComplexScript { Val = "24" }
|
||
);
|
||
|
||
RunProperties fontSize14pt = new RunProperties(
|
||
new FontSize { Val = "28" }, // 14pt
|
||
new FontSizeComplexScript { Val = "28" }
|
||
);
|
||
|
||
RunProperties fontSize18pt = new RunProperties(
|
||
new FontSize { Val = "36" }, // 18pt
|
||
new FontSizeComplexScript { Val = "36" }
|
||
);
|
||
|
||
RunProperties fontSize24pt = new RunProperties(
|
||
new FontSize { Val = "48" }, // 24pt
|
||
new FontSizeComplexScript { Val = "48" }
|
||
);
|
||
|
||
// FontSize from double (helper)
|
||
double targetPt = 11.0;
|
||
int halfPts = (int)(targetPt * 2); // 22 for 11pt
|
||
RunProperties dynamicFontSize = new RunProperties(
|
||
new FontSize { Val = halfPts.ToString() },
|
||
new FontSizeComplexScript { Val = halfPts.ToString() }
|
||
);
|
||
|
||
// Legacy font size (some documents use csSize instead)
|
||
// csSize = complex script size only
|
||
|
||
// ===========================================================================
|
||
// 3.3 BOLD (b, bCs, b, bCs)
|
||
// ===========================================================================
|
||
// b = bold for ASCII/Latin
|
||
// bCs = bold for complex script
|
||
// Both should usually be set together
|
||
|
||
RunProperties bold = new RunProperties(
|
||
new Bold(),
|
||
new BoldComplexScript() // Always include both for consistent rendering
|
||
);
|
||
|
||
// Bold with state control (on/off)
|
||
RunProperties unbold = new RunProperties(
|
||
new Bold { Val = OnOffValueValues.Off } // Explicitly turn off bold
|
||
);
|
||
|
||
// Conditional bold (for complex scripts)
|
||
// b={} with val=Off actually means "not bold" even if parent style says bold
|
||
// This is how you "unbold" in a bold context
|
||
|
||
// ===========================================================================
|
||
// 3.4 ITALIC (i, iCs)
|
||
// ===========================================================================
|
||
RunProperties italic = new RunProperties(
|
||
new Italic(),
|
||
new ItalicComplexScript()
|
||
);
|
||
|
||
RunProperties unitalic = new RunProperties(
|
||
new Italic { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// Word's "Italic" is the style. ComplexScript italic handles Arabic calligraphy etc.
|
||
|
||
// ===========================================================================
|
||
// 3.5 UNDERLINE (u)
|
||
// ===========================================================================
|
||
// UnderlineValues enum has MANY options:
|
||
// Single, Double, Thick, Wave, Dash, Dotted, DashDot, DashDotDot,
|
||
// SingleAccounting, DoubleAccounting, TriWave, Nasized, DotDash, DotDotDash,
|
||
// LongDash, ThickDash, LongDashDot, ThickLongDash, ThickDashDot, ThickDashDotDot
|
||
|
||
// Single underline (most common)
|
||
RunProperties underlineSingle = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Single }
|
||
);
|
||
|
||
// Double underline (often for edits/changes)
|
||
RunProperties underlineDouble = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Double }
|
||
);
|
||
|
||
// Thick single underline
|
||
RunProperties underlineThick = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Thick }
|
||
);
|
||
|
||
// Wave underline (often used for spelling errors in red)
|
||
RunProperties underlineWave = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Wave }
|
||
);
|
||
|
||
// Dotted underline
|
||
RunProperties underlineDotted = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Dotted }
|
||
);
|
||
|
||
// Dashed underline
|
||
RunProperties underlineDashed = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Dash }
|
||
);
|
||
|
||
// Dash-dot underline
|
||
RunProperties underlineDashDot = new RunProperties(
|
||
new Underline { Val = UnderlineValues.DotDash }
|
||
);
|
||
|
||
// Accounting double underline (extends to both sides like accounting)
|
||
RunProperties underlineAccounting = new RunProperties(
|
||
new Underline { Val = UnderlineValues.DoubleAccounting }
|
||
);
|
||
|
||
// With color specification
|
||
RunProperties underlineColored = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Single, Color = "FF0000" } // Red underline
|
||
);
|
||
|
||
// Without color (color="auto" = black)
|
||
// With specific color using hex
|
||
RunProperties underlineBlue = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Single, Color = "0000FF" }
|
||
);
|
||
|
||
// Theme color on underline
|
||
RunProperties underlineThemeColor = new RunProperties(
|
||
new Underline
|
||
{
|
||
Val = UnderlineValues.Single,
|
||
Color = "auto", // or omit for auto/black
|
||
ThemeColor = ThemeColorValues.Accent1,
|
||
ThemeTint = "99" // 60% opacity (hex 99 = 153/255 ≈ 60%)
|
||
}
|
||
);
|
||
|
||
// Turn off underline (in a underlined context)
|
||
RunProperties noUnderline = new RunProperties(
|
||
new Underline { Val = UnderlineValues.None }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.6 COLOR (color)
|
||
// ===========================================================================
|
||
// Color.Val is a 6-digit hex color (RRGGBB) WITHOUT the #
|
||
// Word also supports 8-digit (AARRGGBB) for transparency
|
||
|
||
// Basic color
|
||
RunProperties redText = new RunProperties(
|
||
new Color { Val = "FF0000" } // Pure red
|
||
);
|
||
|
||
RunProperties blueText = new RunProperties(
|
||
new Color { Val = "0070C0" } // Office blue
|
||
);
|
||
|
||
// Theme colors (references to document theme)
|
||
RunProperties themeColorText = new RunProperties(
|
||
new Color
|
||
{
|
||
Val = "FFFFFF", // Fallback
|
||
ThemeColor = ThemeColorValues.Accent1,
|
||
ThemeShade = "BF", // 75% darker (hex BF = 191/255 ≈ 75%)
|
||
ThemeTint = "99" // 60% lighter (hex 99 = 153/255 ≈ 60%)
|
||
}
|
||
);
|
||
|
||
// Theme color shorthand
|
||
RunProperties accent1Text = new RunProperties(
|
||
new Color { Val = "4472C4" } // Direct hex is often simpler
|
||
);
|
||
|
||
// With transparency (alpha channel, 8-digit hex)
|
||
// AA=fully transparent, FF=fully opaque
|
||
RunProperties transparentText = new RunProperties(
|
||
new Color { Val = "80FF0000" } // 50% transparent red (AA=half, FF=red)
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.7 HIGHLIGHT (highlight)
|
||
// ===========================================================================
|
||
// Highlight is a BACKGROUND color applied to the entire run.
|
||
// Different from Shading (which is in run properties too).
|
||
// Highlight enum values: DarkYellow, Yellow, Green, Cyan, Magenta, Blue,
|
||
// DarkBlue, DarkCyan, DarkGreen, DarkMagenta, DarkRed, DarkYellow, LightGray,
|
||
// LightGreen, LightOrange, LightPurple, LightRed, LightYellow, Navy, None,
|
||
// Orange, Pink, Purple, Red, Teal, Turquoise, Yellow
|
||
|
||
// Yellow highlight (default for comments)
|
||
RunProperties yellowHighlight = new RunProperties(
|
||
new Highlight { Val = HighlightValues.Yellow }
|
||
);
|
||
|
||
// Green highlight (for insertions)
|
||
RunProperties greenHighlight = new RunProperties(
|
||
new Highlight { Val = HighlightValues.Green }
|
||
);
|
||
|
||
// Red highlight (for deletions)
|
||
RunProperties redHighlight = new RunProperties(
|
||
new Highlight { Val = HighlightValues.Red }
|
||
);
|
||
|
||
// Blue highlight
|
||
RunProperties blueHighlight = new RunProperties(
|
||
new Highlight { Val = HighlightValues.Blue }
|
||
);
|
||
|
||
// Cyan highlight (for feedback)
|
||
RunProperties cyanHighlight = new RunProperties(
|
||
new Highlight { Val = HighlightValues.Cyan }
|
||
);
|
||
|
||
// Gray highlight (for search)
|
||
RunProperties grayHighlight = new RunProperties(
|
||
new Highlight { Val = HighlightValues.LightGray }
|
||
);
|
||
|
||
// No highlight (turn off)
|
||
RunProperties noHighlight = new RunProperties(
|
||
new Highlight { Val = HighlightValues.None }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.8 STRIKETHROUGH (strike, dstrike)
|
||
// ===========================================================================
|
||
// strike = single strikethrough
|
||
// dstrike = double strikethrough
|
||
|
||
// Single strikethrough (standard)
|
||
RunProperties strikethrough = new RunProperties(
|
||
new Strikethrough()
|
||
);
|
||
|
||
// Double strikethrough (often for legal/editing)
|
||
RunProperties doubleStrikethrough = new RunProperties(
|
||
new DoubleStrike()
|
||
);
|
||
|
||
// Turn off strikethrough
|
||
RunProperties noStrikethrough = new RunProperties(
|
||
new Strikethrough { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.9 SUBSCRIPT/SUPERSCRIPT (verticalAlign)
|
||
// ===========================================================================
|
||
// VerticalTextAlignment enum: Baseline (normal), Subscript, Superscript
|
||
// Subscript: lowers the text and reduces size
|
||
// Superscript: raises the text and reduces size
|
||
|
||
// Superscript (e.g., 2 in X²)
|
||
RunProperties superscript = new RunProperties(
|
||
new VerticalTextAlignment { Val = VerticalPositionValues.Superscript }
|
||
);
|
||
|
||
// Subscript (e.g., 2 in H₂O)
|
||
RunProperties subscript = new RunProperties(
|
||
new VerticalTextAlignment { Val = VerticalPositionValues.Subscript }
|
||
);
|
||
|
||
// Baseline (normal) — explicit
|
||
RunProperties baseline = new RunProperties(
|
||
new VerticalTextAlignment { Val = VerticalPositionValues.Baseline }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.10 CAPS / ALLCAPS / SMALLCAPS (caps, smallCaps)
|
||
// ===========================================================================
|
||
// caps = ALL CAPS (converts lowercase to uppercase visually)
|
||
// smallCaps = Small Caps (converts lowercase to uppercase but with smaller font)
|
||
|
||
// ALL CAPS (visual only, underlying text unchanged)
|
||
RunProperties allCaps = new RunProperties(
|
||
new Caps()
|
||
);
|
||
|
||
// Small Caps (lowercase appears as smaller uppercase letters)
|
||
RunProperties smallCaps = new RunProperties(
|
||
new SmallCaps()
|
||
);
|
||
|
||
// Both properties together (smallcaps takes precedence visually if both set)
|
||
RunProperties emphasisCaps = new RunProperties(
|
||
new SmallCaps(),
|
||
new Caps()
|
||
);
|
||
|
||
// Turn off caps
|
||
RunProperties noCaps = new RunProperties(
|
||
new Caps { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.11 SPACING / KERNING (spacing)
|
||
// ===========================================================================
|
||
// Spacing.Val is in TWIPS (1/20 of a point, same as DXA)
|
||
// Positive = add space, Negative = remove space
|
||
// Range: -240 to +240 twips typically
|
||
|
||
// Add space between characters (letter spacing / kerning)
|
||
RunProperties expandedSpacing = new RunProperties(
|
||
new Spacing
|
||
{
|
||
Val = 100, // +100 twips = +5pt of space between characters
|
||
// Space "100" = 5 points (100/20 = 5)
|
||
}
|
||
);
|
||
|
||
// Compress characters
|
||
RunProperties compressedSpacing = new RunProperties(
|
||
new Spacing
|
||
{
|
||
Val = -50, // -50 twips = -2.5pt (characters closer together)
|
||
}
|
||
);
|
||
|
||
// Normal spacing (remove any spacing adjustments)
|
||
RunProperties normalSpacing = new RunProperties(
|
||
new Spacing { Val = 0 }
|
||
);
|
||
|
||
// Combined with other properties
|
||
RunProperties spacedBold = new RunProperties(
|
||
new Spacing { Val = 50 },
|
||
new Bold()
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.12 POSITION (position) — RAISED/LOWERED TEXT
|
||
// ===========================================================================
|
||
// Position.Val is in HALF-POINTS (not DXA!)
|
||
// Positive = raise, Negative = lower
|
||
// Range: -1584 to +1584 half-pts (-792pt to +792pt!)
|
||
|
||
// Raise text 6pt (12 half-points)
|
||
RunProperties raised = new RunProperties(
|
||
new Position
|
||
{
|
||
Val = 12 // +12 half-pts = +6pt raised
|
||
}
|
||
);
|
||
|
||
// Lower text 3pt
|
||
RunProperties lowered = new RunProperties(
|
||
new Position
|
||
{
|
||
Val = -6 // -6 half-pts = -3pt lowered
|
||
}
|
||
);
|
||
|
||
// Position is often used for:
|
||
// - Footnote references
|
||
// - Baseline alignment adjustments
|
||
// - Mathematical subscripts/superscripts (though verticalAlign is better for these)
|
||
|
||
// ===========================================================================
|
||
// 3.13 TEXT EFFECTS (textEffect)
|
||
// ===========================================================================
|
||
// TextEffectValues: shimmer, blinkBackground, etc.
|
||
// These are decorative effects for special visual emphasis
|
||
|
||
// Shimmer effect (sparkle/light animation)
|
||
RunProperties shimmerEffect = new RunProperties(
|
||
new TextEffect
|
||
{
|
||
Val = TextEffectValues.Shimmer
|
||
}
|
||
);
|
||
|
||
// Blink background effect
|
||
RunProperties blinkEffect = new RunProperties(
|
||
new TextEffect
|
||
{
|
||
Val = TextEffectValues.BlinkBackground
|
||
}
|
||
);
|
||
|
||
// Anti-alias effect (smoother text rendering)
|
||
// (usually applied via document settings, not per-run)
|
||
|
||
// ===========================================================================
|
||
// 3.14 SHADING ON RUNS (shd)
|
||
// ===========================================================================
|
||
// Shading on a run applies a background color/pattern to the text background
|
||
// Different from Highlight: Shading uses pattern fills, Highlight is solid colors
|
||
|
||
// Solid fill shading (run background color)
|
||
RunProperties shadedRun = new RunProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear, // Clear = solid color
|
||
Color = "auto", // auto = no border
|
||
Fill = "FFFF00" // Yellow background
|
||
}
|
||
);
|
||
|
||
// Horizontal line pattern shading
|
||
RunProperties hLineShading = new RunProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.HorizontalLine, // Horizontal line pattern
|
||
Color = "0000FF",
|
||
Fill = "FFFF00"
|
||
}
|
||
);
|
||
|
||
// Reverse pattern (for special effects)
|
||
RunProperties reverseShading = new RunProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.ReverseDiagonalStripe,
|
||
Color = "auto",
|
||
Fill = "E0E0E0"
|
||
}
|
||
);
|
||
|
||
// Clear shading (remove)
|
||
RunProperties noShading = new RunProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Fill = "auto"
|
||
}
|
||
);
|
||
|
||
// Thatch pattern (diagonal lines, like legal document)
|
||
RunProperties thatchShading = new RunProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Thatch,
|
||
Color = "000000",
|
||
Fill = "FFFFFF"
|
||
}
|
||
);
|
||
|
||
// Common shading patterns:
|
||
// Clear, Solid, HorizStripe, VertStripe, RevDiagStripe, DiagCross, DiagStripe,
|
||
// ReverseDiagStripe, DiagHorizCross, ThinHorzStripe, ThinVertStripe,
|
||
// ThinReverseDiagStripe, ThinDiagStripe, ThinDiagHorzCross, ThickHorzStripe,
|
||
// ThickVertStripe, ThickDiagStripe, ThickDiagCross, ThickReverseDiagStripe,
|
||
// ThickDiagonalCross, Shingle, ThickSmallCheck, SmallCheck, LargeCheck,
|
||
// SmallConfetti, Confetti, Horizontal, Diagonal, BigConfetti, ZigZag
|
||
|
||
// ===========================================================================
|
||
// 3.15 RUN STYLE (rStyle) — APPLY CHARACTER STYLE
|
||
// ===========================================================================
|
||
// RunStyle applies a character style to a run
|
||
// The style must be defined in styles.xml first
|
||
|
||
// Apply character style by ID
|
||
RunProperties styledRun = new RunProperties(
|
||
new RunStyle { Val = "Emphasis" } // References a character style
|
||
);
|
||
|
||
// Combined with direct formatting (direct overrides style)
|
||
RunProperties styledWithOverride = new RunProperties(
|
||
new RunStyle { Val = "Emphasis" },
|
||
new Bold { Val = OnOffValueValues.Off } // Override: don't make it bold
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.16 BORDER ON RUNS (rPr/bdr)
|
||
// ===========================================================================
|
||
// Run borders apply a border around individual characters (rarely used)
|
||
|
||
// WordArt-style character border
|
||
RunProperties borderedRun = new RunProperties(
|
||
new CharacterBorder(
|
||
new TopBorder { Val = BorderValues.Single, Size = 4, Color = "0000FF", Space = 1 },
|
||
new BottomBorder { Val = BorderValues.Single, Size = 4, Color = "0000FF", Space = 1 },
|
||
new LeftBorder { Val = BorderValues.Single, Size = 4, Color = "0000FF", Space = 1 },
|
||
new RightBorder { Val = BorderValues.Single, Size = 4, Color = "0000FF", Space = 1 }
|
||
)
|
||
);
|
||
|
||
// Single border (typically used)
|
||
RunProperties borderTop = new RunProperties(
|
||
new CharacterBorder(
|
||
new TopBorder { Val = BorderValues.Single, Size = 8, Color = "FF0000" }
|
||
)
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.17 VANISH / HIDDEN TEXT (vanish, webHidden)
|
||
// ===========================================================================
|
||
// vanish = hidden in both UI and print (like hidden field codes)
|
||
// webHidden = hidden in web layout view
|
||
|
||
// Hidden text (doesn't appear in UI or print)
|
||
RunProperties hiddenText = new RunProperties(
|
||
new Vanish()
|
||
);
|
||
|
||
// Hidden in web view only
|
||
RunProperties webHiddenText = new RunProperties(
|
||
new WebHidden()
|
||
);
|
||
|
||
// Both combined
|
||
RunProperties hiddenBothViews = new RunProperties(
|
||
new Vanish(),
|
||
new WebHidden()
|
||
);
|
||
|
||
// Turn off hide (in a hidden context)
|
||
RunProperties visible = new RunProperties(
|
||
new Vanish { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.18 RIGHT-TO-LEFT (bidi)
|
||
// ===========================================================================
|
||
// For bidirectional text (Arabic, Hebrew)
|
||
|
||
// Right-to-left text
|
||
RunProperties rtlRun = new RunProperties(
|
||
new RightToLeftText()
|
||
);
|
||
|
||
// Normal direction
|
||
RunProperties ltrRun = new RunProperties(
|
||
new RightToLeftText { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.19 LIGATURES (ligatures)
|
||
// ===========================================================================
|
||
// Ligatures combine adjacent characters for typography (fi, fl, ff, etc.)
|
||
// Standard=0 means no ligatures, Standard=1 means common ligatures
|
||
|
||
// Standard ligatures (fi, fl, ff, ffi, ffl)
|
||
RunProperties standardLigatures = new RunProperties(
|
||
new Ligatures { Val = 1 } // Standard ligatures on
|
||
);
|
||
|
||
// No ligatures
|
||
RunProperties noLigatures = new RunProperties(
|
||
new Ligatures { Val = 0 }
|
||
);
|
||
|
||
// Historical ligatures (old-style, for fonts that support them)
|
||
RunProperties historicalLigatures = new RunProperties(
|
||
new Ligatures { Val = 2 } // Historical
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.20 COMPLEX SCRIPT PROPERTIES (cs, csBdr, csShd, etc.)
|
||
// ===========================================================================
|
||
// Complex script properties mirror the ASCII properties but for
|
||
// complex scripts (Arabic, Hebrew, Thai, etc.)
|
||
|
||
// Complex script bold
|
||
RunProperties csBold = new RunProperties(
|
||
new Bold(),
|
||
new BoldComplexScript()
|
||
);
|
||
|
||
// Complex script italic
|
||
RunProperties csItalic = new RunProperties(
|
||
new Italic(),
|
||
new ItalicComplexScript()
|
||
);
|
||
|
||
// Complex script underline
|
||
RunProperties csUnderline = new RunProperties(
|
||
new Underline { Val = UnderlineValues.Single },
|
||
new UnderlineComplexScript { Val = UnderlineValues.Single }
|
||
);
|
||
|
||
// Complex script border
|
||
RunProperties csBorder = new RunProperties(
|
||
new CharacterBorder(
|
||
new TopBorder { Val = BorderValues.Single, Size = 4, Color = "000080" }
|
||
)
|
||
);
|
||
|
||
// Complex script shading
|
||
RunProperties csShading = new RunProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Color = "auto",
|
||
Fill = "E6E6E6"
|
||
}
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.21 LANGUAGE (lang) — HYPHENATION/SPELL CHECK
|
||
// ===========================================================================
|
||
// Language determines hyphenation, spell-check dictionary, etc.
|
||
|
||
// English (US)
|
||
RunProperties enUsText = new RunProperties(
|
||
new Languages { Val = "en-US" }
|
||
);
|
||
|
||
// English (UK)
|
||
RunProperties enGbText = new RunProperties(
|
||
new Languages { Val = "en-GB" }
|
||
);
|
||
|
||
// French
|
||
RunProperties frenchText = new RunProperties(
|
||
new Languages { Val = "fr-FR" }
|
||
);
|
||
|
||
// German
|
||
RunProperties germanText = new RunProperties(
|
||
new Languages { Val = "de-DE" }
|
||
);
|
||
|
||
// Chinese (Simplified)
|
||
RunProperties chineseText = new RunProperties(
|
||
new Languages { Val = "zh-CN" }
|
||
);
|
||
|
||
// Japanese
|
||
RunProperties japaneseText = new RunProperties(
|
||
new Languages { Val = "ja-JP" }
|
||
);
|
||
|
||
// Arabic
|
||
RunProperties arabicText = new RunProperties(
|
||
new Languages { Val = "ar-SA" }
|
||
);
|
||
|
||
// Hebrew
|
||
RunProperties hebrewText = new RunProperties(
|
||
new Languages { Val = "he-IL" }
|
||
);
|
||
|
||
// No language (apply directly)
|
||
RunProperties noLangText = new RunProperties(
|
||
new Languages { Val = "" }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.22 KERNING (kern)
|
||
// ===========================================================================
|
||
// Kern adjusts character spacing based on character pairs
|
||
// Value is in hundredths of a point (100 = 1pt)
|
||
|
||
// Enable kerning
|
||
RunProperties kerning = new RunProperties(
|
||
new Kern { Val = 20 } // 20 = 0.2pt minimum kerning threshold
|
||
);
|
||
|
||
// Disable kerning
|
||
RunProperties noKerning = new RunProperties(
|
||
new Kern { Val = 0 }
|
||
);
|
||
|
||
// Standard document kerning
|
||
RunProperties standardKerning = new RunProperties(
|
||
new Kern { Val = 12 } // 12 = 0.12pt
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.23 SNAP TO GRID (snapToGrid)
|
||
// ===========================================================================
|
||
// SnapToGrid aligns characters to a document grid for consistent line spacing
|
||
|
||
// Enable snap to grid
|
||
RunProperties snapToGrid = new RunProperties(
|
||
new SnapToGrid()
|
||
);
|
||
|
||
// Disable snap to grid
|
||
RunProperties noSnapToGrid = new RunProperties(
|
||
new SnapToGrid { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.24 COMBINED RUN FORMATTING EXAMPLE
|
||
// ===========================================================================
|
||
// Complete run properties combining many options
|
||
|
||
RunProperties complexRunProps = new RunProperties(
|
||
// Style reference (should be first per schema)
|
||
new RunStyle { Val = "Emphasis" },
|
||
|
||
// Font
|
||
new RunFonts
|
||
{
|
||
Ascii = "Georgia",
|
||
HighAnsi = "Georgia",
|
||
EastAsia = "SimSun"
|
||
},
|
||
|
||
// Bold + Bold Complex Script
|
||
new Bold(),
|
||
new BoldComplexScript(),
|
||
|
||
// Italic + Italic Complex Script
|
||
new Italic(),
|
||
new ItalicComplexScript(),
|
||
|
||
// Underline
|
||
new Underline { Val = UnderlineValues.Single, Color = "000080" },
|
||
|
||
// Font size (14pt)
|
||
new FontSize { Val = "28" },
|
||
new FontSizeComplexScript { Val = "28" },
|
||
|
||
// Color
|
||
new Color { Val = "000080" }, // Navy blue
|
||
|
||
// Language
|
||
new Languages { Val = "en-US" },
|
||
|
||
// Spacing (slightly expanded)
|
||
new Spacing { Val = 50 },
|
||
|
||
// Small caps
|
||
new SmallCaps(),
|
||
|
||
// Highlight
|
||
new Highlight { Val = HighlightValues.LightGray },
|
||
|
||
// Shadow (decorative)
|
||
new Shadow()
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 3.25 APPLYING RUN PROPERTIES TO RUNS
|
||
// ===========================================================================
|
||
// RunProperties can be applied in multiple ways:
|
||
|
||
// Method 1: Inline in Run (direct formatting)
|
||
Paragraph inlineFormatting = new Paragraph(
|
||
new Run(
|
||
new RunProperties(
|
||
new Bold(),
|
||
new Color { Val = "FF0000" }
|
||
),
|
||
new Text("This is bold red text")
|
||
)
|
||
);
|
||
|
||
// Method 2: Via RunStyle (character style)
|
||
Paragraph styleFormatting = new Paragraph(
|
||
new Run(
|
||
new RunStyle { Val = "MyCharStyle" },
|
||
new Text("This uses the MyCharStyle character style")
|
||
)
|
||
);
|
||
|
||
// Method 3: Mix (direct overrides style)
|
||
Paragraph mixedFormatting = new Paragraph(
|
||
new Run(
|
||
new RunProperties(
|
||
new RunStyle { Val = "Emphasis" }, // Apply style first
|
||
new Bold { Val = OnOffValueValues.Off } // Override: unbold
|
||
),
|
||
new Text("Emphasis style but not bold")
|
||
)
|
||
);
|
||
|
||
// Method 4: Empty RunProperties to clear formatting
|
||
Paragraph clearedFormatting = new Paragraph(
|
||
new Run(
|
||
new RunProperties(
|
||
new Bold { Val = OnOffValueValues.Off },
|
||
new Italic { Val = OnOffValueValues.Off },
|
||
new Underline { Val = UnderlineValues.None },
|
||
new Color { Val = "000000" },
|
||
new FontSize { Val = "22" }
|
||
),
|
||
new Text("Manually reset to defaults")
|
||
)
|
||
);
|
||
```
|
||
|
||
---
|
||
|
||
## 4. Paragraph Formatting (ParagraphProperties) — EXHAUSTIVE
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// PARAGRAPH FORMATTING (PARAGRAPHPROPERTIES) — COMPLETE REFERENCE
|
||
// =============================================================================
|
||
// ParagraphProperties (w:pPr) controls paragraph-level formatting. It can appear in:
|
||
// 1. Style definitions (w:style/w:pPr) — applies to all paragraphs using that style
|
||
// 2. Direct formatting in paragraphs (w:p/w:pPr) — overrides style for specific paragraphs
|
||
//
|
||
// CHILD ELEMENT ORDER (w:pPr): MUST be in this order per OpenXML schema:
|
||
// pStyle, keepNext, keepLines, pageBreakBefore, widowControl, numPr, pBdr,
|
||
// shd, tabs, suppressAutoHyphens, spacing, ind, contextualSpacing,
|
||
// mirrorIndents, oMath, textDirection, textAlignment, textboxTightWrap,
|
||
// outlineLvl, divId, cnfStyle, rPr, sectPr, pPrChange
|
||
//
|
||
// CRITICAL: sectPr must be LAST child of w:body, but LAST BUT ONE in w:pPr context.
|
||
// In body, sectPr defines section properties. In pPr, sectPr defines section break before paragraph.
|
||
|
||
// ===========================================================================
|
||
// 4.1 JUSTIFICATION / ALIGNMENT (jc)
|
||
// ===========================================================================
|
||
// JustificationValues enum: Left, Center, Right, Both (Justify), Distribute,
|
||
// ThaiDistribute, Justified (same as Both in most cases)
|
||
|
||
// Left justification (default for LTR languages)
|
||
ParagraphProperties justifyLeft = new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Left }
|
||
);
|
||
|
||
// Center justification
|
||
ParagraphProperties justifyCenter = new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center }
|
||
);
|
||
|
||
// Right justification (common in Arabic/Hebrew documents)
|
||
ParagraphProperties justifyRight = new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Right }
|
||
);
|
||
|
||
// Both/Justify (stretches lines to fill width — standard for books/newspapers)
|
||
ParagraphProperties justifyBoth = new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Both }
|
||
);
|
||
|
||
// Distribute (each line individually stretched to fill — no ragging)
|
||
// Often used in Asian typography
|
||
ParagraphProperties justifyDistribute = new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Distribute }
|
||
);
|
||
|
||
// ThaiDistribute (special handling for Thai script)
|
||
ParagraphProperties justifyThaiDistribute = new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.ThaiDistribute }
|
||
);
|
||
|
||
// Center justification on a line (for titles)
|
||
Paragraph titlePara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center }
|
||
),
|
||
new Run(new Text("Centered Title"))
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.2 INDENTATION (ind)
|
||
// ===========================================================================
|
||
// All indentation values in DXA (1 inch = 1440 DXA, 1 cm ≈ 567 DXA)
|
||
// Positive = indent rightward, Negative = indent leftward
|
||
//
|
||
// Left/Right: from page edge
|
||
// FirstLine: extra indent for first line (positive = indent right, negative = outdent)
|
||
// Hanging: amount to "hang" first line (negative moves first line left of body)
|
||
// FirstLineChars: CJK-specific, specifies in character counts
|
||
|
||
// Basic left indent (1 inch from left edge)
|
||
ParagraphProperties indentLeft1Inch = new ParagraphProperties(
|
||
new Indentation { Left = "1440" } // 1440 DXA = 1 inch
|
||
);
|
||
|
||
// Left indent with hanging first line (negative FirstLine)
|
||
ParagraphProperties hangingIndent = new ParagraphProperties(
|
||
new Indentation
|
||
{
|
||
Left = "720", // Body starts 0.5 inch from left
|
||
FirstLine = "-720" // First line aligns with body start
|
||
}
|
||
);
|
||
|
||
// FirstLine positive (first line indented more than body)
|
||
ParagraphProperties firstLineIndent = new ParagraphProperties(
|
||
new Indentation
|
||
{
|
||
Left = "1440", // Body at 1 inch
|
||
FirstLine = "720" // First line at 1.5 inch (additional 0.5 inch)
|
||
}
|
||
);
|
||
|
||
// Right indent
|
||
ParagraphProperties indentRight = new ParagraphProperties(
|
||
new Indentation { Right = "1440" } // 1 inch from right edge
|
||
);
|
||
|
||
// Both left and right indent (centered block)
|
||
ParagraphProperties blockIndent = new ParagraphProperties(
|
||
new Indentation
|
||
{
|
||
Left = "1440", // 1 inch from left
|
||
Right = "1440" // 1 inch from right
|
||
}
|
||
);
|
||
|
||
// Hanging indent (classic for bibliographies, numbered lists)
|
||
// First line hangs to the left of the body
|
||
ParagraphProperties hangingIndent720 = new ParagraphProperties(
|
||
new Indentation
|
||
{
|
||
Left = "1440", // Body indent = 1 inch
|
||
Hanging = "720" // First line hangs 0.5 inch to the left of body
|
||
}
|
||
);
|
||
|
||
// Outdent (first line starts BEFORE body start)
|
||
ParagraphProperties outdent = new ParagraphProperties(
|
||
new Indentation
|
||
{
|
||
Left = "720", // Body at 0.5 inch
|
||
FirstLine = "-720" // First line at 0 (page edge)
|
||
}
|
||
);
|
||
|
||
// Line-specific: negative left indent (pull into margin)
|
||
ParagraphProperties negativeIndent = new ParagraphProperties(
|
||
new Indentation { Left = "-720" } // 0.5 inch into left margin
|
||
);
|
||
|
||
// CJK FirstLineChars (character-based first line indent)
|
||
// This converts character count to DXA based on font metrics
|
||
ParagraphProperties cjkFirstLine = new ParagraphProperties(
|
||
new Indentation
|
||
{
|
||
Left = "567", // Body at 1 cm
|
||
FirstLineChars = 200 // 2 characters extra indent (200 = 2 chars × 100)
|
||
}
|
||
);
|
||
|
||
// CJK HangingChars
|
||
ParagraphProperties cjkHanging = new ParagraphProperties(
|
||
new Indentation
|
||
{
|
||
Left = "567",
|
||
HangingChars = 100 // 1 character hanging
|
||
}
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.3 SPACING BETWEEN LINES (spacing)
|
||
// ===========================================================================
|
||
// SpacingBetweenLines has multiple attributes:
|
||
// Before: space above paragraph in DXA
|
||
// After: space below paragraph in DXA
|
||
// Line: line height (in DXA for Exact/AtLeast, or value×240 for Auto)
|
||
// LineRule: Auto (multiple of single), Exact (fixed DXA), AtLeast (minimum DXA)
|
||
//
|
||
// Special Line values for Auto:
|
||
// 240 = single spacing
|
||
// 360 = 1.5 line spacing
|
||
// 480 = double spacing
|
||
// 120 = half spacing (rare)
|
||
// For other multiples: Line = (desired spacing in points) × 20
|
||
|
||
// Space before only
|
||
ParagraphProperties spaceBefore = new ParagraphProperties(
|
||
new SpacingBetweenLines { Before = "240" } // 240 DXA = 12pt before
|
||
);
|
||
|
||
// Space after only
|
||
ParagraphProperties spaceAfter = new ParagraphProperties(
|
||
new SpacingBetweenLines { After = "200" } // 200 DXA = 10pt after
|
||
);
|
||
|
||
// Both before and after
|
||
ParagraphProperties spaceBoth = new ParagraphProperties(
|
||
new SpacingBetweenLines
|
||
{
|
||
Before = "120",
|
||
After = "120"
|
||
}
|
||
);
|
||
|
||
// SINGLE LINE SPACING (Auto rule)
|
||
ParagraphProperties singleSpacing = new ParagraphProperties(
|
||
new SpacingBetweenLines
|
||
{
|
||
Line = "240",
|
||
LineRule = LineSpacingRuleValues.Auto // 240 = 1.0× line height
|
||
}
|
||
);
|
||
|
||
// DOUBLE LINE SPACING
|
||
ParagraphProperties doubleSpacing = new ParagraphProperties(
|
||
new SpacingBetweenLines
|
||
{
|
||
Line = "480",
|
||
LineRule = LineSpacingRuleValues.Auto // 480 = 2.0× line height
|
||
}
|
||
);
|
||
|
||
// 1.5 LINE SPACING
|
||
ParagraphProperties oneAndHalfSpacing = new ParagraphProperties(
|
||
new SpacingBetweenLines
|
||
{
|
||
Line = "360",
|
||
LineRule = LineSpacingRuleValues.Auto // 360 = 1.5× line height
|
||
}
|
||
);
|
||
|
||
// EXACT LINE HEIGHT (fixed height, regardless of content)
|
||
ParagraphProperties exactLineHeight = new ParagraphProperties(
|
||
new SpacingBetweenLines
|
||
{
|
||
Line = "360", // 360 DXA = 18pt
|
||
LineRule = LineSpacingRuleValues.Exact // Exactly 18pt, even if text overflows
|
||
}
|
||
);
|
||
|
||
// AT-LEAST LINE HEIGHT (minimum, grows if needed)
|
||
ParagraphProperties atLeastLineHeight = new ParagraphProperties(
|
||
new SpacingBetweenLines
|
||
{
|
||
Line = "288", // At least 14.4pt
|
||
LineRule = LineSpacingRuleValues.AtLeast // At least 14.4pt, more if content requires
|
||
}
|
||
);
|
||
|
||
// LINE SPACING WITH SPACE BEFORE/AFTER
|
||
ParagraphProperties paragraphWithSpacing = new ParagraphProperties(
|
||
new SpacingBetweenLines
|
||
{
|
||
Before = "480", // 24pt before (for heading paragraphs)
|
||
After = "240", // 12pt after
|
||
Line = "276", // 1.15× line spacing
|
||
LineRule = LineSpacingRuleValues.Auto
|
||
}
|
||
);
|
||
|
||
// SPACE BETWEEN LINES EXPLAINED:
|
||
// LineRule = Auto:
|
||
// - Line value is a multiple of 240 (single spacing = 240)
|
||
// - Word multiplies by the font size to get actual line height
|
||
// - Example: Line="360" with 11pt font = 11pt × 1.5 = 16.5pt actual
|
||
// - Most common setting for body text
|
||
//
|
||
// LineRule = Exact:
|
||
// - Line value is in DXA directly
|
||
// - Line="360" = exactly 18pt, period
|
||
// - Text that exceeds will overflow
|
||
// - Used for fixed-height rows in tables
|
||
//
|
||
// LineRule = AtLeast:
|
||
// - Line value is minimum in DXA
|
||
// - Line="288" = at least 14.4pt, grows if text is taller
|
||
// - Used when you need minimum spacing but content varies
|
||
|
||
// ===========================================================================
|
||
// 4.4 KEEP OPTIONS (keepNext, keepLines, widowControl)
|
||
// ===========================================================================
|
||
// These control how paragraphs interact with page breaks
|
||
|
||
// KEEP NEXT: Keep this paragraph on same page as the following paragraph
|
||
// Essential for headings (don't separate heading from first paragraph)
|
||
ParagraphProperties keepWithNext = new ParagraphProperties(
|
||
new KeepNext()
|
||
);
|
||
|
||
// KEEP LINES: Keep all lines of this paragraph together (no page break inside)
|
||
// Used for: table rows, list items, or paragraphs that shouldn't split
|
||
ParagraphProperties keepLinesTogether = new ParagraphProperties(
|
||
new KeepLines()
|
||
);
|
||
|
||
// BOTH: Keep next AND keep lines together
|
||
ParagraphProperties keepBoth = new ParagraphProperties(
|
||
new KeepNext(),
|
||
new KeepLines()
|
||
);
|
||
|
||
// WIDOW CONTROL: Prevent single lines at page top/bottom (widow/orphan control)
|
||
// Default is ON in Word. Only disable if you want orphans/widows.
|
||
ParagraphProperties widowControl = new ParagraphProperties(
|
||
new WidowControl()
|
||
);
|
||
|
||
// NO WIDOW CONTROL (allow single lines at page breaks)
|
||
ParagraphProperties noWidowControl = new ParagraphProperties(
|
||
new WidowControl { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// PAGE BREAK BEFORE: Start this paragraph on a new page
|
||
ParagraphProperties pageBreakBefore = new ParagraphProperties(
|
||
new PageBreakBefore()
|
||
);
|
||
|
||
// Combined: Heading style (keep with next, keep lines, page break before)
|
||
ParagraphProperties headingProps = new ParagraphProperties(
|
||
new KeepNext(),
|
||
new KeepLines(),
|
||
new PageBreakBefore(),
|
||
new WidowControl(),
|
||
new SpacingBetweenLines { Before = "480", After = "120" }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.5 OUTLINE LEVEL (outlineLvl)
|
||
// ===========================================================================
|
||
// OutlineLevel defines the heading level for document structure (TOC, Navigation)
|
||
// Values 0-8 correspond to Heading 1 through Heading 9
|
||
// Word uses this to identify headings in the Navigation Pane
|
||
|
||
// Level 0 = Heading 1
|
||
ParagraphProperties outlineLevel1 = new ParagraphProperties(
|
||
new OutlineLevel { Val = 0 }
|
||
);
|
||
|
||
// Level 1 = Heading 2
|
||
ParagraphProperties outlineLevel2 = new ParagraphProperties(
|
||
new OutlineLevel { Val = 1 }
|
||
);
|
||
|
||
// Level 5 = Heading 6
|
||
ParagraphProperties outlineLevel6 = new ParagraphProperties(
|
||
new OutlineLevel { Val = 5 }
|
||
);
|
||
|
||
// Level 8 = last possible level
|
||
ParagraphProperties outlineLevel8 = new ParagraphProperties(
|
||
new OutlineLevel { Val = 8 }
|
||
);
|
||
|
||
// TOC integration: When you insert a TOC field, Word looks for paragraphs
|
||
// with outlineLevel to generate entries. Without outlineLevel, TOC won't
|
||
// recognize the heading.
|
||
|
||
// Heading 1 style example (combining with style reference)
|
||
Paragraph heading1 = new Paragraph(
|
||
new ParagraphProperties(
|
||
new ParagraphStyleId { Val = "Heading1" }, // Style reference
|
||
new OutlineLevel { Val = 0 } // Also set outline level directly
|
||
),
|
||
new Run(new Text("Chapter One"))
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.6 PARAGRAPH BORDERS (pBdr)
|
||
// ===========================================================================
|
||
// Paragraph borders draw lines around/adjacent to paragraphs
|
||
// Four borders: Top, Left, Bottom, Right, Between, Bar
|
||
|
||
// Simple bottom border
|
||
ParagraphProperties bottomBorder = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new BottomBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 4,
|
||
Color = "000000",
|
||
Space = 4 // Space between text and border in DXA
|
||
}
|
||
)
|
||
);
|
||
|
||
// Top border only
|
||
ParagraphProperties topBorder = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new TopBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 8,
|
||
Color = "4472C4",
|
||
Space = 4
|
||
}
|
||
)
|
||
);
|
||
|
||
// Double line bottom border (common for headings)
|
||
ParagraphProperties doubleBottomBorder = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new BottomBorder
|
||
{
|
||
Val = BorderValues.Double,
|
||
Size = 4,
|
||
Color = "000000",
|
||
Space = 4
|
||
}
|
||
)
|
||
);
|
||
|
||
// All four borders
|
||
ParagraphProperties allBorders = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new TopBorder { Val = BorderValues.Single, Size = 4, Color = "CCCCCC", Space = 1 },
|
||
new LeftBorder { Val = BorderValues.Single, Size = 4, Color = "CCCCCC", Space = 4 },
|
||
new BottomBorder { Val = BorderValues.Single, Size = 4, Color = "CCCCCC", Space = 1 },
|
||
new RightBorder { Val = BorderValues.Single, Size = 4, Color = "CCCCCC", Space = 4 }
|
||
)
|
||
);
|
||
|
||
// Between border (line between adjacent paragraphs)
|
||
// Used for paragraph groups with separator lines
|
||
ParagraphProperties withBetweenBorder = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new BetweenBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 2,
|
||
Color = "CCCCCC",
|
||
Space = 4
|
||
}
|
||
)
|
||
);
|
||
|
||
// Bar border (vertical bar on one side)
|
||
// Val can be Left or Right — a solid bar in the margin
|
||
ParagraphProperties leftBarBorder = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new BarBorder { Val = BorderValues.Left, Color = "000080", Size = 12 }
|
||
)
|
||
);
|
||
|
||
// Thick top border with color
|
||
ParagraphProperties thickTopBorder = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new TopBorder
|
||
{
|
||
Val = BorderValues.Thick,
|
||
Size = 12,
|
||
Color = "2F5496",
|
||
Space = 8
|
||
}
|
||
)
|
||
);
|
||
|
||
// Wave border (decorative)
|
||
ParagraphProperties waveBorder = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new BottomBorder
|
||
{
|
||
Val = BorderValues.Wave,
|
||
Size = 6,
|
||
Color = "FF0000",
|
||
Space = 4
|
||
}
|
||
)
|
||
);
|
||
|
||
// Border.NONE to explicitly remove borders
|
||
ParagraphProperties noBorders = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new BottomBorder { Val = BorderValues.None }
|
||
)
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.7 SHADING / BACKGROUND (shd)
|
||
// ===========================================================================
|
||
// Shading applies background color/pattern to the paragraph area
|
||
// Different from run-level highlight (which only covers the text)
|
||
|
||
// Solid color shading (paragraph background)
|
||
ParagraphProperties shadedBackground = new ParagraphProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Color = "auto",
|
||
Fill = "E6F2FF" // Light blue
|
||
}
|
||
);
|
||
|
||
// Gray shading (common for quotes, notes)
|
||
ParagraphProperties grayBackground = new ParagraphProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Color = "auto",
|
||
Fill = "F2F2F2" // Light gray
|
||
}
|
||
);
|
||
|
||
// Accent1 theme color shading
|
||
ParagraphProperties themedBackground = new ParagraphProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Color = "auto",
|
||
Fill = "D9E2F3", // Light blue accent
|
||
ThemeColor = ThemeColorValues.Accent1,
|
||
ThemeShade = "80" // 50% shade
|
||
}
|
||
);
|
||
|
||
// Pattern shading (horizontal lines)
|
||
ParagraphProperties stripedBackground = new ParagraphProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.HorizStripe,
|
||
Color = "000000",
|
||
Fill = "FFFFFF"
|
||
}
|
||
);
|
||
|
||
// Diagonal stripe shading
|
||
ParagraphProperties diagonalBackground = new ParagraphProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.ReverseDiagStripe,
|
||
Color = "auto",
|
||
Fill = "FFF2CC" // Light yellow
|
||
}
|
||
);
|
||
|
||
// Clear shading (remove background)
|
||
ParagraphProperties noBackground = new ParagraphProperties(
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Fill = "auto"
|
||
}
|
||
);
|
||
|
||
// Combined shading and border (common for callout boxes)
|
||
ParagraphProperties calloutBox = new ParagraphProperties(
|
||
new ParagraphBorders(
|
||
new LeftBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 24,
|
||
Color = "4472C4",
|
||
Space = 8
|
||
}
|
||
),
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Color = "auto",
|
||
Fill = "D9E2F3"
|
||
},
|
||
new Indentation { Left = "720" }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.8 TABS (tabs)
|
||
// ===========================================================================
|
||
// TabStops define where tab characters position text
|
||
// Each tab has: position (DXA from left margin), alignment, leader
|
||
|
||
// Single left tab at 1 inch
|
||
ParagraphProperties leftTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop { Position = 1440, Val = TabStopValues.Left }
|
||
)
|
||
);
|
||
|
||
// Multiple tabs
|
||
ParagraphProperties multipleTabs = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop { Position = 1440, Val = TabStopValues.Left }, // 1"
|
||
new TabStop { Position = 2880, Val = TabStopValues.Center }, // 2"
|
||
new TabStop { Position = 4320, Val = TabStopValues.Right }, // 3"
|
||
new TabStop { Position = 5760, Val = TabStopValues.Decimal, TabChar = '.' } // 4" decimal
|
||
)
|
||
);
|
||
|
||
// Tab with dot leader (dots connecting to tab position)
|
||
ParagraphProperties dotLeaderTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop
|
||
{
|
||
Position = 4320, // 3 inches
|
||
Val = TabStopValues.Left,
|
||
Leader = TabStopLeaderCharValues.Dot
|
||
}
|
||
)
|
||
);
|
||
|
||
// Tab with dash leader
|
||
ParagraphProperties dashLeaderTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop
|
||
{
|
||
Position = 4320,
|
||
Val = TabStopValues.Left,
|
||
Leader = TabStopLeaderCharValues.Dash
|
||
}
|
||
)
|
||
);
|
||
|
||
// Tab with underscore leader
|
||
ParagraphProperties underscoreLeaderTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop
|
||
{
|
||
Position = 4320,
|
||
Val = TabStopValues.Left,
|
||
Leader = TabStopLeaderCharValues.Underscore
|
||
}
|
||
)
|
||
);
|
||
|
||
// Tab with heavy line leader
|
||
ParagraphProperties heavyLeaderTab = new ParagraphProperties(
|
||
new TabStop
|
||
{
|
||
Position = 4320,
|
||
Val = TabStopValues.Left,
|
||
Leader = TabStopLeaderCharValues.Heavy
|
||
)
|
||
);
|
||
|
||
// Tab with middle dot leader
|
||
ParagraphProperties middleDotLeaderTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop
|
||
{
|
||
Position = 4320,
|
||
Val = TabStopValues.Left,
|
||
Leader = TabStopLeaderCharValues.MiddleDot
|
||
}
|
||
)
|
||
);
|
||
|
||
// CENTER TAB (text centered at tab position)
|
||
ParagraphProperties centerTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop { Position = 4320, Val = TabStopValues.Center }
|
||
)
|
||
);
|
||
|
||
// RIGHT TAB (text right-aligned at tab position)
|
||
ParagraphProperties rightTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop { Position = 5760, Val = TabStopValues.Right }
|
||
)
|
||
);
|
||
|
||
// DECIMAL TAB (aligns on decimal point)
|
||
ParagraphProperties decimalTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop
|
||
{
|
||
Position = 5040, // 3.5 inches
|
||
Val = TabStopValues.Decimal,
|
||
TabChar = '.' // Align on period (or specify comma for European)
|
||
}
|
||
)
|
||
);
|
||
|
||
// BAR TAB (vertical bar at tab position)
|
||
ParagraphProperties barTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop { Position = 2880, Val = TabStopValues.Bar }
|
||
)
|
||
);
|
||
|
||
// CLEAR TAB (removes inherited tab at this position)
|
||
ParagraphProperties clearTab = new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop { Position = 1440, Val = TabStopValues.Clear }
|
||
)
|
||
);
|
||
|
||
// TAB STOP LEADER VALUES (Leader property):
|
||
// None = no leader
|
||
// Dot = ....... (dots)
|
||
// Dash = ------- (dashes)
|
||
// Underscore = _______ (underscores)
|
||
// Heavy = ═══════ (heavy line)
|
||
// MiddleDot = ········ (centered dots, European style)
|
||
|
||
// ===========================================================================
|
||
// 4.9 SUPPRESS AUTO HYPHENS (suppressAutoHyphens)
|
||
// ===========================================================================
|
||
// When true, Word won't auto-hyphenate this paragraph
|
||
|
||
// Prevent auto-hyphenation
|
||
ParagraphProperties noAutoHyphens = new ParagraphProperties(
|
||
new SuppressAutoHyphens()
|
||
);
|
||
|
||
// Allow hyphenation (default) — explicit
|
||
ParagraphProperties allowAutoHyphens = new ParagraphProperties(
|
||
new SuppressAutoHyphens { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.10 NUMBERING PROPERTIES (numPr)
|
||
// ===========================================================================
|
||
// numPr links a paragraph to a numbering definition (bullets or lists)
|
||
|
||
// Simple bullet list item
|
||
Paragraph bulletItem = new Paragraph(
|
||
new ParagraphProperties(
|
||
new NumberingProperties(
|
||
new NumberingLevelReference { Val = 0 }, // Level 0 (top-level)
|
||
new NumberingId { Val = 1 } // References numbering definition
|
||
),
|
||
new Indentation { Left = "720", Hanging = "360" } // Standard hanging indent
|
||
),
|
||
new Run(new Text("First bullet item"))
|
||
);
|
||
|
||
// Numbered list item
|
||
Paragraph numberedItem = new Paragraph(
|
||
new ParagraphProperties(
|
||
new NumberingProperties(
|
||
new NumberingLevelReference { Val = 0 },
|
||
new NumberingId { Val = 2 }
|
||
),
|
||
new Indentation { Left = "720", Hanging = "360" }
|
||
),
|
||
new Run(new Text("First numbered item"))
|
||
);
|
||
|
||
// Multi-level list item (level 2)
|
||
Paragraph level2Item = new Paragraph(
|
||
new ParagraphProperties(
|
||
new NumberingProperties(
|
||
new NumberingLevelReference { Val = 2 }, // Level 2 (sub-sub-item)
|
||
new NumberingId { Val = 1 }
|
||
),
|
||
new Indentation { Left = "1440", Hanging = "360" } // Deeper indent
|
||
),
|
||
new Run(new Text("Sub-item under sub-item"))
|
||
);
|
||
|
||
// Restart numbering at this paragraph
|
||
Paragraph restartNumberedItem = new Paragraph(
|
||
new ParagraphProperties(
|
||
new NumberingProperties(
|
||
new NumberingLevelReference { Val = 0 },
|
||
new NumberingId { Val = 3 },
|
||
new NumberingRestart { Val = NumberingRestartValues.Restart } // Restart
|
||
),
|
||
new Indentation { Left = "720", Hanging = "360" }
|
||
),
|
||
new Run(new Text("Item 1 (restarted)"))
|
||
);
|
||
|
||
// Continue numbering (default)
|
||
Paragraph continueNumberedItem = new Paragraph(
|
||
new ParagraphProperties(
|
||
new NumberingProperties(
|
||
new NumberingLevelReference { Val = 0 },
|
||
new NumberingId { Val = 3 },
|
||
new NumberingRestart { Val = NumberingRestartValues.Continuous } // Continue
|
||
),
|
||
new Indentation { Left = "720", Hanging = "360" }
|
||
),
|
||
new Run(new Text("Item 4 (continued)"))
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.11 PARAGRAPH STYLE (pStyle)
|
||
// ===========================================================================
|
||
// pStyle references a paragraph style by ID
|
||
|
||
// Apply Heading1 style
|
||
ParagraphProperties styledPara = new ParagraphProperties(
|
||
new ParagraphStyleId { Val = "Heading1" }
|
||
);
|
||
|
||
// Apply custom style
|
||
ParagraphProperties customStyledPara = new ParagraphProperties(
|
||
new ParagraphStyleId { Val = "MyCustomStyle" }
|
||
);
|
||
|
||
// Default paragraph style (Normal)
|
||
ParagraphProperties normalPara = new ParagraphProperties(
|
||
new ParagraphStyleId { Val = "Normal" }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.12 BIDIRECTIONAL (BiDi, rtl)
|
||
// ===========================================================================
|
||
// BiDi enables right-to-left paragraph layout for Arabic/Hebrew
|
||
|
||
// Right-to-left paragraph
|
||
ParagraphProperties rtlParagraph = new ParagraphProperties(
|
||
new BiDi()
|
||
);
|
||
|
||
// Left-to-right (default) — explicit
|
||
ParagraphProperties ltrParagraph = new ParagraphProperties(
|
||
new BiDi { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// When BiDi is on:
|
||
// - Text flows right-to-left
|
||
// - Justification defaults to right
|
||
// - List numbering appears on the right
|
||
|
||
// ===========================================================================
|
||
// 4.13 CONTEXTUAL SPACING (contextualSpacing)
|
||
// ===========================================================================
|
||
// When true, suppresses space between paragraphs when they share the same style
|
||
// Useful for headings followed by body text within the same style
|
||
|
||
// Enable contextual spacing (suppress space between same-style paragraphs)
|
||
ParagraphProperties contextualSpacing = new ParagraphProperties(
|
||
new ContextualSpacing()
|
||
);
|
||
|
||
// Disable contextual spacing (normal space between all paragraphs)
|
||
ParagraphProperties noContextualSpacing = new ParagraphProperties(
|
||
new ContextualSpacing { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.14 MIRROR IN DENTS (mirrorIndents)
|
||
// ===========================================================================
|
||
// When enabled, Left/Right indents are mirrored for odd/even pages
|
||
// (left indent on even pages becomes right indent on odd pages)
|
||
// Used for book-style printing with binding margin
|
||
|
||
// Enable mirror indents
|
||
ParagraphProperties mirrorIndents = new ParagraphProperties(
|
||
new MirrorIndents()
|
||
);
|
||
|
||
// Disable mirror indents (default)
|
||
ParagraphProperties noMirrorIndents = new ParagraphProperties(
|
||
new MirrorIndents { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.15 TEXT DIRECTION (textDirection)
|
||
// ===========================================================================
|
||
// Controls text flow direction within the paragraph
|
||
|
||
// Left-to-right (default)
|
||
ParagraphProperties ltrTextFlow = new ParagraphProperties(
|
||
new TextDirection { Val = TextDirectionValues.LeftToRight }
|
||
);
|
||
|
||
// Right-to-left
|
||
ParagraphProperties rtlTextFlow = new ParagraphProperties(
|
||
new TextDirection { Val = TextDirectionValues.RightToLeft }
|
||
);
|
||
|
||
// Top-to-bottom (vertical, common in East Asian documents)
|
||
ParagraphProperties verticalTextFlow = new ParagraphProperties(
|
||
new TextDirection { Val = TextDirectionValues.TopToBottom }
|
||
);
|
||
|
||
// Bottom-to-top (vertical rotated 180°)
|
||
ParagraphProperties bottomToTopTextFlow = new ParagraphProperties(
|
||
new TextDirection { Val = TextDirectionValues.BottomToTop }
|
||
);
|
||
|
||
// Left-to-right rotated (90° clockwise)
|
||
ParagraphProperties leftToRightRotated = new ParagraphProperties(
|
||
new TextDirection { Val = TextDirectionValues.LeftToRightRotated }
|
||
);
|
||
|
||
// Right-to-left rotated (90° counter-clockwise)
|
||
ParagraphProperties rightToLeftRotated = new ParagraphProperties(
|
||
new TextDirection { Val = TextDirectionValues.RightToLeftRotated }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.16 SNAP TO GRID (snapToGrid)
|
||
// ===========================================================================
|
||
// Aligns paragraph to document grid for consistent vertical spacing
|
||
|
||
// Enable snap to grid
|
||
ParagraphProperties snapToGridPara = new ParagraphProperties(
|
||
new SnapToGrid()
|
||
);
|
||
|
||
// Disable snap to grid
|
||
ParagraphProperties noSnapToGridPara = new ParagraphProperties(
|
||
new SnapToGrid { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.17 TEXT ALIGNMENT (textAlignment)
|
||
// ===========================================================================
|
||
// Vertical alignment of text within a line box (rarely used)
|
||
// Default is Auto (baseline)
|
||
|
||
// Baseline alignment (default)
|
||
ParagraphProperties baselineAlign = new ParagraphProperties(
|
||
new TextAlignment { Val = VerticalTextAlignmentValues.Auto }
|
||
);
|
||
|
||
// Top alignment
|
||
ParagraphProperties topAlign = new ParagraphProperties(
|
||
new TextAlignment { Val = VerticalTextAlignmentValues.Top }
|
||
);
|
||
|
||
// Center alignment
|
||
ParagraphProperties centerVerticalAlign = new ParagraphProperties(
|
||
new TextAlignment { Val = VerticalTextAlignmentValues.Center }
|
||
);
|
||
|
||
// Bottom alignment
|
||
ParagraphProperties bottomAlign = new ParagraphProperties(
|
||
new TextAlignment { Val = VerticalTextAlignmentValues.Bottom }
|
||
);
|
||
|
||
// Baseline alignment (explicit)
|
||
ParagraphProperties baselineAlignExplicit = new ParagraphProperties(
|
||
new TextAlignment { Val = VerticalTextAlignmentValues.Baseline }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.18 DIV ID (divId)
|
||
// ===========================================================================
|
||
// Associates paragraph with a div for HTML/CSS mapping (很少使用)
|
||
// Used when importing/exporting HTML content
|
||
|
||
ParagraphProperties divIdPara = new ParagraphProperties(
|
||
new DivId { Val = "myDiv123" }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.19 CNF STYLE (cnfStyle)
|
||
// ===========================================================================
|
||
// Conditional formatting style index (used by Word for table of contents,
|
||
// styles pane grouping, etc.) — typically set automatically by Word
|
||
|
||
ParagraphProperties cnfStylePara = new ParagraphProperties(
|
||
new CnfStyle { Val = 1 } // Index into style's cnfStyle definitions
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.20 SECTION PROPERTIES IN PARAGRAPH (sectPr)
|
||
// ===========================================================================
|
||
// Section properties can appear INSIDE a paragraph to create a section break
|
||
// BEFORE that paragraph. This is how you have different page layouts
|
||
// in different parts of the document.
|
||
|
||
// Section break with continuous layout
|
||
Paragraph continuousSectionBreak = new Paragraph(
|
||
new ParagraphProperties(
|
||
new SectionProperties(
|
||
new SectionType { Val = SectionMarkValues.Continuous }
|
||
)
|
||
)
|
||
);
|
||
|
||
// Section break starting new page
|
||
Paragraph newPageSectionBreak = new Paragraph(
|
||
new ParagraphProperties(
|
||
new SectionProperties(
|
||
new SectionType { Val = SectionMarkValues.NextPage }
|
||
)
|
||
)
|
||
);
|
||
|
||
// Section break with even page
|
||
Paragraph evenPageSectionBreak = new Paragraph(
|
||
new ParagraphProperties(
|
||
new SectionProperties(
|
||
new SectionType { Val = SectionMarkValues.EvenPage }
|
||
)
|
||
)
|
||
);
|
||
|
||
// Section break with odd page
|
||
Paragraph oddPageSectionBreak = new Paragraph(
|
||
new ParagraphProperties(
|
||
new SectionProperties(
|
||
new SectionType { Val = SectionMarkValues.OddPage }
|
||
)
|
||
)
|
||
);
|
||
|
||
// Section with custom page size
|
||
Paragraph customSectionPara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new SectionProperties(
|
||
new PageSize { Width = 12240u, Height = 15840u }, // Letter
|
||
new PageMargin
|
||
{
|
||
Top = 1440,
|
||
Bottom = 1440,
|
||
Left = 1440u,
|
||
Right = 1440u
|
||
}
|
||
)
|
||
)
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.21 COMBINED PARAGRAPH FORMATTING EXAMPLE
|
||
// ===========================================================================
|
||
// Complete paragraph properties combining many options
|
||
|
||
ParagraphProperties complexParaProps = new ParagraphProperties(
|
||
// Style reference
|
||
new ParagraphStyleId { Val = "Normal" },
|
||
|
||
// Keep options
|
||
new KeepNext(),
|
||
new KeepLines(),
|
||
new WidowControl(),
|
||
|
||
// Spacing
|
||
new SpacingBetweenLines
|
||
{
|
||
Before = "240",
|
||
After = "200",
|
||
Line = "276",
|
||
LineRule = LineSpacingRuleValues.Auto
|
||
},
|
||
|
||
// Indentation
|
||
new Indentation
|
||
{
|
||
Left = "0",
|
||
Right = "0",
|
||
FirstLine = "0",
|
||
Hanging = "0"
|
||
},
|
||
|
||
// Alignment
|
||
new Justification { Val = JustificationValues.Left },
|
||
|
||
// Border (bottom line)
|
||
new ParagraphBorders(
|
||
new BottomBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 4,
|
||
Color = "CCCCCC",
|
||
Space = 4
|
||
}
|
||
),
|
||
|
||
// Shading
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Color = "auto",
|
||
Fill = "auto"
|
||
},
|
||
|
||
// Tabs
|
||
new Tabs(
|
||
new TabStop { Position = 1440, Val = TabStopValues.Left },
|
||
new TabStop { Position = 2880, Val = TabStopValues.Center, Leader = TabStopLeaderCharValues.Dot }
|
||
),
|
||
|
||
// Outline level (for TOC)
|
||
new OutlineLevel { Val = 0 },
|
||
|
||
// Bidirectional
|
||
new BiDi { Val = OnOffValueValues.Off },
|
||
|
||
// Contextual spacing
|
||
new ContextualSpacing(),
|
||
|
||
// Snap to grid
|
||
new SnapToGrid(),
|
||
|
||
// Suppress auto hyphens
|
||
new SuppressAutoHyphens { Val = OnOffValueValues.Off }
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.22 APPLYING PARAGRAPH PROPERTIES
|
||
// ===========================================================================
|
||
// ParagraphProperties can be applied in multiple ways:
|
||
|
||
// Method 1: Inline in Paragraph (direct formatting)
|
||
Paragraph inlineParaProps = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center },
|
||
new SpacingBetweenLines { After = "200" }
|
||
),
|
||
new Run(new Text("Centered paragraph with space after"))
|
||
);
|
||
|
||
// Method 2: Via ParagraphStyleId (paragraph style)
|
||
Paragraph styledParagraph = new Paragraph(
|
||
new ParagraphProperties(
|
||
new ParagraphStyleId { Val = "Heading1" }
|
||
),
|
||
new Run(new Text("This is Heading 1"))
|
||
);
|
||
|
||
// Method 3: In Style definition (style-level)
|
||
Style bodyTextStyle = new Style(
|
||
new StyleName { Val = "BodyText" },
|
||
new BasedOn { Val = "Normal" },
|
||
new StyleParagraphProperties(
|
||
new Justification { Val = JustificationValues.Both }, // Justify
|
||
new SpacingBetweenLines { After = "160", Line = "276", LineRule = LineSpacingRuleValues.Auto },
|
||
new Indentation { FirstLine = "568" } // First line indent 0.5"
|
||
),
|
||
new StyleRunProperties(
|
||
new FontSize { Val = "22" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "BodyText" };
|
||
|
||
// Method 4: Combination (style + direct overrides)
|
||
Paragraph mixedParaProps = new Paragraph(
|
||
new ParagraphProperties(
|
||
new ParagraphStyleId { Val = "BodyText" }, // Apply style
|
||
new Justification { Val = JustificationValues.Left } // Override justification
|
||
),
|
||
new Run(new Text("Body text style but left-aligned"))
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.23 COMMON PATTERNS
|
||
// ===========================================================================
|
||
// Heading paragraph (with style + keep options)
|
||
Paragraph headingPara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new ParagraphStyleId { Val = "Heading1" },
|
||
new KeepNext(),
|
||
new KeepLines(),
|
||
new SpacingBetweenLines { Before = "480", After = "120" },
|
||
new OutlineLevel { Val = 0 }
|
||
),
|
||
new Run(new Text("Chapter One"))
|
||
);
|
||
|
||
// Quote paragraph (indented, italic)
|
||
Paragraph quotePara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Indentation { Left = "1440", Right = "1440" },
|
||
new SpacingBetweenLines { Before = "240", After = "240" },
|
||
new ParagraphBorders(
|
||
new LeftBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 24,
|
||
Color = "4472C4",
|
||
Space = 8
|
||
}
|
||
)
|
||
),
|
||
new Run(
|
||
new RunProperties(new Italic()),
|
||
new Text("To be, or not to be, that is the question."))
|
||
);
|
||
|
||
// List item paragraph (hanging indent pattern)
|
||
Paragraph listItemPara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new NumberingProperties(
|
||
new NumberingLevelReference { Val = 0 },
|
||
new NumberingId { Val = 1 }
|
||
),
|
||
new Indentation { Left = "720", Hanging = "360" }
|
||
),
|
||
new Run(new Text("• List item text"))
|
||
);
|
||
|
||
// Block quote / callout (background, left border)
|
||
Paragraph blockQuotePara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Indentation { Left = "720" },
|
||
new Shading
|
||
{
|
||
Val = ShadingPatternValues.Clear,
|
||
Fill = "F5F5F5"
|
||
},
|
||
new ParagraphBorders(
|
||
new LeftBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 12,
|
||
Color = "999999",
|
||
Space = 8
|
||
}
|
||
),
|
||
new SpacingBetweenLines { Before = "120", After = "120" }
|
||
),
|
||
new Run(new Text("Block quote text"))
|
||
);
|
||
|
||
// Caption (centered, small text, below figure)
|
||
Paragraph captionPara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center },
|
||
new SpacingBetweenLines { Before = "0", After = "240" },
|
||
new ParagraphStyleId { Val = "Caption" }
|
||
),
|
||
new Run(
|
||
new RunProperties(
|
||
new FontSize { Val = "20" }, // 10pt
|
||
new Italic()
|
||
),
|
||
new Text("Figure 1: Sample caption"))
|
||
);
|
||
|
||
// Page title (large, centered, space after)
|
||
Paragraph pageTitlePara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center },
|
||
new SpacingBetweenLines { After = "480" },
|
||
new KeepLines(),
|
||
new ParagraphBorders(
|
||
new BottomBorder
|
||
{
|
||
Val = BorderValues.Single,
|
||
Size = 4,
|
||
Color = "000000",
|
||
Space = 4
|
||
}
|
||
)
|
||
),
|
||
new Run(
|
||
new RunProperties(
|
||
new FontSize { Val = "56" }, // 28pt
|
||
new Bold()
|
||
),
|
||
new Text("Document Title"))
|
||
);
|
||
|
||
// Signature line (right-aligned, with tab for signature)
|
||
Paragraph signatureLinePara = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Tabs(
|
||
new TabStop { Position = 5760, Val = TabStopValues.Right } // 4" right tab
|
||
)
|
||
),
|
||
new Run(new Text("Name: ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new TabChar()),
|
||
new Run(new Text("Date: ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new TabChar()),
|
||
new Run(new Text("Signature: ") { Space = SpaceProcessingModeValues.Preserve })
|
||
);
|
||
|
||
// Bibliography entry (hanging indent, single-spaced)
|
||
Paragraph bibliographyEntry = new Paragraph(
|
||
new ParagraphProperties(
|
||
new Indentation { Left = "720", Hanging = "720" },
|
||
new SpacingBetweenLines { Line = "240", LineRule = LineSpacingRuleValues.Auto },
|
||
new Bibliography()
|
||
),
|
||
new Run(new Text("Smith, J. (2024). The Art of OpenXML. New York: Publisher."))
|
||
);
|
||
|
||
// ===========================================================================
|
||
// 4.24 UNIT SYSTEM QUICK REFERENCE
|
||
// ===========================================================================
|
||
// DXA (Twentieths of a DXA / Twips):
|
||
// 1 inch = 1440 DXA
|
||
// 1 cm ≈ 567 DXA
|
||
// 1 pt = 20 DXA
|
||
// Used for: margins, indents, spacing, tab stops, borders
|
||
//
|
||
// Half-Points (Font Size):
|
||
// 24 = 12pt
|
||
// 22 = 11pt
|
||
// 20 = 10pt
|
||
// Used for: FontSize.Val
|
||
//
|
||
// Points (pt):
|
||
// Used for: border widths, some line spacing values
|
||
//
|
||
// EMU (English Metric Units):
|
||
// 1 inch = 914400 EMU
|
||
// Used for: drawing objects, images, shapes
|
||
//
|
||
// COMMON DXA VALUES:
|
||
// 720 = 0.5 inch
|
||
// 1440 = 1 inch
|
||
// 2160 = 1.5 inches
|
||
// 2880 = 2 inches
|
||
// 4320 = 3 inches
|
||
// 5760 = 4 inches
|
||
// 8640 = 6 inches
|
||
```
|
||
|
||
---
|
||
|
||
## Appendix A: Complete Working Example
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// COMPLETE WORKING EXAMPLE: BUSINESS REPORT
|
||
// =============================================================================
|
||
// This example demonstrates a complete, professional document with
|
||
// all concepts covered in this encyclopedia.
|
||
|
||
using DocumentFormat.OpenXml;
|
||
using DocumentFormat.OpenXml.Packaging;
|
||
using DocumentFormat.OpenXml.Wordprocessing;
|
||
|
||
namespace OpenXmlExamples;
|
||
|
||
public static class BusinessReportGenerator
|
||
{
|
||
public static void Generate(string outputPath)
|
||
{
|
||
using var doc = WordprocessingDocument.Create(
|
||
outputPath,
|
||
WordprocessingDocumentType.Document);
|
||
|
||
var mainPart = doc.MainDocumentPart!;
|
||
mainPart.Document = new Document(new Body());
|
||
var body = mainPart.Document.Body!;
|
||
|
||
// Add all parts
|
||
AddStyles(mainPart);
|
||
AddNumbering(mainPart);
|
||
AddSettings(mainPart);
|
||
AddTheme(mainPart);
|
||
AddHeadersAndFooters(mainPart);
|
||
|
||
// Add content
|
||
AddTitle(body);
|
||
AddTableOfContents(body);
|
||
AddExecutiveSummary(body);
|
||
AddSection(body, "Introduction", @"
|
||
This is the introduction section of the business report.
|
||
It contains multiple paragraphs with various formatting.");
|
||
AddSection(body, "Methodology", @"
|
||
Our methodology section describes the approach taken.
|
||
Bulleted lists are used for key points:");
|
||
AddBulletPoints(body, new[]
|
||
{
|
||
"First methodology point",
|
||
"Second methodology point",
|
||
"Third methodology point with more text to demonstrate wrapping"
|
||
});
|
||
AddSection(body, "Results", @"
|
||
The results section presents data in tables:");
|
||
AddSampleTable(body);
|
||
AddSection(body, "Conclusion", @"
|
||
In conclusion, this report demonstrates the capabilities of the OpenXML SDK.
|
||
The formatting options are comprehensive and allow for professional document generation.");
|
||
|
||
// Section properties (must be last)
|
||
body.Append(CreateSectionProperties(mainPart));
|
||
|
||
mainPart.Document.Save();
|
||
}
|
||
|
||
private static void AddStyles(MainDocumentPart mainPart)
|
||
{
|
||
var stylesPart = mainPart.AddNewPart<StyleDefinitionsPart>();
|
||
var styles = CreateBusinessStyles();
|
||
stylesPart.Styles = styles;
|
||
stylesPart.Styles.Save();
|
||
}
|
||
|
||
private static Styles CreateBusinessStyles()
|
||
{
|
||
var styles = new Styles();
|
||
|
||
// DocDefaults
|
||
styles.Append(new DocDefaults(
|
||
new RunPropertiesDefault(
|
||
new RunPropertiesBaseStyle(
|
||
new RunFonts { Ascii = "Calibri", HighAnsi = "Calibri" },
|
||
new FontSize { Val = "22" },
|
||
new FontSizeComplexScript { Val = "22" },
|
||
new Languages { Val = "en-US" }
|
||
)
|
||
),
|
||
new ParagraphPropertiesDefault(
|
||
new ParagraphPropertiesBaseStyle(
|
||
new SpacingBetweenLines { After = "200", Line = "276", LineRule = LineSpacingRuleValues.Auto }
|
||
)
|
||
)
|
||
));
|
||
|
||
// Normal
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new StyleRunProperties(
|
||
new RunFonts { Ascii = "Calibri", HighAnsi = "Calibri" },
|
||
new FontSize { Val = "22" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Normal", Default = true });
|
||
|
||
// Title
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "Title" },
|
||
new BasedOn { Val = "Normal" },
|
||
new NextParagraphStyle { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new QuickStyle(),
|
||
new StyleParagraphProperties(
|
||
new Justification { Val = JustificationValues.Center },
|
||
new SpacingBetweenLines { After = "300" },
|
||
new KeepNext(),
|
||
new KeepLines()
|
||
),
|
||
new StyleRunProperties(
|
||
new RunFonts { Ascii = "Calibri Light", HighAnsi = "Calibri Light" },
|
||
new FontSize { Val = "56" },
|
||
new Bold(),
|
||
new Color { Val = "1F497D" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Title" });
|
||
|
||
// Heading 1
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "heading 1" },
|
||
new BasedOn { Val = "Normal" },
|
||
new NextParagraphStyle { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new QuickStyle(),
|
||
new StyleParagraphProperties(
|
||
new KeepNext(),
|
||
new KeepLines(),
|
||
new SpacingBetweenLines { Before = "480", After = "120" },
|
||
new OutlineLevel { Val = 0 },
|
||
new ParagraphBorders(
|
||
new BottomBorder { Val = BorderValues.Single, Size = 4, Color = "4472C4", Space = 4 }
|
||
)
|
||
),
|
||
new StyleRunProperties(
|
||
new RunFonts { Ascii = "Calibri Light", HighAnsi = "Calibri Light" },
|
||
new FontSize { Val = "48" },
|
||
new Bold(),
|
||
new Color { Val = "1F497D" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Heading1" });
|
||
|
||
// Heading 2
|
||
styles.Append(new Style(
|
||
new StyleName { Val = "heading 2" },
|
||
new BasedOn { Val = "Normal" },
|
||
new NextParagraphStyle { Val = "Normal" },
|
||
new PrimaryStyle(),
|
||
new QuickStyle(),
|
||
new StyleParagraphProperties(
|
||
new KeepNext(),
|
||
new SpacingBetweenLines { Before = "240", After = "120" },
|
||
new OutlineLevel { Val = 1 }
|
||
),
|
||
new StyleRunProperties(
|
||
new FontSize { Val = "32" },
|
||
new Bold(),
|
||
new Color { Val = "2F5496" }
|
||
)
|
||
)
|
||
{ Type = StyleValues.Paragraph, StyleId = "Heading2" });
|
||
|
||
return styles;
|
||
}
|
||
|
||
private static void AddNumbering(MainDocumentPart mainPart)
|
||
{
|
||
var numberingPart = mainPart.AddNewPart<NumberingDefinitionsPart>();
|
||
var numbering = new Numbering();
|
||
|
||
var abstractNum = new AbstractNum { AbstractNumberId = 1 };
|
||
abstractNum.Append(new Level(
|
||
new StartNumberingValue { Val = 1 },
|
||
new NumberingFormat { Val = NumberFormatValues.Bullet },
|
||
new LevelText { Val = "•" },
|
||
new LevelJustification { Val = LevelJustificationValues.Left },
|
||
new PreviousParagraphProperties(
|
||
new Indentation { Left = "720", Hanging = "360" })
|
||
)
|
||
{ LevelIndex = 0 });
|
||
|
||
numbering.Append(abstractNum);
|
||
numbering.Append(new NumberingInstance(
|
||
new AbstractNumId { Val = 1 }
|
||
)
|
||
{ NumberID = 1 });
|
||
|
||
numberingPart.Numbering = numbering;
|
||
numberingPart.Numbering.Save();
|
||
}
|
||
|
||
private static void AddSettings(MainDocumentPart mainPart)
|
||
{
|
||
var settingsPart = mainPart.AddNewPart<DocumentSettingsPart>();
|
||
settingsPart.Settings = new Settings(
|
||
new Zoom { Val = "100", Percent = true },
|
||
new DefaultTabStop { Val = 720 },
|
||
new CharacterSpacingControl { Val = CharacterSpacingValues.CompressPunctuation }
|
||
);
|
||
settingsPart.Settings.Save();
|
||
}
|
||
|
||
private static void AddTheme(MainDocumentPart mainPart)
|
||
{
|
||
var themePart = mainPart.AddNewPart<ThemePart>();
|
||
themePart.Theme = new Theme(
|
||
new ThemeElements(
|
||
new ColorScheme(
|
||
new Dark1Color(new Color { Val = "000000" }),
|
||
new Light1Color(new Color { Val = "FFFFFF" }),
|
||
new Accent1Color(new Color { Val = "4472C4" }),
|
||
new Accent2Color(new Color { Val = "C0504D" }),
|
||
new Accent3Color(new Color { Val = "9BBB59" }),
|
||
new Accent4Color(new Color { Val = "8064A2" }),
|
||
new Accent5Color(new Color { Val = "4BACC6" }),
|
||
new Accent6Color(new Color { Val = "F79646" })
|
||
),
|
||
new FontScheme(
|
||
new MajorFont { Val = "Calibri Light" },
|
||
new MinorFont { Val = "Calibri" }
|
||
)
|
||
),
|
||
new ThemeName { Val = "Office Theme" }
|
||
);
|
||
themePart.Theme.Save();
|
||
}
|
||
|
||
private static void AddHeadersAndFooters(MainDocumentPart mainPart)
|
||
{
|
||
var headerPart = mainPart.AddNewPart<HeaderPart>();
|
||
headerPart.Header = new Header(
|
||
new Paragraph(
|
||
new ParagraphProperties(new Justification { Val = JustificationValues.Right }),
|
||
new Run(
|
||
new RunProperties(new RunFonts { Ascii = "Calibri Light" }, new Italic(), new FontSize { Val = "18" }),
|
||
new Text("Business Report"))
|
||
));
|
||
var headerId = mainPart.GetIdOfPart(headerPart);
|
||
|
||
var footerPart = mainPart.AddNewPart<FooterPart>();
|
||
footerPart.Footer = new Footer(
|
||
new Paragraph(
|
||
new ParagraphProperties(new Justification { Val = JustificationValues.Center }),
|
||
new Run(new Text("Page ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.Begin }),
|
||
new Run(new FieldCode(" PAGE ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.End }),
|
||
new Run(new Text(" of ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.Begin }),
|
||
new Run(new FieldCode(" NUMPAGES ") { Space = SpaceProcessingModeValues.Preserve }),
|
||
new Run(new FieldChar { FieldCharType = FieldCharValues.End })
|
||
));
|
||
var footerId = mainPart.GetIdOfPart(footerPart);
|
||
|
||
// Store IDs for later use
|
||
mainPart.Document.Body!.Append(new Paragraph()); // Placeholder for sectPr
|
||
}
|
||
|
||
private static void AddTitle(Body body)
|
||
{
|
||
body.Append(new Paragraph(
|
||
new ParagraphProperties(new ParagraphStyleId { Val = "Title" }),
|
||
new Run(new Text("Business Report"))
|
||
));
|
||
|
||
body.Append(new Paragraph(
|
||
new ParagraphProperties(new ParagraphStyleId { Val = "Subtitle" }),
|
||
new Run(new Text("Quarterly Performance Analysis"))
|
||
));
|
||
|
||
body.Append(new Paragraph(
|
||
new ParagraphProperties(new SpacingBetweenLines { After = "400" }),
|
||
new Run(
|
||
new RunProperties(new Color { Val = "666666" }),
|
||
new Text("March 2026"))
|
||
));
|
||
}
|
||
|
||
private static void AddTableOfContents(Body body)
|
||
{
|
||
body.Append(new Paragraph(
|
||
new ParagraphProperties(new ParagraphStyleId { Val = "Heading1" }),
|
||
new Run(new Text("Table of Contents"))
|
||
));
|
||
|
||
var tocPara = new Paragraph();
|
||
tocPara.Append(new Run(new FieldChar { FieldCharType = FieldCharValues.Begin }));
|
||
tocPara.Append(new Run(new FieldCode(" TOC \\o \"1-2\" \\h \\z \\u ") { Space = SpaceProcessingModeValues.Preserve }));
|
||
tocPara.Append(new Run(new FieldChar { FieldCharType = FieldCharValues.Separate }));
|
||
tocPara.Append(new Run(new Text("Update field to generate Table of Contents")));
|
||
tocPara.Append(new Run(new FieldChar { FieldCharType = FieldCharValues.End }));
|
||
body.Append(tocPara);
|
||
|
||
body.Append(new Paragraph(new Run(new Break { Type = BreakValues.Page })));
|
||
}
|
||
|
||
private static void AddExecutiveSummary(Body body)
|
||
{
|
||
body.Append(new Paragraph(
|
||
new ParagraphProperties(new ParagraphStyleId { Val = "Heading1" }),
|
||
new Run(new Text("Executive Summary"))
|
||
));
|
||
|
||
body.Append(new Paragraph(
|
||
new Run(new Text("This executive summary provides a high-level overview of the quarterly performance. Key highlights include revenue growth, market expansion, and operational improvements."))
|
||
));
|
||
}
|
||
|
||
private static void AddSection(Body body, string title, string content)
|
||
{
|
||
body.Append(new Paragraph(
|
||
new ParagraphProperties(new ParagraphStyleId { Val = "Heading1" }),
|
||
new Run(new Text(title))
|
||
));
|
||
|
||
body.Append(new Paragraph(
|
||
new Run(new Text(content))
|
||
));
|
||
}
|
||
|
||
private static void AddBulletPoints(Body body, string[] points)
|
||
{
|
||
foreach (var point in points)
|
||
{
|
||
body.Append(new Paragraph(
|
||
new ParagraphProperties(
|
||
new NumberingProperties(
|
||
new NumberingLevelReference { Val = 0 },
|
||
new NumberingId { Val = 1 }
|
||
),
|
||
new Indentation { Left = "720", Hanging = "360" }
|
||
),
|
||
new Run(new Text(point))
|
||
));
|
||
}
|
||
}
|
||
|
||
private static void AddSampleTable(Body body)
|
||
{
|
||
var table = new Table(
|
||
new TableProperties(
|
||
new TableWidth { Width = "5000", Type = TableWidthUnitValues.Pct },
|
||
new TableBorders(
|
||
new TopBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new BottomBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new LeftBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new RightBorder { Val = BorderValues.Single, Size = 4, Color = "000000" },
|
||
new InsideHorizontalBorder { Val = BorderValues.Single, Size = 2, Color = "CCCCCC" },
|
||
new InsideVerticalBorder { Val = BorderValues.Single, Size = 2, Color = "CCCCCC" }
|
||
),
|
||
new TableCellMarginDefault(
|
||
new TopMargin { Width = "50", Type = TableWidthUnitValues.DXA },
|
||
new BottomMargin { Width = "50", Type = TableWidthUnitValues.DXA },
|
||
new StartMargin { Width = "100", Type = TableWidthUnitValues.DXA },
|
||
new EndMargin { Width = "100", Type = TableWidthUnitValues.DXA }
|
||
)
|
||
),
|
||
new TableGrid(
|
||
new GridColumn { Width = "2000" },
|
||
new GridColumn { Width = "2000" },
|
||
new GridColumn { Width = "2000" }
|
||
)
|
||
);
|
||
|
||
// Header row
|
||
var headerRow = new TableRow(
|
||
new TableRowProperties(new TableHeader()),
|
||
CreateTableCell("Metric", bold: true),
|
||
CreateTableCell("Q1 2026", bold: true),
|
||
CreateTableCell("Q4 2025", bold: true)
|
||
);
|
||
table.Append(headerRow);
|
||
|
||
// Data rows
|
||
table.Append(CreateTableRow("Revenue", "$2.5M", "$2.1M"));
|
||
table.Append(CreateTableRow("Growth", "19%", "12%"));
|
||
table.Append(CreateTableRow("Customers", "1,250", "1,100"));
|
||
|
||
body.Append(table);
|
||
}
|
||
|
||
private static TableCell CreateTableCell(string text, bool bold = false)
|
||
{
|
||
var cell = new TableCell(
|
||
new Paragraph(
|
||
new Run(
|
||
bold
|
||
? new RunProperties(new Bold())
|
||
: new RunProperties(),
|
||
new Text(text))
|
||
)
|
||
);
|
||
return cell;
|
||
}
|
||
|
||
private static TableRow CreateTableRow(string metric, string q1, string q4)
|
||
{
|
||
return new TableRow(
|
||
CreateTableCell(metric),
|
||
CreateTableCell(q1),
|
||
CreateTableCell(q4)
|
||
);
|
||
}
|
||
|
||
private static SectionProperties CreateSectionProperties(MainDocumentPart mainPart)
|
||
{
|
||
var sectPr = new SectionProperties();
|
||
|
||
// Header/Footer references
|
||
var headerPart = mainPart.HeaderParts.FirstOrDefault();
|
||
var footerPart = mainPart.FooterParts.FirstOrDefault();
|
||
if (headerPart != null)
|
||
sectPr.Append(new HeaderReference { Type = HeaderFooterValues.Default, Id = mainPart.GetIdOfPart(headerPart) });
|
||
if (footerPart != null)
|
||
sectPr.Append(new FooterReference { Type = HeaderFooterValues.Default, Id = mainPart.GetIdOfPart(footerPart) });
|
||
|
||
// Page size
|
||
sectPr.Append(new PageSize { Width = 12240u, Height = 15840u });
|
||
|
||
// Page margins
|
||
sectPr.Append(new PageMargin
|
||
{
|
||
Top = 1440,
|
||
Bottom = 1440,
|
||
Left = 1440u,
|
||
Right = 1440u,
|
||
Header = 720u,
|
||
Footer = 720u
|
||
});
|
||
|
||
return sectPr;
|
||
}
|
||
}
|
||
|
||
// ===========================================================================
|
||
// USAGE
|
||
// ===========================================================================
|
||
/*
|
||
public static void Main(string[] args)
|
||
{
|
||
BusinessReportGenerator.Generate("C:\\Reports\\BusinessReport.docx");
|
||
Console.WriteLine("Report generated successfully!");
|
||
}
|
||
*/
|
||
```
|
||
|
||
---
|
||
|
||
## Appendix B: OpenXmlUnits Helper Class
|
||
|
||
```csharp
|
||
// =============================================================================
|
||
// UNIT CONVERSION HELPERS
|
||
// =============================================================================
|
||
// Copy this class into your project for convenient unit conversions.
|
||
|
||
public static class OpenXmlUnits
|
||
{
|
||
// DXA (Twentieths of a DXA / Twips) conversions
|
||
public static int InchesToDxa(double inches) => (int)(inches * 1440);
|
||
public static int CmToDxa(double cm) => (int)(cm * 567.0);
|
||
public static int PtToDxa(double pt) => (int)(pt * 20);
|
||
public static double DxaToInches(int dxa) => dxa / 1440.0;
|
||
public static double DxaToCm(int dxa) => dxa / 567.0;
|
||
public static double DxaToPt(int dxa) => dxa / 20.0;
|
||
|
||
// EMU (English Metric Units) conversions
|
||
public static long InchesToEmu(double inches) => (long)(inches * 914400);
|
||
public static long CmToEmu(double cm) => (long)(cm * 360000);
|
||
public static double EmuToInches(long emu) => emu / 914400.0;
|
||
public static double EmuToCm(long emu) => emu / 360000.0;
|
||
|
||
// Half-point conversions (font sizes)
|
||
public static int PtToHalfPt(double pt) => (int)(pt * 2);
|
||
public static int FontSizeToSz(double ptSize) => (int)(ptSize * 2);
|
||
public static double SzToPt(int sz) => sz / 2.0;
|
||
|
||
// Line spacing helpers
|
||
public static int SingleSpacing => 240;
|
||
public static int DoubleSpacing => 480;
|
||
public static int OneAndHalfSpacing => 360;
|
||
public static int LineSpacingPt(double pt) => (int)(pt * 20);
|
||
|
||
// Common measurements
|
||
public static int HalfInch => 720;
|
||
public static int OneInch => 1440;
|
||
public static int OneAndHalfInches => 2160;
|
||
public static int TwoInches => 2880;
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
*Document Version: 1.0*
|
||
*OpenXML SDK: 3.x*
|
||
*.NET Version: 10*
|
||
*C# Version: 13*
|