Matlab Generate Report

MathWorksOfficialCreated by MathWorks

Skill
Tool integration
Science and research
BSD-2-Clause
No issues found

From the author

Unified skill for all MATLAB and Simulink report generation tasks. Covers report generation, PDF report, document generation, mlreportgen, Report Generator, template, TitlePage, Chapter, multipage HTML, HTMLPage, html-multipage, custom reporter, customizeReporter, template hole, page header, page border, company style package, branded reporters, buildTemplates, Simulink report, model documentation, slreportgen, block diagram report, model report, subsystem documentation, SystemDiagramFinder, SystemIO, ExecutionOrder, LookupTable, template style, page footer, TemplateSrc, report package, table variants, multiple HTML pages, PDF report generation, Word report, DOM API, FormalTable, BaseTable, Figure, FormalImage, Section.

— the description by MathWorks

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The MATLAB Report Generation skill provides a unified framework for creating structured, professional documentation directly from MATLAB and Simulink. It leverages the Report API for high-level document structure and the DOM API for granular control over formatting, tables, and images. The system supports template-based styling, custom reporter classes for branded content, and specialized tools for documenting Simulink models, including block diagrams and execution order.

What it does

Creates PDF, Word, and HTML documents from MATLAB data.
Supports auto-numbered figures, tables, and chapters.
Generates technical documentation for Simulink models.
Enables custom branded templates with headers, footers, and page borders.
Provides a scaffolded approach for building custom reporter classes.
Supports multipage HTML output with navigation.

When to use it

When you need to automate the creation of technical reports from MATLAB analysis.
When documenting Simulink models, including system I/O and execution order.
When you require consistent, branded document styling across multiple reports.
When you need to integrate MATLAB plots and data into professional PDF or Word documents.

Advantages

Maintains document structure and numbering automatically.
Separates content logic from visual styling via templates.
Provides specialized support for complex Simulink model documentation.
Allows for highly customized, reusable report components.

Usage examples

“Create a basic PDF report with a title page and a chapter containing a plot.”: The agent provides a script using mlreportgen.report.Report, TitlePage, and Figure classes to generate a PDF with auto-numbered content.
“How do I document a Simulink model's system I/O?”: The agent guides you to use slreportgen.report.Report and the SystemIO reporter to extract and format model I/O data.
“How can I create a custom report template?”: The agent instructs you to use the customizeReporter method to scaffold a custom reporter class and its associated template files.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/matlab/matlab-generate-report/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip matlab-generate-report.zip -d .agents/skills

Documentation by MathWorks

MATLAB Report Generation

Generate structured, professional reports (PDF, Word, HTML) from MATLAB data and Simulink models.

When to Use

Creating PDF, Word, or HTML reports from MATLAB data
Building reports with chapters, title pages, tables of contents
Adding auto-numbered figures and tables to documents
Creating multipage HTML reports (separate HTML files with navigation)
Documenting Simulink models with block diagrams, I/O tables, execution order
Customizing report templates (styles, colors, fonts, headers, footers)
Creating custom reporter classes with template holes and dynamic content
Building multi-reporter packages with shared company styles
Creating table variant reporters with different header colors
Including HTML content in reports

When NOT to Use

Simple file export (CSV, Excel) — use writetable, writematrix
Live Scripts as reports — use MATLAB Live Editor export
Interactive report building — use Report Explorer GUI
Web views of Simulink models — use slreportgen.webview.* directly

API Selection

Always use the Report API (mlreportgen.report.*) as the foundation. It provides the Report container and reporters (Figure, BaseTable, FormalImage, Chapter, TitlePage, etc.) that handle auto-numbering, captions, and document structure.

Use both APIs together. Use the Report API to create the report and add content for which reporters exist. Use the DOM API (mlreportgen.dom.*) for styled paragraphs, custom tables, inline formatting, HTML inclusion, and images without captions. DOM objects append directly to Report, Chapter, or Section alongside reporters.

Critical rule: Report API reporters (Figure, BaseTable, FormalImage) can ONLY be appended to Report, Chapter, or Section objects — never to DOM objects like TableEntry. Use DOM objects inside TableEntry.

Simulink reports: Use slreportgen.report.Report (not mlreportgen.report.Report) — it extends the base with model compilation support required by SystemIO, ExecutionOrder, and other Simulink reporters.

Multipage HTML: Use mlreportgen.dom.Document with "html-multipage" type + HTMLPage objects. This is the only case where you use the DOM Document instead of the Report API Report.

Core Workflow: Standard Report

TitlePage, TableOfContents, ListOfFigures, and ListOfTables are optional — include only when the task requires them. The minimal report is just Report + content + close.

import mlreportgen.report.*
import mlreportgen.dom.*

rpt = Report("MyReport","pdf");
append(rpt,TitlePage(Title="Report Title",Author="Team"));  % optional
append(rpt,TableOfContents());   % optional
append(rpt,ListOfFigures());     % optional
append(rpt,ListOfTables());      % optional

ch = Chapter("Results");
append(ch,Paragraph("Analysis complete."));

% Auto-numbered table
data = FormalTable(["ID","Value"],[1 10; 2 20]);
bt = BaseTable(data);
bt.Title = "Measured values";
append(ch,bt);

% Auto-numbered figure
fig = figure("Visible","off");
plot([1 2],[10 20]);
rptFig = Figure(fig);
rptFig.Snapshot.Caption = "Value trend";
append(ch,rptFig);
close(fig);

append(rpt,ch);
close(rpt);
rptview(rpt);

Core Workflow: Simulink Report

load_system(modelName);

% MUST use slreportgen.report.Report for Simulink content
rpt = slreportgen.report.Report(outputPath,"pdf");
append(rpt,mlreportgen.report.TitlePage("Title","Model Report"));
append(rpt,mlreportgen.report.TableOfContents());

ch = mlreportgen.report.Chapter("Diagrams");

% Root diagram — direct reporter
rootDiag = slreportgen.report.Diagram(modelName);
rootDiag.Snapshot.ScaleToFit = true;
append(ch,rootDiag);

% Subsystems — finder pattern (iterator for memory efficiency)
finder = slreportgen.finder.SystemDiagramFinder(modelName);
finder.IncludeRoot = false;
finder.SortType = "alphabetical";

while finder.hasNext()
    result = finder.next();
    sec = mlreportgen.report.Section("Title",result.Name);
    append(sec,result);
    append(ch,sec);
end

append(rpt,ch);
close(rpt);
rptview(rpt);

Choosing Built-In vs Custom Reporters

Before writing code, analyze requirements against built-in reporter capabilities:

