OfficeIMO

https://officeimo.com/docs
Admin
OfficeIMO is a family of focused .NET libraries for creating, editing, and converting Office...
Tokens:34,666
Snippets:434
Trust Score:2.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install OfficeIMO.Word.Html

Source: https://officeimo.com/docs/getting-started/installation

Commands to add the OfficeIMO.Word.Html library to a .NET project.

```bash
dotnet add package OfficeIMO.Word.Html
```

```xml
<PackageReference Include="OfficeIMO.Word.Html" Version="1.0.13" />
```

--------------------------------

### Install OfficeIMO.Markdown

Source: https://officeimo.com/docs/getting-started/installation

Commands to add the OfficeIMO.Markdown library to a .NET project.

```bash
dotnet add package OfficeIMO.Markdown
```

```powershell
Install-Package OfficeIMO.Markdown
```

```xml
<PackageReference Include="OfficeIMO.Markdown" Version="0.6.6" />
```

--------------------------------

### Generate CONTRIBUTING Guide Scaffold

Source: https://officeimo.com/docs/markdown

Create a pre-built CONTRIBUTING guide scaffold using the ContributingScaffold class for a specified project.

```csharp
// Generate a CONTRIBUTING guide
var contributing = ContributingScaffold.Contributing("MyProject");
```

--------------------------------

### Install OfficeIMO.Word.Markdown

Source: https://officeimo.com/docs/getting-started/installation

Commands to add the OfficeIMO.Word.Markdown library to a .NET project.

```bash
dotnet add package OfficeIMO.Word.Markdown
```

```xml
<PackageReference Include="OfficeIMO.Word.Markdown" Version="1.0.13" />
```

--------------------------------

### Install OfficeIMO.Excel

Source: https://officeimo.com/docs/getting-started/installation

Commands to add the OfficeIMO.Excel library to a .NET project.

```bash
dotnet add package OfficeIMO.Excel
```

```powershell
Install-Package OfficeIMO.Excel
```

```xml
<PackageReference Include="OfficeIMO.Excel" Version="0.6.19" />
```

--------------------------------

### Install OfficeIMO.Word

Source: https://officeimo.com/docs/getting-started/installation

Commands to add the OfficeIMO.Word library to a .NET project.

```bash
dotnet add package OfficeIMO.Word
```

```powershell
Install-Package OfficeIMO.Word
```

```xml
<PackageReference Include="OfficeIMO.Word" Version="1.0.39" />
```

--------------------------------

### Install OfficeIMO.CSV

Source: https://officeimo.com/docs/getting-started/installation

Commands to add the OfficeIMO.CSV library to a .NET project.

```bash
dotnet add package OfficeIMO.CSV
```

```powershell
Install-Package OfficeIMO.CSV
```

```xml
<PackageReference Include="OfficeIMO.CSV" Version="0.1.19" />
```

--------------------------------

### Verify Installation

Source: https://officeimo.com/docs/getting-started/installation

Commands to verify that .NET packages and PowerShell modules are correctly installed.

```bash
dotnet build
```

```powershell
Import-Module PSWriteOffice
Get-Module PSWriteOffice
```

--------------------------------

### Generate a complete report

Source: https://officeimo.com/docs/pswriteoffice/word

A full example demonstrating document creation, data processing, and formatting.

```powershell
Import-Module PSWriteOffice

$doc = New-OfficeWord -Path "C:\Reports\ServerReport.docx" -PassThru

$doc | Add-OfficeWordParagraph -Text "Server Health Report" -Style Heading1 -Alignment Center

$date = Get-Date -Format "MMMM dd, yyyy"
$doc | Add-OfficeWordParagraph {
    Add-OfficeWordText -Text "Generated: $date" -Italic
}

$disks = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "DriveType=3"
$diskRows = $disks | ForEach-Object {
    [pscustomobject]@{
        Drive      = $_.DeviceID
        'Size GB'  = [math]::Round($_.Size / 1GB, 1)
        'Free GB'  = [math]::Round($_.FreeSpace / 1GB, 1)
        'Pct Free' = [math]::Round(($_.FreeSpace / $_.Size) * 100, 1)
    }
}

$doc | Add-OfficeWordSection {
    Add-OfficeWordParagraph -Text "Disk Usage" -Style Heading1
    Add-OfficeWordTable -InputObject $diskRows -Style "GridTable4Accent1"
}

$doc | Save-OfficeWord
Close-OfficeWord -Document $doc

Write-Host "Report saved to C:\Reports\ServerReport.docx"
```

--------------------------------

### Quick Start: Create Presentation with Slides and Text

Source: https://officeimo.com/docs/pswriteoffice/powerpoint

Create a new PowerPoint presentation, add a slide, and insert a text box and bullet points. Save the presentation using the pipeline.

```powershell
$ppt = New-OfficePowerPoint -FilePath .\status_update.pptx
$slide = Add-OfficePowerPointSlide -Presentation $ppt

Add-OfficePowerPointTextBox -Slide $slide -Text 'Weekly Status' -X 80 -Y 60 -Width 520 -Height 50
Add-OfficePowerPointBullets -Slide $slide -Bullets @(
    'Shipped the March release',
    'Closed 14 customer issues',
    'Finished security review follow up'
) -X 80 -Y 140 -Width 520 -Height 220

$ppt | Save-OfficePowerPoint
```

--------------------------------

### Add OfficeIMO.Word.Markdown Package

Source: https://officeimo.com/docs/converters/word-markdown

Install the OfficeIMO.Word.Markdown package using the .NET CLI.

```bash
dotnet add package OfficeIMO.Word.Markdown
```

--------------------------------

### Install OfficeIMO.Word.Html Package

Source: https://officeimo.com/docs/converters/word-html

Use the dotnet CLI to add the OfficeIMO.Word.Html package to your project. This package depends on OfficeIMO.Word, AngleSharp, and AngleSharp.Css.

```bash
dotnet add package OfficeIMO.Word.Html
```

--------------------------------

### Configure Page Setup for Printing

Source: https://officeimo.com/docs/excel/worksheets

Shows how to adjust page orientation, paper size, and scaling options for printing. Ensure the worksheet is loaded or created.