List all content/format requirements — title page fields, page borders, headers/footers, branded styling
Check built-in reporters. Built-in TitlePage has: Title, Subtitle, Author, Publisher, PubDate, Image. Built-in Chapter/Section provide headings, auto-numbering, and a Content hole.
If built-in reporters meet all requirements, use them directly
If any requirement is unmet, create custom reporters:
- Single custom reporter — see references/custom-reporters.md
- Multiple reporters sharing a visual identity — see references/report-package.md

Common triggers for custom reporters:

Title page needs fields beyond the standard set (project name, facility, contract number)
Page borders, watermarks, or custom page layout
Page headers/footers with dynamic content (per-chapter images, tickers)
Branded table variants with different header colors
MATLAB-generated logos (geometric shapes drawn with plot/patch + exportgraphics)

Do NOT force-fit requirements into built-in properties (e.g., concatenating fields into Subtitle). Create a custom reporter instead.

Do NOT build custom title pages with raw DOM elements (Paragraphs, Images appended to a Chapter). Always use customizeReporter for template-based layout and format portability.

Decision Tree: What Reference Do I Need?

I need to...	Reference
Build a standard report with chapters, figures, tables, verification	references/report-api-patterns.md
Work with DOM tables, HTML inclusion, multipage HTML, Number/NumberFormat	references/dom-api-patterns.md
Understand template file types, locate/inspect templates	references/template-system.md
Look up built-in template holes, styles, page layout (pre-computed)	references/template-reference.md
Create a custom reporter class (customizeReporter, holes, headers)	references/custom-reporters.md
Build a multi-reporter package with shared styles and buildTemplates	references/report-package.md
Generate Simulink model reports (finders, orientation, centering)	references/simulink-report.md
Look up all Simulink finders and reporters	references/finders-and-reporters.md
Iterate struct arrays into chapters with custom reporters	references/data-driven-report-pattern.md
Edit template styles (colors, fonts, headers, footers, TOC)	references/template-system.md

Key Functions

Class	Purpose	Package
`Report`	Top-level report container	`mlreportgen.report`
`TitlePage`	Title page with title, subtitle, author	`mlreportgen.report`
`TableOfContents`	Auto-generated TOC	`mlreportgen.report`
`Chapter` / `Section`	Document structure	`mlreportgen.report`
`Figure`	Auto-numbered figure from MATLAB figure	`mlreportgen.report`
`FormalImage`	Auto-numbered image from file with caption	`mlreportgen.report`
`BaseTable`	Auto-numbered table wrapper (pass `FormalTable`)	`mlreportgen.report`
`FormalTable`	Table with header/body/footer from cell arrays	`mlreportgen.dom`
`Template` (3-arg)	Edit templates: `Template(out,fmt,src)`	`mlreportgen.dom`
`HTMLFile` / `HTML`	Include HTML content in any output format	`mlreportgen.dom`
`HTMLPage`	Page in multipage HTML document (R2024a+)	`mlreportgen.dom`
`Number`	Numeric DOM object (use with `NumberFormat`)	`mlreportgen.dom`
`TemplateHole`	Placeholder filled at report time	`mlreportgen.dom`
`Page` / `NumPages`	Page number / total pages	`mlreportgen.dom`
`*.customizeReporter`	Scaffold custom reporter + templates	`mlreportgen.report`
`getStyle` / `replaceStyle`	Modify template styles	`mlreportgen.dom`
`slreportgen.report.Report`	Report container for Simulink content	`slreportgen.report`
`slreportgen.report.Diagram`	Diagram snapshot of a system	`slreportgen.report`
`slreportgen.finder.SystemDiagramFinder`	Find system/subsystem diagrams	`slreportgen.finder`
`slreportgen.report.SystemIO`	Report inputs/outputs (requires compilation)	`slreportgen.report`
`slreportgen.report.ExecutionOrder`	Report block execution order	`slreportgen.report`
`slreportgen.report.LookupTable`	Report lookup table data + plot	`slreportgen.report`
`rptview`	Display report (updates DOCX fields)	function
`docview`	Process Word documents (update fields, convert)	function

Common Mistakes

Mistake	Correct Approach
Using `mlreportgen.dom.Document` as report container	Use `mlreportgen.report.Report`. Exception: multipage HTML requires `Document` with `"html-multipage"`
Using `mlreportgen.report.Report` for Simulink content	Use `slreportgen.report.Report` — needed for model compilation
Using `Report` with `"html"` for multipage output	Use `mlreportgen.dom.Document` with `"html-multipage"` + `HTMLPage` objects
Appending reporters to DOM objects (Paragraph, TableEntry)	Reporters can ONLY go in Report, Chapter, or Section. Use DOM objects inside TableEntry
Putting raw doubles in `FormalTable` cells	Use `Number` with `NumberFormat` in Style: `n = Number(42); n.Style = {NumberFormat("%.0f")}`. Put `n` directly in cell arrays. See references/dom-api-patterns.md § Number and NumberFormat
`NumberFormat("$%.0f")` or `NumberFormat("%,.0f")`	Only standard `sprintf` specifiers work (no `$`, no `%,`, no `%d`). For currency/units, wrap `Number` in `Paragraph` and prepend/append `Text`
Customizing only "default"/"even" page headers	Customize ALL page types: "first", "default", "even" — but differentiate content (see below)
Putting StyleRef (chapter title) in the first-page header	First page already displays the chapter heading — omit StyleRef from "first" header. Use it only in "default"/"even" for wayfinding
Opening DOCX with `winopen`/`open`/`start`	Use `rptview(rpt)` or `docview(file,"updatefields")` — triggers field update
Using `ColSpec`/`ColSpecGroup` for widths	Use `TableColSpecGroup` + `TableColSpec` with `Width` in `Style`
Setting widths without `ResizeToFitContents(false)`	Add `ResizeToFitContents(false)` to table `Style`; set absolute `ft.Width` (not `"100%"`)
`TemplateParagraphStyle.Formats = {Bold(true)}`	Use array: `Formats = [Bold(true),FontSize("12pt")]`
`Template(path,"pdf")` to edit existing template	2-arg creates blank. Use 3-arg: `Template(out,"pdf",src)`
Same path for source and output in Template constructor	OPC cannot read/write simultaneously. Use different paths, then `movefile`
Setting `PDFPageLayout.PageSize.Orientation` without `rotate()`	Call `rotate(pl)` — swaps Width/Height AND sets Orientation
Using `DOCXPageLayout` without explicit Height and Width	DOCX does not auto-swap — set both explicitly
Page numbers resetting after `PDFPageLayout`	Set `pl.FirstPageNumber = ''` (empty string) to continue numbering
Wrapping reporter in Paragraph to center it	Customize the reporter's template style via Template API
Using `RawText(html)` for HTML in PDF	Use `HTMLFile(path)` or `HTML(string)` — works for any format
Using `Group` in a `Table` cell array	Use nested cell arrays: `Table({{img,caption},desc})`
Passing MATLAB `table()` to `BaseTable`	Pass `FormalTable(headers,body)` — avoids `MATLABTable` wrapper
`e.Style = {BackgroundColor("yellow")}` (overwrites existing styles)	Append: `e.Style = [e.Style, {BackgroundColor("yellow")}]` — preserves inherited styles
Force-fitting fields into `TitlePage.Subtitle`	Create a custom title page reporter via `customizeReporter`
Writing custom reporter class from scratch	Use `customizeReporter` to scaffold — creates required binary templates
Writing classdef before running `customizeReporter`	Scaffolding overwrites classdef files. Scaffold first, then edit
Unqualified `TitlePage.getClassFolder()` in package	Use fully-qualified: `mypkg.TitlePage.getClassFolder()`
`getStyle(ss,name,type)` for PDF/HTML	Type arg returns `[]`. Use `getStyle(ss,name)` without type
`OuterMargin("12pt","6pt","0","0")` for vertical spacing	Args are `(left,right,top,bottom)` — NOT CSS order. Use `OuterMargin("0","0","12pt","6pt")` for top/bottom spacing
Using `TemplateCharacterStyle`	Does not exist. Use `TemplateTextStyle` for character/inline styles in PDF/HTML
Unzipping `.pdftx`/`.htmtx`/`.dotx` to edit with fileread/regexprep	ALWAYS use DOM Template API — `Template(out,fmt,src)` + `open` + modify objects + `close`. Raw edits bypass framework validation
`find_system` + `DiagramFinder` for discovery	Use `SystemDiagramFinder` with filter properties
`Diagram(result.Path)` on `ChartDiagramFinder` results	Use `getReporter(result)` — chart paths are invalid for `Diagram` constructor
`find()` + for loop on finders	Always use iterator: `while finder.hasNext()` / `result = finder.next()`
`BlockFinder` with `SearchDepth=inf` expecting referenced models	`BlockFinder` does NOT traverse Model References. Use `SystemDiagramFinder` (IncludeReferencedModels=true) + per-system `BlockFinder` (SearchDepth=1)
`ExecutionOrder` on virtual subsystem	Check `get_param(obj,'IsSubsystemVirtual')` first
`ExecutionOrder`/`SystemIO` on Simulink Functions	Guard with `slreportgen.utils.isSimulinkFunction(result.Object)`

Conventions

Always close(rpt) after appending all content — generates the output file
Always rptview or docview to open DOCX — never winopen or open
Use figure("Visible","off") for plots destined for reports
Use exportgraphics (not print) when saving figures to files
One Chapter = one numbering scope — figures/tables numbered Chapter-Sequence (e.g., "Figure 2-1")
BaseTable wraps FormalTable — pass FormalTable(headers,body), not a MATLAB table()
Cell-level styling: Use entry(t,row,col) after construction, not during
Template styles use [] arrays; inline .Style properties use {}
Reporters in @ClassName directories — each needs its own resources/templates/
Scaffold ALL reporters before editing ANY — customizeReporter creates binary templates + overwrites classdef
Fix unqualified class names after scaffolding — use package-qualified names
Customize all output formats — PDF/Word/HTML templates are independent
Simulink: Always slreportgen.report.Report; always Diagram.Snapshot.ScaleToFit = true
Simulink finders: Use .Object handle (not path string) for get_param; use result.Name for titles
JSON is single source of truth for multi-reporter packages — never hardcode style values

Viewing and Processing Reports

rptview(rpt);                           % Open in system viewer (updates DOCX fields)
rptview("MyReport.docx","pdf");         % Convert DOCX to PDF via Word
docview("Report.docx","updatefields","closedoc","closeapp");  % Update without display

Verification: Running without error does NOT confirm correctness. After close(rpt):