```csharp
sheet.PageSetup.Orientation = OrientationValues.Landscape;
sheet.PageSetup.PaperSize = 1;  // Letter
sheet.PageSetup.FitToWidth = 1;
sheet.PageSetup.FitToHeight = 0;  // 0 = as many pages as needed
```

--------------------------------

### PowerShell Example: Create Word Document

Source: https://officeimo.com/docs/getting-started/quickstart

This PowerShell script uses the PSWriteOffice module to create a Word document, add a heading, and a paragraph with bold text. Ensure PSWriteOffice is installed.

```PowerShell
Import-Module PSWriteOffice

# Create a Word document
$doc = New-OfficeWord -Path "Report.docx" -PassThru

$doc | Add-OfficeWordSection {
    Add-OfficeWordParagraph -Text "Hello from PowerShell!" -Style Heading1
}
$doc | Add-OfficeWordParagraph {
    Add-OfficeWordText -Text "Created with PSWriteOffice." -Bold
}

$doc | Save-OfficeWord
Close-OfficeWord -Document $doc
```

--------------------------------

### PowerShell Example: Create Excel Workbook

Source: https://officeimo.com/docs/getting-started/quickstart

This PowerShell script utilizes the PSWriteOffice module to create an Excel workbook, add a sheet named 'Summary', and set cell values for headers. Ensure PSWriteOffice is installed.

```PowerShell
# Create an Excel workbook
$excel = New-OfficeExcel -Path "Data.xlsx" -PassThru

$excel | Add-OfficeExcelSheet -Name "Summary" {
    Set-OfficeExcelCell -Address "A1" -Value "Metric"
    Set-OfficeExcelCell -Address "B1" -Value "Value"
}

$excel | Save-OfficeExcel
Close-OfficeExcel -Document $excel
```

--------------------------------

### Create a Word Document with Basic Formatting

Source: https://officeimo.com/docs/getting-started/quickstart

Use this snippet to create a new Word document, add paragraphs with text, apply bold formatting, set font properties, and insert a table. Ensure the OfficeIMO.Word NuGet package is installed.

```C#
using OfficeIMO.Word;

// Create a new document saved to disk
using var document = WordDocument.Create("HelloWorld.docx");

// Add a paragraph with text
document.AddParagraph("Hello, World!").Bold = true;

// Add more content
var paragraph = document.AddParagraph("This document was created with OfficeIMO.");
paragraph.FontFamily = "Calibri";
paragraph.FontSize = 14;
paragraph.Color = SixLabors.ImageSharp.Color.DarkBlue;

// Add a table
var table = document.AddTable(3, 3, WordTableStyle.TableGrid);
table.Rows[0].Cells[0].Paragraphs[0].Text = "Name";
table.Rows[0].Cells[1].Paragraphs[0].Text = "Role";
table.Rows[0].Cells[2].Paragraphs[0].Text = "Location";
table.Rows[1].Cells[0].Paragraphs[0].Text = "Alice";
table.Rows[1].Cells[1].Paragraphs[0].Text = "Developer";
table.Rows[1].Cells[2].Paragraphs[0].Text = "New York";
table.Rows[2].Cells[0].Paragraphs[0].Text = "Bob";
table.Rows[2].Cells[1].Paragraphs[0].Text = "Designer";
table.Rows[2].Cells[2].Paragraphs[0].Text = "London";

document.Save();
```

--------------------------------

### Configure IL Trimming

Source: https://officeimo.com/docs/getting-started/platform-support

Enable IL trimming for publishing trimmed applications. Start with a conservative configuration and test your workflows.

```xml
<PropertyGroup>
    <PublishTrimmed>true</PublishTrimmed>
    <TrimMode>link</TrimMode>
</PropertyGroup>
```

--------------------------------

### Insert Page Breaks

Source: https://officeimo.com/docs/word/paragraphs

Force content to start on a new page.

```csharp
document.AddParagraph("Content before break");
document.AddPageBreak();
document.AddParagraph("Content on next page");
```

--------------------------------

### Markdown Document Generation for AOT Experiments

Source: https://officeimo.com/docs/advanced/aot-trimming

This C# example demonstrates creating a Markdown document using OfficeIMO.Markdown, suitable for testing in a Native AOT compiled binary. It includes basic Markdown elements like headers, paragraphs, and tables.

```csharp
// Program.cs
using OfficeIMO.Markdown;

var doc = MarkdownDoc.Create()
    .H1("AOT Report")
    .P("Generated from a native AOT binary.")
    .Table(t => t
        .Headers("Metric", "Value")
        .Row("Startup", "< 10ms")
        .Row("Binary Size", "~8 MB")
    );

File.WriteAllText("report.md", doc.ToString());
```

--------------------------------

### Manage PSWriteOffice Module

Source: https://officeimo.com/docs/getting-started/installation

Commands to install and update the PSWriteOffice PowerShell module.

```powershell
Install-Module -Name PSWriteOffice -Scope CurrentUser
```

```powershell
Install-Module -Name PSWriteOffice -Scope AllUsers
```

```powershell
Update-Module -Name PSWriteOffice
```

--------------------------------

### Create an Excel Workbook

Source: https://officeimo.com/docs/getting-started/quickstart

Generates a new Excel workbook with a specified sheet name, sets header rows, populates data, and adds a SUM formula. Ensure the OfficeIMO.Excel NuGet package is installed.

```C#
using OfficeIMO.Excel;

// Create a workbook with one sheet
using var workbook = ExcelDocument.Create("Report.xlsx", "Sales");

// Access the first sheet
var sheet = workbook.Sheets[0];

// Set header row
sheet.Cells["A1"].Value = "Product";
sheet.Cells["B1"].Value = "Q1 Revenue";
sheet.Cells["C1"].Value = "Q2 Revenue";

// Set data rows
sheet.Cells["A2"].Value = "Widget A";
sheet.Cells["B2"].Value = 15000;
sheet.Cells["C2"].Value = 18000;

sheet.Cells["A3"].Value = "Widget B";
sheet.Cells["B3"].Value = 22000;
sheet.Cells["C3"].Value = 25000;

// Add a SUM formula
sheet.Cells["B4"].Value = "=SUM(B2:B3)";
sheet.Cells["C4"].Value = "=SUM(C2:C3)";

workbook.Save();
```