Check isfile(rpt.OutputPath) and dir(rpt.OutputPath).bytes > 1000
For PDF: call open(rpt), then set rpt.Document.RetainFO = true before appending content, search *_FO/*.fo files
For DOCX: unzip and search word/document.xml
Assert expected titles, headings, captions appear in output

See references/report-api-patterns.md for full verification patterns.

Required Toolbox

MATLAB Report Generator (verify with mcp__matlab__detect_matlab_toolboxes). Simulink Report Generator additionally required for Simulink model reports.

Files

ATTRIBUTION.mdAdded by AutoGineer1.1 KiB
LICENSELicence file added by AutoGineer1.4 KiB
SKILL.md17.1 KiB
manifest.yaml598 B
references/custom-reporters.md39.1 KiB
references/data-driven-report-pattern.md13.1 KiB
references/dom-api-patterns.md31.0 KiB
references/finders-and-reporters.md13.1 KiB
references/report-api-patterns.md7.2 KiB
references/report-package.md15.8 KiB
references/simulink-report.md19.9 KiB
references/template-reference.md38.1 KiB
references/template-system.md30.9 KiB

references/template-system.md

Template System

Comprehensive reference for editing MATLAB Report Generator templates using the DOM Template API — styles, page headers/footers, holes, TOC customization, and template creation across PDF, Word, and HTML formats.

Template File Types

Output Type	Extension	Template API Type Arg	Nature
PDF	`.pdftx`	`"pdf"`	OPC archive (HTML + CSS)
Word	`.dotx`	`"docx"`	OPC archive (Word XML)
HTML (multi-file)	`.htmtx`	`"html"`	OPC archive
HTML (single-file)	`.htmt`	`"html-file"`	Plain HTML file

Critical: Match the type argument to the file extension. Using "html" with a .htmt file fails ("Could not open source package") because .htmt is plain text, not OPC. Use "html-file" for .htmt.

The 3-Argument Template Constructor

The Template constructor has two forms:

Form	Purpose	Stylesheet Returns
`Template(outPath,format)`	Create new blank template	34 Report-level base styles
`Template(outPath,format,srcPath)`	Open existing template for editing/inspection	Reporter's own styles (e.g., 16 for Section PDF)

Always use the 3-argument form to edit or inspect an existing template. The 2-argument form creates a blank template from DOM defaults — it does NOT load existing content.

Critical: OPC packages cannot be read and written simultaneously. The output path MUST differ from the source path:

import mlreportgen.dom.*

srcPath = "path/to/default.pdftx";
tmpPath = strrep(srcPath,"default.pdftx","default_new.pdftx");

tpl = Template(tmpPath,"pdf",srcPath);
open(tpl);
% ... modify ...
close(tpl);
movefile(tmpPath,srcPath);

Locating Templates

Preferred: getDefaultTemplatePath — works for any reporter, handles inheritance:

rpt = mlreportgen.report.Report(fullfile(tempdir,"tmp"),"pdf");
reporter = mlreportgen.report.Chapter("X");
templatePath = reporter.getDefaultTemplatePath(rpt);
% Returns Section's PDF template path (Chapter inherits from Section)
delete(rpt);

Alternative: Manual location from class file:

classDir = fileparts(which("mlreportgen.report.Section"));
templatePath = fullfile(classDir,"resources","templates","pdf","default.pdftx");

Key facts:

Chapter and InlineContent have no template directory — they inherit from Section/Reporter
getDefaultTemplatePath handles this transparently
reporter.TemplateName tells you which document part is the entry point

Inspecting Templates

Use this pattern to introspect any reporter's template — extracts document parts, holes, styles, and page layout:

import mlreportgen.dom.*

% 1. Locate template
rpt = mlreportgen.report.Report(fullfile(tempdir,"tmp"),"pdf");
reporter = mlreportgen.report.Chapter("X");
templatePath = reporter.getDefaultTemplatePath(rpt);
delete(rpt);

% 2. Open with 3-arg constructor
tpl = Template(fullfile(tempdir,"introspect.pdftx"),"pdf",templatePath);
open(tpl);

% 3. Document parts and holes
parts = tpl.TemplateDocumentParts;
for i = 1:numel(parts)
    fprintf("Part: %s\n",parts(i).Name);
    for j = 1:numel(parts(i).Children)
        child = parts(i).Children(j);
        if isa(child,"mlreportgen.dom.TemplateHole")
            fprintf("  Hole: %s (defaultStyle: %s)\n",...
                child.HoleId,child.DefaultHoleStyleName);
        end
    end
end

% 4. Styles
ts = tpl.Stylesheet.TemplateStyles;
for i = 1:numel(ts)
    if isprop(ts(i),"Selector")
        fprintf("Style: %s [%s]\n",ts(i).Name,ts(i).Selector);
    else
        fprintf("Style: %s [%s]\n",ts(i).Name,ts(i).Type);
    end
end

% 5. Page layout (PDF/DOCX — first child of Section1)
for i = 1:numel(parts)
    if strcmp(parts(i).Name,"Section1") && numel(parts(i).Children) > 0
        layout = parts(i).Children(1);
        fprintf("Layout: %s\n",class(layout));
        if isa(layout,"mlreportgen.dom.PDFPageLayout")
            fprintf("  Headers: %d, Footers: %d\n",...
                numel(layout.PageHeaders),numel(layout.PageFooters));
        end
    end
end

close(tpl);

Before customizing a built-in reporter template, first consult template-reference.md. It contains pre-computed introspection of common reporters — no need to run introspection code for those.

Template Inheritance Model

Level 1: Report Template
  - Defines base styles (TOC, Title, headings, table, link — 34 for PDF)
  - Created by Report() or 2-arg Template()

Level 2: Reporter Templates
  - Each reporter has its own template with reporter-specific styles
  - Loaded via 3-arg Template(out, fmt, src)

Level 3: Generated Output
  - Style propagation MERGES all styles from every reporter into output
  - ALL defined styles appear regardless of whether referenced

Critical: Do NOT inspect generated output to determine "used" styles — style propagation copies everything. Walk template doc parts to find actual references.

Style Object Types by Format

PDF — TemplatePDFStyle:

Property	Description
`Name`	Style display name (e.g., `"SectionTitle1"`)
`Selector`	CSS selector (e.g., `"h1.SectionTitle1"`)
`RawFormats`	Raw CSS property string

Multiple selectors can share a Name (e.g., h1.SectionTitle1 and p.SectionTitle1).

DOCX — TemplateDOCXStyle:

Property	Description
`Name`	Style display name
`Type`	`"paragraph"`, `"text"`, `"linked"`, `"table"`, `"list"`
`Formats`	Always empty — cannot inspect or set formats

To inspect DOCX style formats, parse styles.xml inside the .dotx.

Modifying Styles — PDF and HTML

PDF styles (TemplatePDFStyle) and HTML styles (TemplateHTMLStyle) are handle objects. Modify RawFormats directly:

import mlreportgen.dom.*

classDir = fileparts(which("mlreportgen.report.Section"));
srcPath = fullfile(classDir,"resources","templates","pdf","default.pdftx");
outPath = fullfile(tempdir,"modified_section.pdftx");

tpl = Template(outPath,"pdf",srcPath);
open(tpl);

% No type argument — returns all CSS rules with this name
styles = getStyle(tpl.Stylesheet,"SectionTitle1");

% Modify RawFormats directly (handle semantics — changes persist)
for i = 1:numel(styles)
    styles(i).RawFormats = regexprep(styles(i).RawFormats,...
        "color:\s*[^;]+","color: navy");
end

close(tpl);
movefile(outPath,srcPath);

Common RawFormats changes:

Change	Pattern
Color	`regexprep(raw,"color:\s*[^;]+","color: red")`
Font size	`regexprep(raw,"font-size:\s*[^;]+","font-size: 16pt")`
Font family	`regexprep(raw,"font-family:\s*[^;]+","font-family: Arial")`
Add property	`raw = raw + " text-decoration: underline;"`
Remove bold	`regexprep(raw,"font-weight:\sbold;?\s","")`

Filtering by Selector: When getStyle returns multiple entries, use .Selector to target the correct one:

styles = getStyle(tpl.Stylesheet,"BaseTableContent");
for i = 1:numel(styles)
    if contains(styles(i).Selector,"th")
        % Modify header cells only
        styles(i).RawFormats = regexprep(styles(i).RawFormats,...
            "background-color:\s*[^;]+","background-color: navy");
    end
end

Modifying Styles — DOCX

DOCX styles are read-only. Create a replacement and use replaceStyle:

import mlreportgen.dom.*

tpl = Template(outPath,"docx",srcPath);
open(tpl);

% Get style (no type argument) and check its Type
style = getStyle(tpl.Stylesheet,"SectionTitle1");
fprintf("Type: %s\n",style.Type);  % "linked" → use TemplateLinkedStyle

% Create replacement with updated formats
newStyle = TemplateLinkedStyle("SectionTitle1");
newStyle.Formats = [Bold(true),FontSize("14pt"),FontFamily("Cambria"),...
    Color("green"),OutlineLevel(1)];  % OutlineLevel REQUIRED for headings
replaceStyle(tpl.Stylesheet,newStyle);

close(tpl);

Style Class Selection

`TemplateDOCXStyle.Type`	Replacement Class
`"linked"`	`TemplateLinkedStyle`
`"paragraph"`	`TemplateParagraphStyle`
`"text"` (character)	`TemplateCharacterStyle`
`"table"`	`TemplateTableStyle`

CRITICAL: Heading Styles and TOC (OutlineLevel)

When replacing any heading style (SectionTitle1–SectionTitle6), you MUST include OutlineLevel(N) in the Formats array. Word's TOC uses outline levels to discover headings. Without it, TOC displays "No table of contents entries found."

Style Name	Required OutlineLevel
`SectionTitle1`	`OutlineLevel(1)`
`SectionTitle2`	`OutlineLevel(2)`
`SectionTitle3`	`OutlineLevel(3)`
`SectionTitle4`	`OutlineLevel(4)`
`SectionTitle5`	`OutlineLevel(5)`
`SectionTitle6`	`OutlineLevel(6)`

DOCX Table Styles (TemplateTableStyle)

ts = TemplateTableStyle("BaseTableContent");
ts.Formats = [Border("solid","#333333","0.5pt"),FontSize("10pt"),FontFamily("Arial")];
ts.HeaderFormats = [Bold(true),BackgroundColor("#1B3A5C"),Color("white"),FontSize("11pt")];
% Optional: ts.EvenRowFormats = [BackgroundColor("#F0F0F0")];
replaceStyle(tpl.Stylesheet,ts);

Key TemplateTableStyle properties:

Property	Applied To
`Formats`	All table body cells
`HeaderFormats`	Header row cells (overrides Formats)
`FooterFormats`	Footer row cells
`EvenRowFormats`	Even-numbered body rows (striping)
`OddRowFormats`	Odd-numbered body rows
`FirstColumnFormats`	First column cells
`LastColumnFormats`	Last column cells

Identifying Current DOCX Formats from styles.xml

% Extract styles.xml to read current formatting
unzipDir = fullfile(tempdir,"dotx_inspect");
if isfolder(unzipDir),rmdir(unzipDir,"s"); end
unzip(srcPath,unzipDir);

stylesXml = fileread(fullfile(unzipDir,"word","styles.xml"));
% Look for: <w:name w:val="SectionTitle1"/>
% Then read: w:rPr (run properties), w:pPr (paragraph properties)
% Common elements:
%   <w:b/>            → Bold
%   <w:sz w:val="28"/> → FontSize (half-points: 28 = 14pt)
%   <w:color w:val="365F91"/> → Color("#365F91")
%   <w:rFonts w:ascii="Cambria"/> → FontFamily("Cambria")
%   <w:jc w:val="center"/> → HAlign("center")

Multi-Level Headings

Section templates define 6 heading levels (SectionTitle1–SectionTitle6). Chapter uses level 1; Sections nested under Chapter use level 2+. To change heading appearance uniformly, modify ALL levels:

% Modify all heading levels for uniform color
for level = 1:6
    styleName = sprintf("SectionTitle%d",level);
    styles = getStyle(tpl.Stylesheet,styleName);
    for i = 1:numel(styles)
        styles(i).RawFormats = regexprep(styles(i).RawFormats,...
            "color:\s*[^;]+","color: navy");
    end
end

Modifying Page Headers and Footers

Page headers/footers live on the page layout object inside the Section1 document part:

Format	Layout Object	Header/Footer Class
PDF	`PDFPageLayout` (first child of Section1)	`PDFPageHeader` / `PDFPageFooter`
Word	`DOCXSection` (first child of Section1)	`DOCXPageHeader` / `DOCXPageFooter`
HTML	N/A (no page concept)	N/A

Access Pattern

import mlreportgen.dom.*

tpl = Template(tmpPath,"pdf",srcPath);
open(tpl);

parts = tpl.TemplateDocumentParts;
section1 = [];
for i = 1:numel(parts)
    if strcmp(parts(i).Name,"Section1")
        section1 = parts(i);
        break
    end
end

layout = section1.Children(1);  % PDFPageLayout or DOCXSection

for k = 1:numel(layout.PageHeaders)
    fprintf("Header %d: PageType=%s\n",k,layout.PageHeaders(k).PageType);
end

Replacing a Footer (Adding Page Numbers)

for k = 1:numel(layout.PageFooters)
    if strcmp(layout.PageFooters(k).PageType,"default")
        newFooter = PDFPageFooter("default");

        footerPara = Paragraph("");
        footerPara.HAlign = "center";
        append(footerPara,"Page ");
        append(footerPara,Page());
        append(footerPara," of ");
        append(footerPara,NumPages());
        append(newFooter,footerPara);

        layout.PageFooters(k) = newFooter;
    end
end

tpl.TemplateDocumentParts(1) = section1;
close(tpl);
movefile(tmpPath,srcPath);

Multi-Column Header Layout (3-Column Centering)

newHeader = PDFPageHeader("default");

% Left: image or hole
imgPara = Paragraph("");
append(imgPara,TemplateHole("HeaderImage"));

% Center: running head (centered on page)
titlePara = Paragraph("");
titlePara.HAlign = "center";
titlePara.StyleName = "SectionTitleHeader";
append(titlePara,StyleRef("SectionTitle1"));

% Right: spacer (balances image column)
spacerPara = Paragraph(" ");

% 3-column table with explicit entry widths
e1 = TableEntry(imgPara);
e1.Style = {Width("1in")};
e2 = TableEntry(titlePara);
e2.Style = {Width("5in")};
e3 = TableEntry(spacerPara);
e3.Style = {Width("1in")};

row = TableRow();
append(row,e1);
append(row,e2);
append(row,e3);

headerTable = Table();
append(headerTable,row);
headerTable.Width = "100%";
headerTable.Style = {Border("none"),ResizeToFitContents(false)};
headerTable.TableEntriesVAlign = "bottom";
append(newHeader,headerTable);

Preferred approach for column widths in headers: Set widths on TableEntry.Style (more reliable than TableColSpecGroup in single-row header context).

If using TableColSpecGroup + TableColSpec, you must set Span = 1 explicitly on each TableColSpec:

grp = TableColSpecGroup();
cs1 = TableColSpec(); cs1.Span = 1; cs1.Style = {Width("1in")};
cs2 = TableColSpec(); cs2.Span = 1; cs2.Style = {Width("5in")};
cs3 = TableColSpec(); cs3.Span = 1; cs3.Style = {Width("1in")};
grp.ColSpecs = [cs1,cs2,cs3];
headerTable.ColSpecGroups = grp;

Word-Specific Header Rules

Do NOT modify existing TemplateText objects — their content is raw Word XML. Always create new DOCXPageHeader from DOM objects.

Preserve the first-page header when replacing the default:

firstHeader = docxSection.PageHeaders(2);  % PageType="first"
docxSection.PageHeaders = [newDefaultHeader,firstHeader];

PDF Header/Footer Doc Parts (Section/Chapter Templates)

Doc Part Name	When Used
`SectionFirstPageHeader`	First page of chapter only
`SectionDefaultPageHeader`	Odd pages (or all non-first if no even defined)
`SectionEvenPageHeader`	Even pages
`SectionFirstPageFooter`	First page footer
`SectionDefaultPageFooter`	Odd pages footer
`SectionEvenPageFooter`	Even pages footer

Special Elements in PDF Templates

Element	DOM Equivalent	Purpose
`<hole id="Name">`	`TemplateHole("Name")`	Placeholder filled by reporter property
`<StyleRef style-name="X"/>`	`StyleRef("X")`	Running head — shows text with style X
`<page/>`	`Page()`	Current page number
`<numpages/>`	`NumPages()`	Total page count

Adding Holes to Templates

To a Document Part Body

% Rebuild the document part with a new hole inserted
newSection = TemplateDocumentPart("Section1");
append(newSection,section1.Children(1));  % Keep layout

% Add new hole before existing content
summaryHole = TemplateHole("Summary");
summaryHole.DefaultHoleStyleName = "SectionContent";
append(newSection,summaryHole);

% Clone remaining children
for k = 2:numel(section1.Children)
    append(newSection,clone(section1.Children(k)));
end

tpl.TemplateDocumentParts(1) = newSection;

To a Page Header

Place a TemplateHole inside a Paragraph in the header (inline hole — can only accept inline content like Text, Image):

imgPara = Paragraph("");
append(imgPara,TemplateHole("HeaderImage"));

Key rules:

Holes inside Paragraphs are inline holes — they can only accept inline content (Text, Image)
A get<HoleId> method must return inline content (not a Paragraph or Table) for header holes
Do not use Table({...}) shorthand with TemplateHole — build via TableEntry + append(entry,hole)

DOCX Templates: TemplateText Spacers Between Holes

Word templates use TemplateText objects (containing Word XML paragraph spacing) between each TemplateHole. When adding new holes to a DOCX template, clone an existing spacer from the original template and insert it between holes to preserve correct formatting.

Creating Templates from Scratch

import mlreportgen.dom.*

tpl = Template("MyTemplate","pdf");
open(tpl);

% Add styles
ss = tpl.Stylesheet;
titleStyle = TemplateLinkedStyle("DocTitle");
titleStyle.Formats = [Bold(true),FontSize("24pt"),Color("navy"),HAlign("center")];
addStyle(ss,titleStyle);

bodyStyle = TemplateLinkedStyle("BodyText");
bodyStyle.Formats = [FontSize("11pt"),FontFamily("Calibri")];
addStyle(ss,bodyStyle);

% Add holes with default styles
titleHole = TemplateHole("Title");
titleHole.DefaultHoleStyleName = "DocTitle";
append(tpl,titleHole);

bodyHole = TemplateHole("Body");
bodyHole.DefaultHoleStyleName = "BodyText";
append(tpl,bodyHole);

close(tpl);

Critical: Style .Formats requires array [], not cell array {}. Use TemplateLinkedStyle for hole styles — linked styles work in all output formats.

Using a Created Template

doc = Document("OutputReport","pdf","MyTemplate.pdftx");
open(doc);
moveToNextHole(doc);
append(doc,"My Report Title");
moveToNextHole(doc);
append(doc,"Content inherits BodyText style.");
close(doc);

Applying Modified Templates

Option A — TemplateSrc on a standard reporter (no custom class needed):

ch = Chapter("My Chapter");
ch.TemplateSrc = "path/to/modified.pdftx";
sec = Section("Sub-section");
sec.TemplateSrc = "path/to/modified.pdftx";  % Must also set on nested reporters
add(ch,sec);
append(rpt,ch);

Scope: TemplateSrc applies only to the reporter it is set on. Set on both Chapter and Section for style changes to appear at all heading levels.

Option B — Custom Report class (via customizeReport):

mlreportgen.report.Report.customizeReport("+xyzco/@Report");
% Edit templates in +xyzco/@Report/resources/templates/
rpt = xyzco.Report("MyReport","pdf");  % Automatically uses custom templates

TOC Customization

Reporter Properties (Simple — No Template Edit)

toc = TableOfContents();
toc.Title = "Contents";
toc.NumberOfLevels = 4;
toc.LeaderPattern = "dots";
append(rpt,toc);

PDF: Template API with addStyle

TOC entry styles live in the Report template (not the TOC reporter template). Customize via addStyle with TemplateParagraphStyle:

import mlreportgen.report.*
import mlreportgen.dom.*

% Scaffold custom Report class (once)
Report.customizeReport(fullfile(pwd,"+mypkg/@Report"));

% Open the Report's PDF template
pdfTemplatePath = fullfile(pwd,"+mypkg","@Report",...
    "resources","templates","pdf","default.pdftx");
tmpPath = fullfile(tempdir,"toc_pdf_edited.pdftx");

tpl = Template(tmpPath,"pdf",pdfTemplatePath);
open(tpl);
ss = tpl.Stylesheet;

% Add TOC styles (addStyle — these are new, not replacements)
tocStyle1 = TemplateParagraphStyle("TOC1");
tocStyle1.Formats = [FontFamily("Helvetica"),FontSize("12pt"),Bold(true),...
    OuterMargin("6pt","3pt","0in","0in")];
addStyle(ss,tocStyle1);

tocStyle2 = TemplateParagraphStyle("TOC2");
tocStyle2.Formats = [FontFamily("Helvetica"),FontSize("11pt"),Bold(false),...
    OuterMargin("2pt","2pt","0.3in","0in")];
addStyle(ss,tocStyle2);

tocStyle3 = TemplateParagraphStyle("TOC3");
tocStyle3.Formats = [FontFamily("Helvetica"),FontSize("10pt"),Italic(true),...
    OuterMargin("1pt","1pt","0.6in","0in")];
addStyle(ss,tocStyle3);

close(tpl);
copyfile(tmpPath,pdfTemplatePath);

% Generate with custom Report class
rpt = mypkg.Report("my_report","pdf");
toc = TableOfContents();
toc.NumberOfLevels = 4;
append(rpt,toc);
% ... add chapters ...
close(rpt);

Key points:

Use addStyle (not replaceStyle) — TOC styles don't exist in default Report template
Style names are TOC1–TOC6 (no space)
OuterMargin(top,bottom,left,right) — third arg controls indentation
Do NOT edit the TOC reporter's own .pdftx — crashes MATLAB in R2026a

DOCX: Word COM/ActiveX (Required)

For Word output, TOC styles are named "TOC 1" through "TOC 9" (with space). Word COM/ActiveX is the only way to customize these. The Template API cannot modify them because:

TemplateParagraphStyle rejects spaces in names
addStyle/replaceStyle with "TOC1" creates a separate custom style Word ignores
TemplateDOCXStyle.Formats modifications don't persist

function customizeDocxTocStyles(templatePath)
%customizeDocxTocStyles Customize DOCX TOC styles via Word COM/ActiveX

% Copy to temp to avoid path issues (+ and @ in folder names)
tmpTemplate = fullfile(tempdir,"toc_dotx_com_edit.dotx");
copyfile(templatePath,tmpTemplate);

wordApp = actxserver('Word.Application');
wordApp.Visible = false;

doc = wordApp.Documents.Open(tmpTemplate);
styles = doc.Styles;

% TOC 1: Bold, 12pt Calibri, no indent
toc1 = styles.Item('TOC 1');
toc1.Font.Name = 'Calibri';
toc1.Font.Size = 12;
toc1.Font.Bold = true;
toc1.ParagraphFormat.LeftIndent = 0;
toc1.ParagraphFormat.SpaceBefore = 6;
toc1.ParagraphFormat.SpaceAfter = 3;

% TOC 2: Regular, 11pt, 0.3in indent (21.6pt)
toc2 = styles.Item('TOC 2');
toc2.Font.Name = 'Calibri';
toc2.Font.Size = 11;
toc2.Font.Bold = false;
toc2.ParagraphFormat.LeftIndent = 21.6;
toc2.ParagraphFormat.SpaceBefore = 2;
toc2.ParagraphFormat.SpaceAfter = 2;

% TOC 3: Italic, 10pt, 0.6in indent (43.2pt)
toc3 = styles.Item('TOC 3');
toc3.Font.Name = 'Calibri';
toc3.Font.Size = 10;
toc3.Font.Italic = true;
toc3.ParagraphFormat.LeftIndent = 43.2;

doc.Save();
doc.Close();
wordApp.Quit();
delete(wordApp);

copyfile(tmpTemplate,templatePath);
delete(tmpTemplate);
end

Key points — DOCX TOC:

Style names are 'TOC 1'–'TOC 9' (with space) via styles.Item('TOC 1')
LeftIndent in points (72pt = 1in): 0.3in = 21.6pt
Font.Size in points (not half-points)
Do NOT use Font.Color — throws "Ambiguous property" error
Copy .dotx to tempdir first — Word COM has issues with +/@ in paths

Style Name Differences by Format

TOC Level	PDF Style	DOCX Style (COM)
1	`TOC1`	`'TOC 1'`
2	`TOC2`	`'TOC 2'`
3	`TOC3`	`'TOC 3'`
4	`TOC4`	`'TOC 4'`

Editing Children (Read-Only Property)

The Children property on DOM objects is read-only. To restructure, create a new object and clone:

% WRONG: section1.Children = [newChild; section1.Children];  % Errors

% CORRECT: rebuild from fresh object
newSection = TemplateDocumentPart("Section1");
append(newSection,myNewParagraph);
for k = 1:numel(section1.Children)
    append(newSection,clone(section1.Children(k)));
end
tpl.TemplateDocumentParts(1) = newSection;

Always use clone() when copying children — DOM objects cannot belong to two parents.

Discovering Which Style Controls a Hole

Use TemplateHole.DefaultHoleStyleName:

dps = tpl.TemplateDocumentParts;
for i = 1:numel(dps)
    queue = {dps(i)};
    while ~isempty(queue)
        node = queue{1}; queue(1) = [];
        if isa(node,"mlreportgen.dom.TemplateHole")
            fprintf("Hole: %-12s  Style: %s\n",node.Id,node.DefaultHoleStyleName);
        end
        if isprop(node,"Children")
            for j = 1:numel(node.Children)
                queue{end+1} = node.Children(j); %#ok
            end
        end
    end
end

Determining Which Styles Are Referenced

Walk TemplateDocumentParts to find style references (via StyleName, DefaultHoleStyleName, and DOCX DOCXText):

import mlreportgen.dom.*

tpl = Template(fullfile(tempdir,"inspect.pdftx"),"pdf",srcPath);
open(tpl);

dps = tpl.TemplateDocumentParts;
referencedStyles = string.empty;

for i = 1:numel(dps)
    queue = {dps(i)};
    while ~isempty(queue)
        node = queue{1}; queue(1) = [];
        if isprop(node,"StyleName") && ~isempty(node.StyleName)
            referencedStyles(end+1) = string(node.StyleName); %#ok
        end
        if isprop(node,"DefaultHoleStyleName") && ~isempty(node.DefaultHoleStyleName)
            referencedStyles(end+1) = string(node.DefaultHoleStyleName); %#ok
        end
        if isa(node,"mlreportgen.dom.TemplateText") && isprop(node,"DOCXText") ...
                && ~isempty(node.DOCXText)
            txt = string(node.DOCXText);
            for pat = ["<w:pStyle w:val=""([^""]*)""",...
                       "<w:rStyle w:val=""([^""]*)""",...
                       "<w:tblStyle w:val=""([^""]*)"""]
                toks = regexp(txt,pat,"tokens");
                for j = 1:numel(toks)
                    referencedStyles(end+1) = string(toks{j}{1}); %#ok
                end
            end
        end
        if isa(node,"mlreportgen.dom.DOCXSection")
            for h = 1:numel(node.PageHeaders)
                queue{end+1} = node.PageHeaders(h); %#ok
            end
            for f = 1:numel(node.PageFooters)
                queue{end+1} = node.PageFooters(f); %#ok
            end
        end
        if isprop(node,"Children")
            for j = 1:numel(node.Children)
                queue{end+1} = node.Children(j); %#ok
            end
        end
    end
end

close(tpl);
referencedStyles = unique(referencedStyles);

DOCX Style Property Extraction (XPath)

For a readable summary of DOCX style properties, use XPath:

function propsTable = extractDOCXStyleProperties(templatePath)
%extractDOCXStyleProperties Extract formatting properties from a DOTX template.
    arguments
        templatePath (1,1) string {mustBeFile}
    end

    import mlreportgen.dom.*
    import matlab.io.xml.dom.*
    import matlab.io.xml.xpath.*

    unzipDir = fullfile(tempdir,"dotx_style_extract");
    if isfolder(unzipDir), rmdir(unzipDir,"s"); end
    unzip(templatePath,unzipDir);

    stylesFile = fullfile(unzipDir,"word","styles.xml");
    if ~isfile(stylesFile)
        propsTable = table.empty;
        return
    end

    parser = Parser;
    stylesDoc = parseFile(parser,stylesFile);

    outPath = fullfile(tempdir,"inspect_props.dotx");
    tpl = mlreportgen.dom.Template(outPath,"docx",templatePath);
    open(tpl);
    ts = tpl.Stylesheet.TemplateStyles;
    close(tpl);

    evaluator = Evaluator;
    NodeSet = EvalResultType.NodeSet;

    numStyles = numel(ts);
    names = strings(numStyles,1);
    types = strings(numStyles,1);
    properties = strings(numStyles,1);

    for i = 1:numStyles
        names(i) = string(ts(i).Name);
        types(i) = string(ts(i).Type);

        xpath = sprintf( ...
            "//*[local-name()=""style""][*[local-name()=""name""][@*[local-name()=""val""]=""%s""]]",...
            ts(i).Name);
        result = evaluate(evaluator,xpath,stylesDoc,NodeSet);
        if isempty(result), continue; end
        styleNode = result(1);

        propParts = string.empty;

        % Font
        fontResult = evaluate(evaluator,...
            ".//*[local-name()=""rFonts""]/@*[local-name()=""ascii""]",styleNode,NodeSet);
        if ~isempty(fontResult)
            propParts(end+1) = "font:" + string(fontResult(1).Value);
        end

        % Size (half-points → points)
        sizeResult = evaluate(evaluator,...
            ".//*[local-name()=""sz""]/@*[local-name()=""val""]",styleNode,NodeSet);
        if ~isempty(sizeResult)
            halfPts = str2double(string(sizeResult(1).Value));
            propParts(end+1) = "size:" + num2str(halfPts/2) + "pt";
        end

        % Bold
        boldResult = evaluate(evaluator,...
            ".//*[local-name()=""rPr""]/*[local-name()=""b""]",styleNode,NodeSet);
        if ~isempty(boldResult)
            propParts(end+1) = "bold";
        end

        % Color
        colorResult = evaluate(evaluator,...
            ".//*[local-name()=""color""]/@*[local-name()=""val""]",styleNode,NodeSet);
        if ~isempty(colorResult)
            colorVal = string(colorResult(1).Value);
            if colorVal ~= "auto"
                propParts(end+1) = "color:#" + colorVal;
            end
        end

        if ~isempty(propParts)
            properties(i) = join(propParts,"; ");
        end
    end

    propsTable = table(names,types,properties,...
        "VariableNames",{"Name","Type","Properties"});
end

Note: Unzipping .dotx for read-only styles.xml inspection is acceptable. The prohibition on unzipping applies to structural editing.

PDF Template File Structure

default/
├── root.html                  # Main template
├── docpart_templates.html     # Doc part library (headers, footers, sections)
├── stylesheets/
│   └── root.css               # Styles for all template content
└── images/
    └── (static images)

Style Types for Template Creation

Class	Purpose
`TemplateLinkedStyle`	Paragraph + text combined (preferred for hole styles)
`TemplateParagraphStyle`	Paragraph-level only
`TemplateTextStyle`	Inline text only
`TemplateTableStyle`	Table formatting
`TemplateOrderedListStyle`	Numbered lists
`TemplateUnorderedListStyle`	Bulleted lists

All use .Formats = [...] (array syntax, not cell array).

Filling Holes with Multiple Items (Cell Arrays)

A single hole can receive multiple DOM objects via a cell array:

Reporter property assignment:

ch.SummaryContent = {Heading1("Key Findings"),resultsTable,Paragraph("See appendix.")};

get<HoleId>() method return:

function content = getSummary(obj,~)
    import mlreportgen.dom.*
    content = {Heading1("Results"),obj.ResultsTable,Paragraph(obj.Notes)};
end

Common Mistakes

Mistake	Correct Approach
`Template(path,"pdf")` to modify existing	Use 3-arg: `Template(out,"pdf",src)`
`getStyle(ss,name,type)` with type arg	Type returns `[]` in R2026a. Use `getStyle(ss,name)`
Setting `TemplateDOCXStyle.Formats`	Read-only. Create `TemplateLinkedStyle` + `replaceStyle`
`addStyle` for PDF/HTML style that exists	Modify `RawFormats` directly (handle object)
Unzipping template to edit structure	Use DOM Template API for all edits
`TemplateParagraphStyle.Formats = {Bold(true)}`	Use array: `Formats = [Bold(true)]`
Same source and output path	OPC can't read/write simultaneously. Different paths + `movefile`
`DOCXPageHeader` for PDF output	Use `PDFPageHeader`/`PDFPageFooter` for PDF
Modifying existing DOCX `TemplateText`	Create new `DOCXPageHeader` from DOM objects
Only modifying `SectionTitle1`	Modify all levels (1–6) for uniform appearance
Setting `TemplateSrc` on Chapter only	Set on both Chapter AND Section
Inspecting output to find "used" styles	Walk template doc parts for actual references
Editing TOC reporter's `.pdftx` template	Crashes MATLAB R2026a. Edit Report template instead
`TemplateParagraphStyle("TOC 1")` for DOCX	Rejects spaces. Use Word COM: `styles.Item('TOC 1')`
Replacing heading style without `OutlineLevel`	TOC breaks. Always include `OutlineLevel(N)`

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

MathWorks

Publisher

MathWorks (Official)

Source

matlab/matlab-agentic-toolkit · skills-catalog/reporting-and-database-access/matlab-generate-report · commit 2a7f215

Licence

BSD 2-Clause License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE.md)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by MathWorks.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download matlab-generate-report.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by MathWorks

MATLAB Report Generation

When to Use

When NOT to Use

API Selection

Core Workflow: Standard Report

Core Workflow: Simulink Report

Choosing Built-In vs Custom Reporters

Decision Tree: What Reference Do I Need?

Key Functions

Common Mistakes

Conventions

Viewing and Processing Reports

Required Toolbox

Files

references/template-system.md

Template System

Template File Types

The 3-Argument Template Constructor

Locating Templates

Inspecting Templates

Template Inheritance Model

Style Object Types by Format

Modifying Styles — PDF and HTML

Modifying Styles — DOCX

Style Class Selection

CRITICAL: Heading Styles and TOC (OutlineLevel)

DOCX Table Styles (TemplateTableStyle)

Identifying Current DOCX Formats from styles.xml

Multi-Level Headings

Modifying Page Headers and Footers

Access Pattern

Replacing a Footer (Adding Page Numbers)

Multi-Column Header Layout (3-Column Centering)

Word-Specific Header Rules

PDF Header/Footer Doc Parts (Section/Chapter Templates)

Special Elements in PDF Templates

Adding Holes to Templates

To a Document Part Body

To a Page Header

DOCX Templates: TemplateText Spacers Between Holes

Creating Templates from Scratch

Using a Created Template

Applying Modified Templates

TOC Customization

Reporter Properties (Simple — No Template Edit)

PDF: Template API with addStyle

DOCX: Word COM/ActiveX (Required)

Style Name Differences by Format

Editing Children (Read-Only Property)

Discovering Which Style Controls a Hole

Determining Which Styles Are Referenced

DOCX Style Property Extraction (XPath)

PDF Template File Structure

Style Types for Template Creation

Filling Holes with Multiple Items (Cell Arrays)

Common Mistakes

Requirements and compatibility

Security

Attribution and licence

Related skills

Astropy

Pymatgen

Opentrons Integration

Relion

Qutip

Simpy

Download ZIP