--------------------------------

### Custom Delimiters

Source: https://officeimo.com/docs/csv

Shows examples of creating CSV documents with different custom delimiters like tabs, semicolons, or pipes.

```APIDOC
## POST /api/csv/create-custom-delimiter

### Description
Creates a CSV document with a specified custom delimiter.

### Method
POST

### Endpoint
`/api/csv/create-custom-delimiter`

### Parameters
#### Request Body
- **delimiter** (char) - Required - The custom delimiter character (e.g., '\t' for tab, ';' for semicolon, '|' for pipe).

### Response
#### Success Response (200)
- **message** (string) - Confirmation message that the CSV document was created with the custom delimiter.

#### Response Example
```json
{
  "message": "CSV document created with tab delimiter."
}
```
```

--------------------------------

### TrimmerRoots.xml Example

Source: https://officeimo.com/docs/advanced/aot-trimming

This XML file defines which types within the DocumentFormat.OpenXml assembly should be preserved during trimming, specifically for Wordprocessing and Spreadsheet components.

```xml
<linker>
    <assembly fullname="DocumentFormat.OpenXml">
        <type fullname="DocumentFormat.OpenXml.Wordprocessing.*" preserve="all" />
        <type fullname="DocumentFormat.OpenXml.Spreadsheet.*" preserve="all" />
    </assembly>
</linker>
```

--------------------------------

### Generate System Inventory Report in Excel

Source: https://officeimo.com/docs/pswriteoffice/excel

This script creates an Excel file with two sheets: 'Disks' and 'Network'. The 'Disks' sheet lists logical disk information including drive letter, label, total size, and free space. The 'Network' sheet lists active network adapters and their IPv4 addresses. Ensure the PSWriteOffice module is installed and the output directory exists.

```powershell
Import-Module PSWriteOffice

New-OfficeExcel -Path "C:\Reports\Inventory.xlsx" {
    Add-OfficeExcelSheet -Name "Disks" {
        Set-OfficeExcelCell -Address "A1" -Value "Drive"
        Set-OfficeExcelCell -Address "B1" -Value "Label"
        Set-OfficeExcelCell -Address "C1" -Value "Size (GB)"
        Set-OfficeExcelCell -Address "D1" -Value "Free (GB)"

        $disks = Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3"
        $row = 2
        foreach ($disk in $disks) {
            Set-OfficeExcelCell -Row $row -Column 1 -Value $disk.DeviceID
            Set-OfficeExcelCell -Row $row -Column 2 -Value $disk.VolumeName
            Set-OfficeExcelCell -Row $row -Column 3 -Value ([math]::Round($disk.Size / 1GB, 1))
            Set-OfficeExcelCell -Row $row -Column 4 -Value ([math]::Round($disk.FreeSpace / 1GB, 1))
            $row++
        }
    }

    Add-OfficeExcelSheet -Name "Network" {
        Set-OfficeExcelCell -Address "A1" -Value "Adapter"
        Set-OfficeExcelCell -Address "B1" -Value "IP Address"
        Set-OfficeExcelCell -Address "C1" -Value "Status"

        $adapters = Get-NetAdapter | Where-Object { $_.Status -eq 'Up' }
        $row = 2
        foreach ($adapter in $adapters) {
            $ip = (Get-NetIPAddress -InterfaceIndex $adapter.InterfaceIndex -AddressFamily IPv4 -ErrorAction SilentlyContinue).IPAddress
            Set-OfficeExcelCell -Row $row -Column 1 -Value $adapter.Name
            Set-OfficeExcelCell -Row $row -Column 2 -Value $(if ($ip) { $ip } else { "N/A" })
            Set-OfficeExcelCell -Row $row -Column 3 -Value $adapter.Status
            $row++
        }
    }
}
```

--------------------------------

### Create a Basic Visio Diagram

Source: https://officeimo.com/docs/visio

Initializes a new VSDX file, adds a page, places shapes, and links them with connectors.

```csharp
using OfficeIMO.Visio;

using var diagram = VisioDiagram.Create("topology.vsdx");
var page = diagram.AddPage("System Overview");

var frontend = page.AddShape("Frontend", 2.0, 8.0);
var api = page.AddShape("API", 5.0, 8.0);
var database = page.AddShape("Database", 8.0, 8.0);

page.AddConnector(frontend, api, "HTTPS");
page.AddConnector(api, database, "SQL");

diagram.Save();
```

--------------------------------

### Create and Save an Excel Workbook

Source: https://officeimo.com/docs/excel

Demonstrates initializing a new workbook, adding a worksheet, populating cells, and saving the file to disk.

```csharp
using OfficeIMO.Excel;

// Create with a file path
using var workbook = ExcelDocument.Create("report.xlsx");
var sheet = workbook.AddWorkSheet("Sales");

sheet.Cells["A1"].Value = "Product";
sheet.Cells["B1"].Value = "Revenue";
sheet.Cells["A2"].Value = "Widget A";
sheet.Cells["B2"].Value = 15000;

workbook.Save();
```

```csharp
using var workbook = ExcelDocument.Create("report.xlsx", "Sales");
var sheet = workbook.Sheets[0]; // "Sales" sheet
```

--------------------------------

### Generate README Scaffold

Source: https://officeimo.com/docs/markdown

Create a pre-built README file scaffold using the ReadmeScaffold class. Configure project details like description, license, and author.

```csharp
// Generate a README scaffold
var readme = ReadmeScaffold.Readme("MyProject", opts => {
    opts.Description = "A cross-platform library for data processing.";
    opts.License = "MIT";
    opts.Author = "Your Name";
});

File.WriteAllText("README.md", readme.ToString());
```

--------------------------------

### Create a Word Document

Source: https://officeimo.com/docs/pswriteoffice

Demonstrates creating a new Word document, adding paragraphs with styles, and saving the file.

```powershell
Import-Module PSWriteOffice

$doc = New-OfficeWord -Path "C:\Reports\Monthly.docx" -PassThru

$doc | Add-OfficeWordParagraph -Text "Monthly Status Report" -Style Heading1
$doc | Add-OfficeWordParagraph -Text "Generated on $(Get-Date -Format 'yyyy-MM-dd')"
$doc | Add-OfficeWordParagraph {
    Add-OfficeWordText -Text "All systems operational." -Bold
}

$doc | Save-OfficeWord
Close-OfficeWord -Document $doc
```

--------------------------------

### Async Create Word Document from Markdown File

Source: https://officeimo.com/docs/converters/word-markdown

Asynchronously load a Markdown file and convert it into a Word document, saving the result as a .docx file. Ensure the document is properly disposed of.

```csharp
using var document = await "README.md".LoadFromMarkdownAsync();
document.Save("readme.docx");
```

--------------------------------

### Merge Cells Horizontally

Source: https://officeimo.com/docs/word/tables

Merges cells horizontally within a row. 'Restart' indicates the start of a merged block, and 'Continue' indicates subsequent cells in the merge.

```csharp
// Merge cells 0-2 in the first row (spans 3 columns)
table.Rows[0].Cells[0].HorizontalMerge = MergedCellValues.Restart;
table.Rows[0].Cells[1].HorizontalMerge = MergedCellValues.Continue;
table.Rows[0].Cells[2].HorizontalMerge = MergedCellValues.Continue;
```

--------------------------------

### Creating a CSV Document

Source: https://officeimo.com/docs/csv

Demonstrates how to create a new CSV document, set delimiters and headers, add rows, and save the document.

```APIDOC
## POST /api/csv/create

### Description
Creates a new CSV document programmatically, allowing specification of delimiters, headers, and data rows before saving.

### Method
POST

### Endpoint
`/api/csv/create`

### Parameters
#### Request Body
- **delimiter** (string) - Optional - The character used to separate values in the CSV.
- **header** (array of strings) - Optional - The column headers for the CSV.
- **rows** (array of arrays of strings) - Optional - The data rows for the CSV.

### Request Example
```json
{
  "delimiter": ",",
  "header": ["Name", "Age", "City"],
  "rows": [
    ["Alice", "30", "New York"],
    ["Bob", "25", "London"],
    ["Carol", "35", "Tokyo"]
  ]
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message that the CSV was created and saved.

#### Response Example
```json
{
  "message": "CSV file 'people.csv' saved successfully."
}
```
```

--------------------------------

### Create a PowerPoint presentation

Source: https://officeimo.com/docs/powerpoint

Initializes a new presentation, defines layout margins, and adds a slide with a title and bulleted text.

```csharp
using OfficeIMO.PowerPoint;

using var presentation = PowerPointPresentation.Create("status-update.pptx");
const double marginCm = 1.5;

var content = presentation.SlideSize.GetContentBoxCm(marginCm);
var slide = presentation.AddSlide();

var title = slide.AddTitleCm(
    "Weekly Status",
    content.LeftCm,
    content.TopCm,
    content.WidthCm,
    1.4);

if (title.Paragraphs.Count > 0)
{
    PowerPointTextStyle.Title.WithColor("1F4E79").Apply(title.Paragraphs[0]);
}

var agenda = slide.AddTextBoxCm(
    string.Empty,
    content.LeftCm,
    content.TopCm + 2.0,
    content.WidthCm,
    content.HeightCm - 2.0);

agenda.AddBullets(new[]
{
    "Deployment completed successfully",
    "Customer onboarding toolkit updated",
    "Performance metrics improved week over week"
});

presentation.Save();
```

--------------------------------

### Import DataTable into Excel Sheet

Source: https://officeimo.com/docs/excel/tables-ranges

Import data from a `System.Data.DataTable` object into an Excel worksheet. Specify the starting cell and whether to include the column headers in the import.

```csharp
var dataTable = new System.Data.DataTable();
dataTable.Columns.Add("Name", typeof(string));
dataTable.Columns.Add("Value", typeof(double));
dataTable.Rows.Add("Item A", 100.5);
dataTable.Rows.Add("Item B", 200.75);

sheet.ImportDataTable(dataTable, startCell: "A1", includeHeaders: true);
```

--------------------------------

### Create and Format Paragraphs

Source: https://officeimo.com/docs/word/paragraphs

Initialize a document and add paragraphs with basic or chained formatting.

```csharp
using OfficeIMO.Word;

using var document = WordDocument.Create("paragraphs.docx");

// Simple text paragraph
document.AddParagraph("Hello, World!");

// Paragraph with chained formatting
var p = document.AddParagraph("Important Notice");
p.Bold = true;
p.FontSize = 16;
p.Color = SixLabors.ImageSharp.Color.Red;

document.Save();
```

--------------------------------

### Apply Conditional Formatting: Contains Text

Source: https://officeimo.com/docs/excel/tables-ranges

Apply formatting to cells that contain specific text. This example highlights cells containing 'Urgent' with a red background and white text.

```csharp
// Highlight cells with specific text
sheet.AddConditionalFormatting("A2:A100",
    ConditionalFormattingRuleType.ContainsText,
    text: "Urgent",
    backgroundColor: "FF0000",   // Red background
    fontColor: "FFFFFF");        // White text
```

--------------------------------

### Create and Add Worksheets

Source: https://officeimo.com/docs/excel/worksheets

Demonstrates how to create a new Excel workbook and add multiple worksheets with specified names. Ensure the file path is valid.

```csharp
using OfficeIMO.Excel;

using var workbook = ExcelDocument.Create("worksheets.xlsx");

// Add worksheets
var sheet1 = workbook.AddWorkSheet("Sales");
var sheet2 = workbook.AddWorkSheet("Inventory");
var sheet3 = workbook.AddWorkSheet("Summary");

workbook.Save();
```

--------------------------------

### Create an Excel Table with Data

Source: https://officeimo.com/docs/excel/tables-ranges

Create a new Excel workbook, add a worksheet, populate it with data, and then define a table over a specified range with a chosen style. Ensure the workbook is saved after creation.

```csharp
using OfficeIMO.Excel;

using var workbook = ExcelDocument.Create("tables.xlsx");
var sheet = workbook.AddWorkSheet("Sales");

// Populate data
sheet.Cells["A1"].Value = "Product";
sheet.Cells["B1"].Value = "Q1";
sheet.Cells["C1"].Value = "Q2";
sheet.Cells["A2"].Value = "Widget A";
sheet.Cells["B2"].Value = 15000;
sheet.Cells["C2"].Value = 18000;
sheet.Cells["A3"].Value = "Widget B";
sheet.Cells["B3"].Value = 22000;
sheet.Cells["C3"].Value = 25000;

// Create a table over the data range
sheet.AddTable("SalesTable", "A1:C3", TableStyle.Medium2);

workbook.Save();
```

--------------------------------

### Apply Conditional Formatting: Icon Sets

Source: https://officeimo.com/docs/excel/tables-ranges

Utilize icon sets to visually categorize data based on predefined thresholds. This example applies a 'Three Arrows' icon set to the specified range.

```csharp
// Icon sets
sheet.AddIconSet("E2:E100", IconSetType.ThreeArrows);
```

--------------------------------

### Create a Presentation and Add Title/Body Text

Source: https://officeimo.com/docs/powerpoint/slides

Initializes a new presentation and adds a title and a text box to the first slide. Ensures content box dimensions are calculated correctly for margin consistency.

```csharp
using OfficeIMO.PowerPoint;

using var presentation = PowerPointPresentation.Create("presentation.pptx");
const double marginCm = 1.5;

var content = presentation.SlideSize.GetContentBoxCm(marginCm);
var slide = presentation.AddSlide();

slide.AddTitleCm(
    "Quarterly Results",
    content.LeftCm,
    content.TopCm,
    content.WidthCm,
    1.4);

slide.AddTextBoxCm(
    "Generated from the reporting pipeline.",
    content.LeftCm,
    content.TopCm + 1.8,
    content.WidthCm,
    1.0);
```

--------------------------------

### Apply Conditional Formatting: Cell Is Greater Than

Source: https://officeimo.com/docs/excel/tables-ranges

Highlight cells within a range that meet a specific numerical condition, such as being greater than a threshold. This example sets the background color to green for values above 10000.

```csharp
// Highlight cells greater than a threshold
sheet.AddConditionalFormatting("B2:B100",
    ConditionalFormattingRuleType.CellIs,
    operatorValue: ConditionalFormattingOperator.GreaterThan,
    formula: "10000",
    backgroundColor: "92D050");  // Green
```

--------------------------------

### Generate CHANGELOG Scaffold

Source: https://officeimo.com/docs/markdown

Create a pre-built CHANGELOG file scaffold using the ChangelogScaffold class for a specified project.

```csharp
// Generate a CHANGELOG scaffold
var changelog = ChangelogScaffold.Changelog("MyProject");
```

--------------------------------

### Enable Trimming Polyfills

Source: https://officeimo.com/docs/advanced/aot-trimming

Add this to your project file to enable trimming polyfills, which can help with compatibility for certain OfficeIMO packages.

```xml
<PropertyGroup>
    <EnableTrimmingPolyfills>true</EnableTrimmingPolyfills>
</PropertyGroup>
```

--------------------------------

### Apply Conditional Formatting: Color Scale

Source: https://officeimo.com/docs/excel/tables-ranges

Implement a color scale on a range of cells to visually represent data distribution. This example creates a gradient from red (low values) to green (high values).

```csharp
// Color scale (gradient from red to green)
sheet.AddColorScale("C2:C100",
    minColor: "FF0000",   // Red for low values
    maxColor: "00FF00");  // Green for high values
```

--------------------------------

### Compose Documents via Pipeline

Source: https://officeimo.com/docs/pswriteoffice

Shows how to chain PSWriteOffice cmdlets using the pipeline for concise document generation.

```powershell
$doc = New-OfficeWord -Path "pipeline.docx" -PassThru

$doc |
    Add-OfficeWordParagraph -Text "Title" -Style Heading1 |
    Add-OfficeWordParagraph {
        Add-OfficeWordText -Text "Subtitle" -Italic
    } |
    Add-OfficeWordParagraph -Text "Chapter 1 content" |
    Save-OfficeWord

Close-OfficeWord -Document $doc
```

--------------------------------

### Create a New Excel Workbook

Source: https://officeimo.com/docs/pswriteoffice/excel

Initializes a new workbook file at the specified path.

```PowerShell
Import-Module PSWriteOffice

# Create a new workbook and return the workbook object
$excel = New-OfficeExcel -Path "C:\Output\data.xlsx" -PassThru
```

--------------------------------

### Create Word Document from Markdown with Options

Source: https://officeimo.com/docs/converters/word-markdown

Load Markdown content into a Word document using specified options for the conversion. This allows for customization of styles and fonts during the process.

```csharp
var options = new MarkdownToWordOptions {
    // Configure default styles, fonts, etc.
};

using var document = markdown.LoadFromMarkdown(options);
```

--------------------------------

### Create Markdown Document with Headings

Source: https://officeimo.com/docs/markdown/builder

Demonstrates creating a Markdown document and adding different levels of headings using the fluent API. The `MarkdownDoc` class is used for chaining methods.

```csharp
using OfficeIMO.Markdown;

var doc = MarkdownDoc.Create()
    .H1("Main Title")
    .H2("Section")
    .H3("Subsection")
    .H4("Sub-subsection")
    .H5("Minor heading")
    .H6("Smallest heading");
```

--------------------------------

### Create Definition List

Source: https://officeimo.com/docs/markdown/builder

Constructs a definition list using the `Dl` method, specifying terms and their definitions.

```csharp
doc.Dl(dl => dl
    .Term("API", "Application Programming Interface")
    .Term("SDK", "Software Development Kit")
);
```

--------------------------------

### Discover PSWriteOffice Commands

Source: https://officeimo.com/docs/pswriteoffice

Commands to list available cmdlets and retrieve help documentation.

```powershell
Get-Command -Module PSWriteOffice
```

```powershell
Get-Help New-OfficeWord -Full
Get-Help Add-OfficeWordParagraph -Examples
```

--------------------------------

### Create a Word Document using the Fluent API

Source: https://officeimo.com/docs/getting-started/quickstart

This snippet demonstrates creating a Word document with a fluent builder API, allowing for chained method calls to set document information, sections, and paragraphs. Requires OfficeIMO.Word and OfficeIMO.Word.Fluent.

```C#
using OfficeIMO.Word;
using OfficeIMO.Word.Fluent;

using var document = WordFluentDocument.Create("Fluent.docx")
    .Info(i => i.Title("My Report").Author("OfficeIMO"))
    .Section(s => s
        .Paragraph(p => p.Text("Introduction").Bold().FontSize(16))
        .Paragraph(p => p.Text("This report was generated programmatically."))
    )
    .Build();

document.Save();
```

--------------------------------

### Manage Slide Order and Reuse

Source: https://officeimo.com/docs/powerpoint/slides

Demonstrates how to manage slide order, hide slides, duplicate existing slides, and import slides from another presentation. Useful for creating templates and organizing presentations.

```csharp
var intro = presentation.AddSlide();
intro.AddTitleCm("Intro", content.LeftCm, content.TopCm, content.WidthCm, 1.4);

var duplicate = presentation.DuplicateSlide(0);
duplicate.Hidden = true;

using var source = PowerPointPresentation.Create("source-deck.pptx");
source.AddSlide().AddTitleCm("Imported slide", content.LeftCm, content.TopCm, content.WidthCm, 1.4);
source.Save();

presentation.ImportSlide(source, 0, insertAt: 1);
presentation.MoveSlide(2, 0);
```

--------------------------------

### Manage Bookmarks

Source: https://officeimo.com/docs/word/paragraphs

Define bookmarks for internal navigation.

```csharp
// Add a bookmark
document.AddBookmark("chapter1_bookmark");
document.AddParagraph("Chapter 1: Introduction");
```

--------------------------------

### Document Lifecycle Management

Source: https://officeimo.com/docs/pswriteoffice/word

Cmdlets for initializing, opening, saving, and closing Word documents.

```APIDOC
## New-OfficeWord

### Description
Creates a new Word document at the specified path.

### Parameters
- **Path** (String) - Required - The file path for the new .docx file.
- **PassThru** (Switch) - Optional - Returns the document object for further piping.

## Get-OfficeWord

### Description
Opens an existing Word document for editing.

### Parameters
- **Path** (String) - Required - The file path to the existing .docx file.

## Save-OfficeWord

### Description
Saves the current state of the document.

## Close-OfficeWord

### Description
Closes the document and releases resources.

### Parameters
- **Document** (Object) - Required - The document object to close.
```

--------------------------------

### Create a Word Table with Style

Source: https://officeimo.com/docs/word/tables

Creates a new Word document and adds a 4-row, 3-column table with the 'TableGrid' style. Populates the table with header and data rows.

```csharp
using OfficeIMO.Word;

using var document = WordDocument.Create("tables.docx");

// Create a 4-row, 3-column table with the TableGrid style
var table = document.AddTable(4, 3, WordTableStyle.TableGrid);

// Populate the header row
table.Rows[0].Cells[0].Paragraphs[0].Text = "Name";
table.Rows[0].Cells[1].Paragraphs[0].Text = "Department";
table.Rows[0].Cells[2].Paragraphs[0].Text = "Start Date";

// Populate data rows
table.Rows[1].Cells[0].Paragraphs[0].Text = "Alice";
table.Rows[1].Cells[1].Paragraphs[0].Text = "Engineering";
table.Rows[1].Cells[2].Paragraphs[0].Text = "2024-01-15";

table.Rows[2].Cells[0].Paragraphs[0].Text = "Bob";
table.Rows[2].Cells[1].Paragraphs[0].Text = "Design";
table.Rows[2].Cells[2].Paragraphs[0].Text = "2024-03-01";

table.Rows[3].Cells[0].Paragraphs[0].Text = "Carol";
table.Rows[3].Cells[1].Paragraphs[0].Text = "Marketing";
table.Rows[3].Cells[2].Paragraphs[0].Text = "2024-06-10";

document.Save();
```

--------------------------------

### Apply Formulas to Cells

Source: https://officeimo.com/docs/excel/worksheets

Shows how to set cell values using standard Excel formula syntax, including SUM, AVERAGE, IF, and COUNTIF. Ensure prerequisite cells have values.

```csharp
sheet.Cells["A1"].Value = 100;
sheet.Cells["A2"].Value = 200;
sheet.Cells["A3"].Value = 300;

// SUM formula
sheet.Cells["A4"].Value = "=SUM(A1:A3)";

// AVERAGE formula
sheet.Cells["A5"].Value = "=AVERAGE(A1:A3)";

// IF formula
sheet.Cells["B1"].Value = "=IF(A1>150,\"High\",\"Low\")";

// VLOOKUP, COUNTIF, and other functions work the same way
sheet.Cells["C1"].Value = "=COUNTIF(A1:A3,\">150\")";
```

--------------------------------

### Create Word Document from Markdown File

Source: https://officeimo.com/docs/converters/word-markdown

Load a Markdown file and convert it into a Word document, saving the result as a .docx file. Ensure the document is properly disposed of.

```csharp
using var document = WordMarkdownConverterExtensions.LoadFromMarkdown(
    "README.md"
);
document.Save("readme.docx");
```

--------------------------------

### Create Word Document from HTML with Options

Source: https://officeimo.com/docs/converters/word-html

Load HTML content into a Word document using custom options. Options include setting the default font family, including list styles, and specifying a base path for relative resources.

```csharp
using OfficeIMO.Word.Html;

var options = new HtmlToWordOptions {
    FontFamily = "Calibri",
    IncludeListStyles = true,
    BasePath = AppContext.BaseDirectory
};

using var document = html.LoadFromHtml(options);
```

--------------------------------

### Iterate Over Workbook Sheets

Source: https://officeimo.com/docs/excel/worksheets

Demonstrates how to load an existing Excel workbook and iterate through all its sheets, printing the name and row count of each. Ensure the 'data.xlsx' file exists.

```csharp
using var workbook = ExcelDocument.Load("data.xlsx");

foreach (var sheet in workbook.Sheets) {
    Console.WriteLine($"Sheet '{sheet.Name}' has data in {sheet.RowCount} rows");
}
```

--------------------------------

### Apply Number Formats to Cells

Source: https://officeimo.com/docs/excel/worksheets

Demonstrates applying custom and preset number formats to cells, including currency, dates, and percentages. Ensure the cell exists and has a value.

```csharp
// Currency format
sheet.Cells["B2"].NumberFormat = "$#,##0.00";

// Date format
sheet.Cells["B3"].NumberFormat = "yyyy-MM-dd";

// Percentage
sheet.Cells["B4"].NumberFormat = "0.00%";

// Use built-in presets
sheet.Cells["B5"].NumberPreset = ExcelNumberPreset.Currency;
```

--------------------------------

### Create Markdown Document with Fluent Builder

Source: https://officeimo.com/docs/markdown

Use the fluent builder API to programmatically compose Markdown documents. Chain methods like H1, P, and Code to construct the document structure.

```csharp
using OfficeIMO.Markdown;

var doc = MarkdownDoc.Create()
    .H1("Project README")
    .P("A short description of the project.")
    .H2("Installation")
    .Code("bash", "dotnet add package MyProject")
    .H2("Usage")
    .P("Import the namespace and create an instance.")
    .Code("csharp", "var client = new MyClient();")
    .H2("License")
    .P("MIT License");

var markdown = doc.ToMarkdown();
Console.WriteLine(markdown);
```

--------------------------------

### Set Column Width and Auto-fit

Source: https://officeimo.com/docs/excel/worksheets

Demonstrates how to set a specific width for columns and how to auto-fit a column's width based on its content. Ensure the worksheet is loaded or created.

```csharp
// Set column width
sheet.SetColumnWidth("A", 25);
sheet.SetColumnWidth("B", 15);

// Auto-fit columns (requires data to be populated first)
sheet.AutoFitColumn("A");
```

--------------------------------

### Create a multi-section Markdown report

Source: https://officeimo.com/docs/pswriteoffice/markdown

Builds a report with multiple sections, a table of contents, and a callout block.

```powershell
$summary = Get-Process | Select-Object -First 5 Name, Id, CPU
$details = Get-Service | Select-Object -First 5 Name, Status, StartType

New-OfficeMarkdown -Path .\operations-report.md {
    MarkdownHeading -Level 1 -Text 'Operations Report'
    MarkdownTableOfContents -Title 'Contents' -MinLevel 2 -MaxLevel 2 -PlaceAtTop

    MarkdownHeading -Level 2 -Text 'Processes'
    MarkdownTable -InputObject $summary

    MarkdownHeading -Level 2 -Text 'Services'
    MarkdownTable -InputObject $details

    MarkdownCallout -Kind note -Title 'Next step' -Body 'Review the failed services before publishing.'
}
```

--------------------------------

### Load Existing Workbook

Source: https://officeimo.com/docs/excel

Opens an existing .xlsx file and iterates through its worksheets.

```csharp
using var workbook = ExcelDocument.Load("existing.xlsx");

foreach (var sheet in workbook.Sheets) {
    Console.WriteLine($"Sheet: {sheet.Name}");
}
```

--------------------------------

### Create a new Word document

Source: https://officeimo.com/docs/pswriteoffice/word

Initializes a new Word document at the specified path. Use -PassThru to return the document object for further operations.

```powershell
# Create a new document and return the document object
$doc = New-OfficeWord -Path "C:\Output\report.docx" -PassThru
```

--------------------------------

### Configure Cell Alignment and Text Wrapping

Source: https://officeimo.com/docs/excel/worksheets

Demonstrates how to set horizontal and vertical alignment for cell content, and enable text wrapping. Ensure the cell exists.

```csharp
sheet.Cells["A1"].HorizontalAlignment = HorizontalAlignmentValues.Center;
sheet.Cells["A1"].VerticalAlignment = VerticalAlignmentValues.Center;
sheet.Cells["A1"].WrapText = true;
```

--------------------------------

### Create Tables and Charts from Data

Source: https://officeimo.com/docs/powerpoint/slides

Generates a slide with a table populated from an array of objects, and another slide with a chart visualizing the same data. Demonstrates table formatting and chart data series creation.

```csharp
using OfficeIMO.PowerPoint;

var rows = new[] {
    new { Product = "Alpha", Q1 = 12, Q2 = 15, Q3 = 18, Q4 = 20 },
    new { Product = "Beta",  Q1 =  9, Q2 = 11, Q3 = 13, Q4 = 14 },
    new { Product = "Gamma", Q1 =  6, Q2 =  9, Q3 = 12, Q4 = 16 }
};

var tableSlide = presentation.AddSlide();
tableSlide.AddTitleCm("Sales by Product", content.LeftCm, content.TopCm, content.WidthCm, 1.4);

var table = tableSlide.AddTableCm(
    rows,
    options => {
        options.HeaderCase = HeaderCase.Title;
        options.PinFirst("Product");
    },
    includeHeaders: true,
    leftCm: content.LeftCm,
    topCm: content.TopCm + 2.0,
    widthCm: content.WidthCm,
    heightCm: 4.5);

table.SetColumnWidthsEvenly();

var chartSlide = presentation.AddSlide();
chartSlide.AddTitleCm("Quarterly Performance", content.LeftCm, content.TopCm, content.WidthCm, 1.4);

var chartData = new PowerPointChartData(
    rows.Select(r => r.Product),
    new[] {
        new PowerPointChartSeries("Q1", rows.Select(r => (double)r.Q1)),
        new PowerPointChartSeries("Q2", rows.Select(r => (double)r.Q2)),
        new PowerPointChartSeries("Q3", rows.Select(r => (double)r.Q3)),
        new PowerPointChartSeries("Q4", rows.Select(r => (double)r.Q4))
    });

chartSlide.AddChartCm(
    chartData,
    content.LeftCm,
    content.TopCm + 2.0,
    content.WidthCm,
    4.8);
chartSlide.Notes.Text = "Chart and table share the same source data.";
```

--------------------------------

### Create Word Document from Markdown Stream

Source: https://officeimo.com/docs/converters/word-markdown

Load Markdown content from a stream and convert it into a Word document, saving the result as a .docx file. Ensure the document and stream are properly disposed of.

```csharp
using var stream = File.OpenRead("document.md");
using var document = stream.LoadFromMarkdown();
document.Save("output.docx");
```

--------------------------------

### Configure Different First Page Headers/Footers

Source: https://officeimo.com/docs/word/headers-footers

Sets up a Word document to use a distinct header and footer for the first page. This is useful for title pages or chapter beginnings. Ensure 'AddHeadersAndFooters()' has been called.

```csharp
using var document = WordDocument.Create("first-page.docx");
document.AddHeadersAndFooters();
document.DifferentFirstPage = true;

// First page gets a special header
document.Header.First.AddParagraph("TITLE PAGE");

// All other pages get the default header
document.Header.Default.AddParagraph("Chapter 1 - Introduction");

document.AddParagraph("Title page content...");
document.AddPageBreak();
document.AddParagraph("Second page content...");

document.Save();
```

--------------------------------

### Set Image Description (Alt Text)

Source: https://officeimo.com/docs/word/images

Set alternative text for images to improve accessibility.

```csharp
var paragraph = document.AddParagraph();
paragraph.AddImage("chart.png", 400, 300,
    description: "Q4 revenue chart showing 15% growth");
```

--------------------------------

### Apply Heading Styles

Source: https://officeimo.com/docs/word/paragraphs

Assign predefined heading styles to paragraphs.

```csharp
var h1 = document.AddParagraph("Chapter 1");
h1.Style = WordParagraphStyles.Heading1;

var h2 = document.AddParagraph("Section 1.1");
h2.Style = WordParagraphStyles.Heading2;

var h3 = document.AddParagraph("Subsection 1.1.1");
h3.Style = WordParagraphStyles.Heading3;
```

--------------------------------

### Render document to HTML string

Source: https://officeimo.com/docs/markdown/builder

Converts the document to an HTML string with specific styling and table of contents configuration.

```csharp
string html = doc.ToHtml(new HtmlOptions {
    Style = HtmlStyle.GitHub,
    InjectTocAtTop = true,
    Prism = new PrismOptions { Enabled = true }
});
```

--------------------------------

### Create a CSV Document with Rows

Source: https://officeimo.com/docs/getting-started/quickstart

Generates a CSV file with a specified delimiter and header, then adds rows of data. Requires the OfficeIMO.CSV NuGet package.

```C#
using OfficeIMO.CSV;

var csv = new CsvDocument()
    .WithDelimiter(',')
    .WithHeader("Name", "Age", "City")
    .AddRow("Alice", "30", "New York")
    .AddRow("Bob", "25", "London")
    .AddRow("Carol", "35", "Tokyo");

csv.Save("people.csv");
```

--------------------------------

### Set Cell Background and Text Color

Source: https://officeimo.com/docs/excel/worksheets

Illustrates setting the background color of a cell and the color of the text within it using hexadecimal color codes. Ensure the cell exists.

```csharp
sheet.Cells["A1"].BackgroundColor = "4472C4";  // Blue background
sheet.Cells["A1"].ForegroundColor = "FFFFFF";   // White text
```

--------------------------------

### Loading a CSV File

Source: https://officeimo.com/docs/csv

Explains how to load a CSV file into memory or stream it for large datasets, with options for delimiter, header presence, and encoding.

```APIDOC
## GET /api/csv/load

### Description
Loads a CSV file. Supports loading the entire file into memory or using streaming mode for large files. Options include specifying the delimiter, header row presence, encoding, and load mode.

### Method
GET

### Endpoint
`/api/csv/load`

### Query Parameters
- **filePath** (string) - Required - The path to the CSV file to load.
- **delimiter** (char) - Optional - The delimiter character (defaults to ',').
- **hasHeaderRow** (boolean) - Optional - Indicates if the CSV has a header row (defaults to true).
- **encoding** (string) - Optional - The character encoding (e.g., "UTF8").
- **mode** (string) - Optional - Load mode: "InMemory" or "Stream" (defaults to "InMemory").

### Response
#### Success Response (200)
- **csvData** (object) - The loaded CSV data. Structure depends on the load mode.
  - **rows** (array of objects) - If Mode is InMemory, contains the rows.
  - **stream** (object) - If Mode is Stream, provides access to the streaming source.

#### Response Example (InMemory)
```json
{
  "csvData": {
    "rows": [
      { "Name": "Alice", "Age": "30" },
      { "Name": "Bob", "Age": "25" }
    ]
  }
}
```

#### Response Example (Stream)
```json
{
  "csvData": {
    "stream": { "message": "Streaming source available" }
  }
}
```
```

--------------------------------

### Set Document Properties

Source: https://officeimo.com/docs/word

Creates a Word document and sets its built-in document properties (like Title, Creator, Description) and application properties (like Company).

```csharp
using var document = WordDocument.Create("props.docx");

document.BuiltinDocumentProperties.Title = "Quarterly Report";
document.BuiltinDocumentProperties.Creator = "OfficeIMO";
document.BuiltinDocumentProperties.Description = "Q4 2025 financial summary";

document.ApplicationProperties.Company = "Evotec";

document.Save();
```

--------------------------------

### Create a Markdown Document

Source: https://officeimo.com/docs/getting-started/quickstart

This snippet shows how to programmatically generate a Markdown document with headings, paragraphs, tables, and unordered lists using the OfficeIMO.Markdown library. The output is a Markdown string that can be saved to a file.

```C#
using OfficeIMO.Markdown;

var doc = MarkdownDoc.Create()
    .H1("Project Status Report")
    .P("Generated automatically by OfficeIMO.Markdown.")
    .H2("Summary")
    .Table(t => t
        .Headers("Task", "Status", "Owner")
        .Row("Backend API", "Complete", "Alice")
        .Row("Frontend UI", "In Progress", "Bob")
        .Row("Documentation", "Planned", "Carol")
    )
    .H2("Notes")
    .Ul(ul => ul
        .Item("Sprint ends Friday")
        .Item("Demo scheduled for Monday")
    );

var markdown = doc.ToMarkdown();
File.WriteAllText("status.md", markdown);
```
Tokens:
Raw