### Document Initialization and Usage Example

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/struct.Document.html

Example demonstrating how to create a new PDF document, add a paragraph, and render it to a file.

```APIDOC
## §Example
```rust
// Load a font from the file system
let font_family = genpdfi::fonts::from_files("./fonts", "LiberationSans", None)
    .expect("Failed to load font family");
// Create a document and set the default font family
let mut doc = genpdfi::Document::new(font_family);
doc.push(genpdfi::elements::Paragraph::new("Document content"));
doc.render_to_file("output.pdf").expect("Failed to render document");
```
```

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

### Example: Analyze Text Coverage and Missing Characters

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Shows how to use `check_coverage` to get font support statistics for a string and how to check if all characters are supported or list the missing ones.

```rust
# use genpdfi::fonts::FontData
# let font_data = FontData::load("font.ttf", None).unwrap();
let coverage = font_data.check_coverage("Hello ăâîșț!");
println!("Coverage: {:.1}%", coverage.coverage_percent());
if !coverage.is_complete() {
    println!("Missing characters: {:?}", coverage.missing_chars());
}
```

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

### UnorderedList Examples

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.UnorderedList.html

Illustrative examples of using the UnorderedList struct.

```APIDOC
## Examples

### Basic Usage
```rust
use genpdfi::elements;
let mut list = elements::UnorderedList::new();
list.push(elements::Paragraph::new("first"));
list.push(elements::Paragraph::new("second"));
list.push(elements::Paragraph::new("third"));
```

### Custom Bullet Symbol
```rust
use genpdfi::elements;
let mut list = elements::UnorderedList::with_bullet("*");
list.push(elements::Paragraph::new("first"));
list.push(elements::Paragraph::new("second"));
list.push(elements::Paragraph::new("third"));
```

### Chained Method Calls
```rust
use genpdfi::elements;
let list = elements::UnorderedList::new()
    .element(elements::Paragraph::new("first"))
    .element(elements::Paragraph::new("second"))
    .element(elements::Paragraph::new("third"));
```

### Nested Lists
```rust
use genpdfi::elements;
let list = elements::UnorderedList::new()
    .element(
        elements::OrderedList::new()
            .element(elements::Paragraph::new("Sublist with bullet point"))
    )
    .element(
        elements::LinearLayout::vertical()
            .element(elements::Paragraph::new("Sublist without bullet point:"))
            .element(
                elements::OrderedList::new()
                    .element(elements::Paragraph::new("first"))
                    .element(elements::Paragraph::new("second"))
            )
    );
```
```

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

### Create StyledStr instances

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/style/struct.StyledStr.html

Examples showing how to instantiate StyledStr with different style effects and colors.

```rust
use genpdfi::style;
let ss1 = style::StyledStr::new("bold", style::Effect::Bold, None);
let ss2 = style::StyledStr::new("red", style::Color::Rgb(255, 0, 0), None);
```

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

### Create Example Bullet List

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.BulletPoint.html

This example demonstrates how to create a vertical layout with two bullet points, each with a custom bullet symbol. It requires importing elements from the genpdfi crate.

```rust
use genpdfi::elements;
let layout = elements::LinearLayout::vertical()
    .element(elements::BulletPoint::new(elements::Paragraph::new("first"))
        .with_bullet("a)"))
    .element(elements::BulletPoint::new(elements::Paragraph::new("second"))
        .with_bullet("b)"));
```

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

### Initialize Color Instances

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/style/enum.Color.html

Examples of creating Color instances using RGB, CMYK, and Greyscale variants.

```rust
let red = genpdfi::style::Color::Rgb(255, 0, 0);
let cyan = genpdfi::style::Color::Cmyk(255, 0, 0, 0);
let grey = genpdfi::style::Color::Greyscale(127);
```

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

### Create New OrderedList

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Initializes a new ordered list starting with the number 1. Use `with_start` for a different starting number.

```rust
pub fn new() -> OrderedList {
    OrderedList::with_start(1)
}
```

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

### Create OrderedList with Custom Start

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Creates a new ordered list that begins numbering from a specified `start` value. This is useful for continuing a list or starting with a non-default number.

```rust
pub fn with_start(start: usize) -> OrderedList {
    OrderedList {
        layout: LinearLayout::vertical(),
        number: start,
    }
}
```

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

### Create a new Paragraph with initial text

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Initialize a Paragraph with a single styled string. This is a convenient way to start a paragraph with some content.

```rust
pub fn new(text: impl Into<StyledString>) -> Paragraph {
    Paragraph {
        text: vec![text.into()],
        ..Default::default()
    }
}
```

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

### Create and populate a TableLayout

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Examples showing how to initialize a table and add rows using either setter methods or a chained builder pattern.

```rust
use genpdfi::elements;
let mut table = elements::TableLayout::new(vec![1, 1]);
table.set_cell_decorator(elements::FrameCellDecorator::new(true, true, false));
let mut row = table.row();
row.push_element(elements::Paragraph::new("Cell 1"));
row.push_element(elements::Paragraph::new("Cell 2"));
row.push().expect("Invalid table row");
```

```rust
use genpdfi::elements;
let table = elements::TableLayout::new(vec![1, 1])
    .row()
    .element(elements::Paragraph::new("Cell 1"))
    .element(elements::Paragraph::new("Cell 2"))
    .push()
    .expect("Invalid table row");
```

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

### Populate TableLayoutRow

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Examples showing how to add elements to a table row using either setter methods or a chained builder pattern.

```rust
use genpdfi::elements;
let mut table = elements::TableLayout::new(vec![1, 1]);
let mut row = table.row();
row.push_element(elements::Paragraph::new("Cell 1"));
row.push_element(elements::Paragraph::new("Cell 2"));
row.push().expect("Invalid table row");
```

```rust
use genpdfi::elements;
let table = elements::TableLayout::new(vec![1, 1])
    .row()
    .element(elements::Paragraph::new("Cell 1"))
    .element(elements::Paragraph::new("Cell 2"))
    .push()
    .expect("Invalid table row");
```

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

### Create an OrderedList with a custom start number

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.OrderedList.html

Use the `with_start()` constructor to create a new ordered list beginning with a specified number. Elements are added using `push()`.

```rust
use genpdfi::elements;
let mut list = elements::OrderedList::with_start(5);
list.push(elements::Paragraph::new("first"));
list.push(elements::Paragraph::new("second"));
list.push(elements::Paragraph::new("third"));
```

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

### Create an OrderedList with elements

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.OrderedList.html

Use the `new()` constructor to create a new ordered list starting at 1. Elements can be added using the `push()` method.

```rust
use genpdfi::elements;
let mut list = elements::OrderedList::new();
list.push(elements::Paragraph::new("first"));
list.push(elements::Paragraph::new("second"));
list.push(elements::Paragraph::new("third"));
```

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

### Manage LineStyle Properties

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/style.rs.html

Provides methods to get and set thickness and color for LineStyle instances.

```rust
impl LineStyle {
    /// Creates a new line style with default values.
    pub fn new() -> LineStyle {
        LineStyle::default()
    }

    /// Sets the line thickness.
    ///
    /// Setting this to 0.0 will not hide the line, rather it’s a special value that tells PDF
    /// viewers to render the line as 1px regardless of the display size and zoom.
    pub fn set_thickness(&mut self, thickness: impl Into<Mm>) {
        self.thickness = thickness.into();
    }

    /// Sets the line thickness and returns the line style.
    ///
    /// Setting this to 0.0 will not hide the line, rather it’s a special value that tells PDF
    /// viewers to render the line as 1px regardless of the display size and zoom.
    pub fn with_thickness(mut self, thickness: impl Into<Mm>) -> Self {
        self.set_thickness(thickness);
        self
    }

    /// Returns the line thickness.
    pub fn thickness(&self) -> Mm {
        self.thickness
    }

    /// Sets the line color.
    pub fn set_color(&mut self, color: Color) {
        self.color = color;
    }

    /// Sets the line color and returns the line style.
    pub fn with_color(mut self, color: Color) -> Self {
        self.set_color(color);
        self
    }

    /// Returns the line color.
    pub fn color(&self) -> Color {
        self.color
    }
}
```

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

### FramedElement Usage Examples

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.FramedElement.html

Demonstrates creating a framed element either by direct instantiation or by using the Element trait extension method.

```rust
use genpdfi::elements;
let p = elements::FramedElement::new(
    elements::Paragraph::new("text"),
);
```

```rust
use genpdfi::{elements, style, Element as _};
let p = elements::Paragraph::new("text").framed(style::LineStyle::new());
```

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

### Create a new Document with Default Font Family

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/lib.rs.html

Initializes a new `Document` instance with a specified default font family. This is the starting point for building a PDF.

```rust
let font_cache = fonts::FontCache::new(default_font_family);
Document {
    root: elements::LinearLayout::vertical(),
    title: String::new(),
    context: Context::new(font_cache),
    style: style::Style::new(),
    paper_size: PaperSize::A4.into(),
    decorator: None,
    conformance: None,
    creation_date: None,
    modification_date: None,
}
```

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

### Get First Layer

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/render/struct.Page.html

Returns the first layer of the page. This method assumes at least one layer exists.

```rust
pub fn first_layer(&self) -> Layer<'_>
```

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

### Example: Check for Romanian Character Support

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Demonstrates how to use the `has_glyph` method to check if a font supports specific characters, like Romanian diacritics.

```rust
# use genpdfi::fonts::FontData
# let font_data = FontData::load("font.ttf", None).unwrap();
if font_data.has_glyph('ă') {
    println!("Font supports Romanian characters!");
}
```

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

### Example of Text Segmentation

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Demonstrates how to use `segment_text` to break down a string into segments, each associated with a font from the fallback chain. Note that the actual font references in the output will depend on the loaded fonts.

```rust
# use genpdfi::fonts::{FontData, FontFallbackChain};
# let primary = FontData::load("font.ttf", None).unwrap();
# let fallback = FontData::load("fallback.ttf", None).unwrap();
let chain = FontFallbackChain::new(primary).with_fallback(fallback);
let segments = chain.segment_text("Hello мир!");
// Returns: [("Hello ", &primary_font), ("мир", &fallback_font), ("!", &primary_font)]
```

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

### Create an Unordered List with Custom Bullet

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

This example demonstrates creating an unordered list with a custom bullet symbol. The specific code for setting the custom bullet is not shown but implied by the description.

```rust
use genpdfi::elements;
```

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

### Get First Layer of Page

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns an immutable reference to the first layer of the page. Assumes the page has at least one layer.

```rust
pub fn first_layer(&self) -> Layer<'_> {
    Layer::new(self, self.layers.first())
}
```

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

### Example Usage of BulletPoint and Paragraph

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Demonstrates creating a vertical `LinearLayout` and adding two `BulletPoint` elements. Each `BulletPoint` contains a `Paragraph` and has a custom bullet symbol specified using `with_bullet`.

```rust
let layout = elements::LinearLayout::vertical()
    .element(elements::BulletPoint::new(elements::Paragraph::new("first"))
        .with_bullet("a)"))
    .element(elements::BulletPoint::new(elements::Paragraph::new("second"))
        .with_bullet("b)"));
```

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

### Get Next Layer or Add New

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns the next layer in sequence. If the current layer is the last one, a new layer is created and returned.

```rust
fn next_layer(&self, layer: &printpdf::PdfLayerReference) -> Layer<'_> {
    let layer = self.layers.next(layer).unwrap_or_else(|| {
        let layer = self
            .page
            .add_layer(format!("Layer {}", self.layers.len() + 1));
        self.layers.push(layer)
    });
    Layer::new(self, layer)
}
```

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

### Create a new PageBreak element

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.PageBreak.html

Use this to create a new page break element. No setup or imports are required beyond having the genpdfi crate available.

```rust
let pb = genpdfi::elements::PageBreak::new();
```

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

### Get First Page of PDF Document

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns an immutable reference to the first page of the PDF document. Assumes the document has at least one page.

```rust
pub fn first_page(&self) -> &Page {
    &self.pages[0]
}
```

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

### Create and Render a PDF Document

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/struct.Document.html

Load a font, create a new document, add a paragraph, and render to a file. Ensure fonts are loaded correctly and rendering is handled.

```rust
// Load a font from the file system
let font_family = genpdfi::fonts::from_files("./fonts", "LiberationSans", None)
    .expect("Failed to load font family");
// Create a document and set the default font family
let mut doc = genpdfi::Document::new(font_family);
doc.push(genpdfi::elements::Paragraph::new("Document content"));
doc.render_to_file("output.pdf").expect("Failed to render document");
```

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

### Create a new FontFallbackChain

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Initializes a font fallback chain with a primary font. This is the starting point for managing multiple fonts to ensure character coverage in documents.

```rust
pub fn new(primary: FontData) -> Self {
        Self {
            primary,
            fallbacks: Vec::new(),
        }
    }
```

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

### Get Document Font Cache

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/lib.rs.html

Retrieves a reference to the font cache used by the document. This can be used to get the default font or query glyph metrics.

```rust
&self.context.font_cache
```

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

### Create and populate a LinearLayout

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.LinearLayout.html

Demonstrates how to initialize a vertical layout and add elements using either mutable push calls or method chaining.

```rust
use genpdfi::elements;
let mut layout = elements::LinearLayout::vertical();
layout.push(elements::Paragraph::new("Test1"));
layout.push(elements::Paragraph::new("Test2"));
```

```rust
use genpdfi::elements;
let layout = elements::LinearLayout::vertical()
    .element(elements::Paragraph::new("Test1"))
    .element(elements::Paragraph::new("Test2"));
```

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

### Create StyledString Instances

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/style/struct.StyledString.html

Demonstrates how to create new StyledString instances with different styles (bold and color). Requires the `style` module to be in scope.

```rust
use genpdfi::style;
let ss1 = style::StyledString::new("bold".to_owned(), style::Effect::Bold, None);
let ss2 = style::StyledString::new("red".to_owned(), style::Color::Rgb(255, 0, 0), None);
```

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

### TypeId Function

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.FontData.html

Gets the TypeId of an object.

```APIDOC
## `type_id(&self) -> TypeId`

### Description
Gets the `TypeId` of `self`.
```

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

### Get Type ID

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/enum.PaperSize.html

Retrieves the TypeId of a type. This is part of the Any trait implementation.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId
}
```

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

### Style Manipulation and Properties

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/style.rs.html

This section details methods for combining styles, setting and getting various style properties such as bold, italic, underline, strikethrough, font size, line spacing, and color.

```APIDOC
## Style API

### Description
Provides methods to manage and query text styles.

### Methods

#### Combining Styles

- `pub fn and(mut self, style: impl Into<Style>) -> Style`
  Combines this style with the given style and returns the result.

- `pub fn combine(left: impl Into<Style>, right: impl Into<Style>) -> Style`
  Creates a new style by combining the given styles.

#### Getting Style Properties

- `pub fn color(&self) -> Option<Color>`
  Returns the outline color for this style, if set.

- `pub fn is_bold(&self) -> bool`
  Returns whether the bold text effect is set.

- `pub fn is_italic(&self) -> bool`
  Returns whether the italic text effect is set.

- `pub fn is_underline(&self) -> bool`
  Returns whether the underline text effect is set.

- `pub fn is_strikethrough(&self) -> bool`
  Returns whether the strikethrough text effect is set.

- `pub fn font_size(&self) -> u8`
  Returns the font size for this style in points, or 12 if no font size is set.

- `pub fn line_spacing(&self) -> f32`
  Returns the line spacing factor for this style, or 1 if no line spacing factor is set.

#### Setting Style Properties

- `pub fn set_bold(&mut self)`
  Sets the bold effect for this style.

- `pub fn bold(mut self) -> Style`
  Sets the bold effect for this style and returns it.

- `pub fn set_italic(&mut self)`
  Sets the italic effect for this style.

- `pub fn italic(mut self) -> Style`
  Sets the italic effect for this style and returns it.

- `pub fn set_underline(&mut self)`
  Sets the underline effect for this style.

- `pub fn underline(mut self) -> Style`
  Sets the underline effect for this style and returns it.

- `pub fn set_strikethrough(&mut self)`
  Sets the strikethrough effect for this style.

- `pub fn strikethrough(mut self) -> Style`
  Sets the strikethrough effect for this style and returns it.

- `pub fn set_font_family(&mut self, font_family: fonts::FontFamily<fonts::Font>)`
  Sets the font family for this style.

- `pub fn with_font_family(mut self, font_family: fonts::FontFamily<fonts::Font>) -> Style`
  Sets the font family for this style and returns it.

- `pub fn set_line_spacing(&mut self, line_spacing: f32)`
  Sets the line spacing factor for this style.

- `pub fn with_line_spacing(mut self, line_spacing: f32) -> Style`
  Sets the line spacing factor for this style and returns it.

- `pub fn set_font_size(&mut self, font_size: u8)`
  Sets the font size in points for this style.

- `pub fn with_font_size(mut self, font_size: u8) -> Style`
  Sets the font size in points for this style and returns it.

- `pub fn set_color(&mut self, color: Color)`
  Sets the outline color for this style.

- `pub fn with_color(mut self, color: Color) -> Self`
  Sets the outline color for this style and returns it.

### Other Methods

- `pub fn char_width(&self, font_cache: &fonts::FontCache, c: char) -> Mm`
  Calculates the width of the given character with this style using the data in the given font cache.
  If the font family is set, it must have been created by the given [`FontCache`][].
  [`FontCache`]: ../fonts/struct.FontCache.html

```

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

### Get Raw Font Data

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Retrieves the raw byte data for embedded fonts.

```APIDOC
## get_data

### Description
Gets the raw font data bytes for embedded fonts. Returns an error if called on a built-in font.

### Response
- **Result<&[u8], Error>** - The raw font bytes or an error if the font is built-in.
```

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

### Create StyledCow Instances

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/style/struct.StyledCow.html

Demonstrates creating StyledCow instances with different styles and colors. Ensure the Style enum or its variants are correctly imported.

```rust
use genpdfi::style;
let ss1 = style::StyledCow::new("bold", style::Effect::Bold, None);
let ss2 = style::StyledCow::new("red".to_owned(), style::Color::Rgb(255, 0, 0), None);
```

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

### Get Number of Layers

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns the current number of layers managed by the `Layers` collection.

```rust
pub fn len(&self) -> usize {
    self.0.borrow().len()
}
```

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

### Get Layer Count on Page

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns the total number of layers present on this page.

```rust
pub fn layer_count(&self) -> usize {
    self.layers.len()
}
```

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

### Get Font Descent

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Returns the descent for text with this font and the given font size.

```rust
pub fn descent(&self, font_size: u8) -> Mm
```

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

### Create and apply bold style to StyledStr

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/style/index.html

Demonstrates creating a bold style and applying it to a StyledStr. Also shows creating a StyledStr with a specific RGB color.

```rust
use genpdfi::style;
let style = style::Style::new().bold();
let ss1 = style::StyledStr::new("bold", style, None);
let ss2 = style::StyledStr::new("red", style::Color::Rgb(255, 0, 0), None);
```

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

### Get Font Ascent

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Returns the ascent for text with this font and the given font size.

```rust
pub fn ascent(&self, font_size: u8) -> Mm
```

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

### Get Layer Count

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/render/struct.Page.html

Returns the total number of layers present on the page as a usize.

```rust
pub fn layer_count(&self) -> usize
```

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

### UnorderedList Constructors

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.UnorderedList.html

Demonstrates how to create new UnorderedList instances.

```APIDOC
## `UnorderedList::new()`

### Description
Creates a new unordered list with the default bullet point symbol.

### Method
`pub fn new() -> UnorderedList`

### Endpoint
N/A (Struct method)

### Request Body
N/A

### Response
N/A

## `UnorderedList::with_bullet(bullet: impl Into<String>)`

### Description
Creates a new unordered list with the given bullet point symbol.

### Method
`pub fn with_bullet(bullet: impl Into<String>) -> UnorderedList`

### Parameters
#### Query Parameters
- **bullet** (String) - Required - The custom bullet symbol to use for the list.
```

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

### Create and Populate TableLayoutRow with Setters

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.TableLayoutRow.html

Demonstrates how to create a TableLayout, add a row, and populate it with elements using the `push_element` method. The row is then appended to the table.

```rust
use genpdfi::elements;
let mut table = elements::TableLayout::new(vec![1, 1]);
let mut row = table.row();
row.push_element(elements::Paragraph::new("Cell 1"));
row.push_element(elements::Paragraph::new("Cell 2"));
row.push().expect("Invalid table row");
```

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

### Initialize Layers with First Layer

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Creates a new `Layers` collection, initializing it with the first provided PDF layer reference.

```rust
pub fn new(layer: printpdf::PdfLayerReference) -> Self {
    Self(vec![LayerData::from(layer).into()].into())
}
```

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

### Get Kerning Data

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Retrieves kerning adjustments for a sequence of characters. Requires the FontCache that loaded the font.

```rust
pub fn kerning<I>(&self, font_cache: &FontCache, iter: I) -> Vec<f32>
where I: IntoIterator<Item = char>
```

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

### Get Font Glyph Height

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Retrieves the glyph height for text with this font and a given font size.

```rust
pub fn glyph_height(&self, font_size: u8) -> Mm
```

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

### Renderer Initialization and Configuration

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/render/struct.Renderer.html

Methods for creating and configuring a new PDF document renderer.

```APIDOC
## Renderer::new

### Description
Creates a new PDF document renderer with one page of the given size and the given title.

### Method
`pub fn new(size: impl Into<Size>, title: impl AsRef<str>) -> Result<Renderer, Error>`

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Renderer** (Renderer) - A new PDF document renderer.
- **Error** (Error) - An error if the renderer cannot be created.

#### Response Example
None
```

```APIDOC
## Renderer::with_conformance

### Description
Sets the PDF conformance for the generated PDF document.

### Method
`pub fn with_conformance(self, conformance: PdfConformance) -> Self`

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Self** (Renderer) - The renderer instance with updated conformance settings.

#### Response Example
None
```

```APIDOC
## Renderer::with_creation_date

### Description
Sets the creation date for the generated PDF document.

### Method
`pub fn with_creation_date(self, date: OffsetDateTime) -> Self`

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Self** (Renderer) - The renderer instance with the specified creation date.

#### Response Example
None
```

```APIDOC
## Renderer::with_modification_date

### Description
Sets the modification date for the generated PDF document.

### Method
`pub fn with_modification_date(self, date: OffsetDateTime) -> Self`

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Self** (Renderer) - The renderer instance with the specified modification date.

#### Response Example
None
```

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

### Get Last Layer Data

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns a clone of the last `LayerData` from the `Layers` collection. Assumes the collection is not empty.

```rust
pub fn last(&self) -> rc::Rc<LayerData> {
    self.0.borrow().last().unwrap().clone()
}
```

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

### Image Creation and Configuration

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.Image.html

Methods for initializing an Image object from various sources and configuring its layout properties.

```APIDOC
## Image Configuration Methods

### Description
Methods to create an Image instance and configure its display properties such as position, scale, alignment, rotation, and DPI.

### Methods
- **from_dynamic_image(data: DynamicImage) -> Result<Self, Error>** - Creates a new image from an already loaded image.
- **from_reader<R>(reader: R) -> Result<Self, Error>** - Creates a new image from the given reader.
- **from_path(path: impl AsRef<Path>) -> Result<Self, Error>** - Creates a new image by reading from the given path.
- **with_position(position: impl Into<Position>) -> Self** - Sets the position and returns the image.
- **with_scale(scale: impl Into<Scale>) -> Self** - Sets the scale and returns the image.
- **with_alignment(alignment: impl Into<Alignment>) -> Self** - Sets the alignment and returns the image.
- **with_clockwise_rotation(rotation: impl Into<Rotation>) -> Self** - Sets the clockwise rotation and returns the image.
- **with_dpi(dpi: f32) -> Self** - Sets the expected DPI and returns the image.

### Usage Example
```rust
use genpdfi::elements;
let image = elements::Image::from_path("examples/images/test_image.jpg")
      .expect("Failed to load test image")
      .with_alignment(genpdfi::Alignment::Center)
      .with_scale(genpdfi::Scale::new(0.5, 2.0));
```
```

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

### Create a New Style

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/style.rs.html

Initializes a new Style object with default settings. Use this as a base for applying custom styles.

```rust
pub fn new() -> Style {
    Style::default()
}
```

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

### Get First Layer Data

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns a clone of the first `LayerData` from the `Layers` collection. Assumes the collection is not empty.

```rust
pub fn first(&self) -> rc::Rc<LayerData> {
    self.0.borrow().first().unwrap().clone()
}
```

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

### BulletPoint Constructors and Methods

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.BulletPoint.html

Details on how to create and configure BulletPoint instances.

```APIDOC
## impl<E: Element> BulletPoint<E>

### `fn new(element: E) -> BulletPoint<E>`

Creates a new bullet point with the given element.

### `fn set_bullet(&mut self, bullet: impl Into<String>)`

Sets the bullet point symbol for this bullet point.

### `fn with_bullet(self, bullet: impl Into<String>) -> Self`

Sets the bullet point symbol for this bullet point and returns the bullet point.
```

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

### Get Font Line Height

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Calculates the line height for text using this font and a specified font size.

```rust
pub fn get_line_height(&self, font_size: u8) -> Mm
```

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

### Get Last Layer

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/render/struct.Page.html

Returns the last layer of the page. This method assumes at least one layer exists.

```rust
pub fn last_layer(&self) -> Layer<'_>
```

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

### Create and Style a Paragraph with Setters

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.Paragraph.html

Use the `default`, `push`, `push_styled`, and `set_alignment` methods to construct and configure a Paragraph. This approach is useful for building paragraphs incrementally.

```rust
use genpdfi::{elements, style};
let mut p = elements::Paragraph::default();
p.push("This is an ");
p.push_styled("important", style::Color::Rgb(255, 0, 0));
p.push(" message!");
p.set_alignment(genpdfi::Alignment::Center);
```

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

### GlyphCoverage: Get Covered Character Count

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Returns the number of unique characters from the analyzed text that have supported glyphs in the font.

```rust
pub fn covered_count(&self) -> usize {
        self.covered
    }
```

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

### Get Layer Data by Index

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Retrieves an optional clone of `LayerData` at the specified index. Returns `None` if the index is out of bounds.

```rust
pub fn get(&self, idx: usize) -> Option<rc::Rc<LayerData>> {
    self.0.borrow().get(idx).cloned()
}
```

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

### Create and Configure TableLayout with Setters

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.TableLayout.html

Use this method to create a TableLayout and then configure its cell decorator and add rows with elements. Ensure the number of elements per row matches the number of columns.

```rust
use genpdfi::elements;
let mut table = elements::TableLayout::new(vec![1, 1]);
table.set_cell_decorator(elements::FrameCellDecorator::new(true, true, false));
let mut row = table.row();
row.push_element(elements::Paragraph::new("Cell 1"));
row.push_element(elements::Paragraph::new("Cell 2"));
row.push().expect("Invalid table row");
```

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

### Create and Use FontFallbackChain

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.FontFallbackChain.html

Demonstrates how to create a FontFallbackChain with a primary font and multiple fallbacks, and how it automatically selects fonts for different characters.

```rust
use genpdfi::fonts::{FontData, FontFallbackChain};

let primary = FontData::load("NotoSans.ttf", None).unwrap();
let cyrillic = FontData::load("NotoSansCyrillic.ttf", None).unwrap();
let emoji = FontData::load("NotoEmoji.ttf", None).unwrap();

let chain = FontFallbackChain::new(primary)
    .with_fallback(cyrillic)
    .with_fallback(emoji);

// Automatically uses the right font for each character
let font_for_a = chain.find_font_for_char('a');      // Uses primary (Noto Sans)
let font_for_я = chain.find_font_for_char('я');      // Uses cyrillic fallback
let font_for_emoji = chain.find_font_for_char('😀'); // Uses emoji fallback
```

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

### Create New Page with Layer

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Internal constructor for creating a new `Page` instance. It initializes the page with a given layer and size.

```rust
fn new(
    page: printpdf::PdfPageReference,
    layer: printpdf::PdfLayerReference,
    size: Size,
) -> Page {
    Page {
        page,
        size,
        layers: Layers::new(layer),
    }
}
```

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

### Document Initialization and Management

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/lib.rs.html

Methods for creating a new document, managing fonts, and configuring hyphenation.

```APIDOC
## Document::new

### Description
Creates a new document instance with a specified default font family.

### Parameters
- **default_font_family** (fonts::FontFamily<fonts::FontData>) - Required - The font family to use as the default for the document.

## Document::add_font_family

### Description
Adds a font family to the document's internal font cache.

### Parameters
- **font_family** (fonts::FontFamily<fonts::FontData>) - Required - The font family to add.

### Response
- **fonts::FontFamily<fonts::Font>** - A reference to the added font family usable within this document.

## Document::set_hyphenator

### Description
Activates hyphenation for the document. Requires the 'hyphenation' feature to be enabled.

### Parameters
- **hyphenator** (hyphenation::Standard) - Required - The hyphenator instance to use.
```

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

### Get the list of fallback fonts

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Returns a slice containing all the fallback fonts configured in the chain, in the order they will be checked after the primary font.

```rust
pub fn fallbacks(&self) -> &[FontData] {
        &self.fallbacks
    }
```

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

### Get the primary font

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Returns a reference to the primary font in the fallback chain. This is the font that is always checked first for character glyphs.

```rust
pub fn primary(&self) -> &FontData {
        &self.primary
    }
```

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

### StyledCow Conversions

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/style.rs.html

Demonstrates various ways to convert different string types into StyledCow<'s>.

```APIDOC
## StyledCow Conversions

### Description
Provides implementations for converting various string and styled string types into `StyledCow<'s>`.

### Implementations

- `From<&'s str>`: Converts a string slice into `StyledCow<'s>` with default styling.
- `From<&'s String>`: Converts a reference to a String into `StyledCow<'s>` with default styling.
- `From<String>`: Converts an owned String into `StyledCow<'s>` with default styling.
- `From<StyledStr<'s>>`: Converts a `StyledStr<'s>` into `StyledCow<'s>`, preserving style and link information.
- `From<&'s StyledString>`: Converts a reference to a `StyledString` into `StyledCow<'s>`, preserving style and link information.
- `From<StyledString>`: Converts an owned `StyledString` into `StyledCow<'s>`, preserving style and link information.
```

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

### StyledCow::new

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/style/struct.StyledCow.html

Creates a new instance of a styled string.

```APIDOC
## pub fn new(s: impl Into<Cow<'s, str>>, style: impl Into<Style>, link: Option<String>) -> StyledCow<'s>

### Description
Creates a new styled string from the given string and style.

### Parameters
- **s** (impl Into<Cow<'s, str>>) - Required - The string content to be styled.
- **style** (impl Into<Style>) - Required - The style annotation to apply.
- **link** (Option<String>) - Optional - An optional link associated with the string.
```

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

### GlyphCoverage: Get Missing Characters

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Returns a slice containing all characters from the analyzed text that are not supported by the font (i.e., missing glyphs).

```rust
pub fn missing_chars(&self) -> &[char] {
        &self.missing_chars
    }
```

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

### Get PDF Font Reference

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Returns a reference to the embedded PDF font for a given Font, if available. Requires that load_pdf_fonts() has been called.

```rust
pub fn get_pdf_font(&self, font: Font) -> Option<&printpdf::IndirectFontRef> {
        self.pdf_fonts.get(font.idx)
    }
```

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

### Create Paragraph with Styled String

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Creates a new paragraph and immediately adds a styled string to it. This is a convenient way to initialize a paragraph with content.

```rust
pub fn styled_string(mut self, s: impl Into<String>, style: impl Into<Style>) -> Self {
        self.push_styled(s, style);
        self
    }
```

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

### Get Default Font Family

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Retrieves the default font family configured for this FontCache. Panics if no default font family has been set.

```rust
pub fn default_font_family(&self) -> FontFamily<Font> {
        self.default_font_family
            .expect("Invariant violated: no default font family for FontCache")
    }
```

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

### POST /render

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/lib.rs.html

Renders the configured document into a PDF file and writes it to the provided writer.

```APIDOC
## render

### Description
Renders the document into a PDF file and writes it to the given writer.

### Parameters
- **w** (impl io::Write) - Required - The writer to output the PDF data to.

### Response
- **Result<(), error::Error>** - Returns Ok(()) on success or an error if rendering fails.
```

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

### Create and Populate TableLayoutRow with Chained Methods

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.TableLayoutRow.html

Shows how to create a TableLayout and add a row with elements using chained method calls. This approach is more concise for simple row constructions.

```rust
use genpdfi::elements;
let table = elements::TableLayout::new(vec![1, 1])
    .row()
    .element(elements::Paragraph::new("Cell 1"))
    .element(elements::Paragraph::new("Cell 2"))
    .push()
    .expect("Invalid table row");
```

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

### Get Last Layer of Page

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/render.rs.html

Returns an immutable reference to the last layer of the page. Assumes the page has at least one layer.

```rust
pub fn last_layer(&self) -> Layer<'_> {
    Layer::new(self, self.layers.last())
}
```

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

### TableLayoutRow Construction and Usage

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Demonstrates how to create and populate a TableLayoutRow, and append it to a TableLayout.

```APIDOC
## TableLayoutRow API

### Description
A helper struct for populating a [`TableLayout`][]. It allows adding elements to a row before appending it to the table.

### Methods

#### `new(table_layout: &'a mut TableLayout) -> TableLayoutRow<'a>`

- **Description**: Creates a new `TableLayoutRow` associated with a mutable `TableLayout`.
- **Parameters**:
  - `table_layout` (&'a mut TableLayout) - A mutable reference to the `TableLayout` this row belongs to.

#### `push_element<E: IntoBoxedElement>(&mut self, element: E)`

- **Description**: Adds the given element to the current row.
- **Parameters**:
  - `element` (E: IntoBoxedElement) - The element to add to the row.

#### `element<E: IntoBoxedElement>(mut self, element: E) -> Self`

- **Description**: Adds the given element to this row and returns the row itself, allowing for chaining.
- **Parameters**:
  - `element` (E: IntoBoxedElement) - The element to add to the row.
- **Returns**: `Self` (the modified `TableLayoutRow`)

#### `push(self) -> Result<(), Error>`

- **Description**: Tries to append this row to the associated table. This method fails if the number of elements in the row does not match the number of columns in the table.
- **Returns**: `Result<(), Error>` - Ok(()) on success, or an Error if the row has an incorrect number of elements.

### Examples

#### Using setters:
```rust
use genpdfi::elements;
let mut table = elements::TableLayout::new(vec![1, 1]);
let mut row = table.row();
row.push_element(elements::Paragraph::new("Cell 1"));
row.push_element(elements::Paragraph::new("Cell 2"));
row.push().expect("Invalid table row");
```

#### Using chained methods:
```rust
use genpdfi::elements;
let table = elements::TableLayout::new(vec![1, 1])
    .row()
    .element(elements::Paragraph::new("Cell 1"))
    .element(elements::Paragraph::new("Cell 2"))
    .push()
    .expect("Invalid table row");
```

### Extend Implementation

Implements the `Extend` trait for `TableLayoutRow<'a>`, allowing elements to be added using iterators.

```rust
// Example of using extend (conceptual, requires a concrete iterator)
// let mut row = table.row();
// row.extend(vec![element1, element2]);
```
```

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

### Create a PaddedElement

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/elements/struct.PaddedElement.html

Demonstrates how to apply padding to an element using either the struct constructor or the trait method.

```rust
use genpdfi::elements;
let p = elements::PaddedElement::new(
    elements::Paragraph::new("text"),
    genpdfi::Margins::trbl(5, 2, 5, 10),
);
```

```rust
use genpdfi::{elements, Element as _};
let p = elements::Paragraph::new("text")
    .padded(genpdfi::Margins::trbl(5, 2, 5, 10));
```

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

### Get String Width

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Calculates the total width of a string for a given font and font size. Requires the FontCache that loaded the font.

```rust
pub fn str_width(&self, font_cache: &FontCache, s: &str, font_size: u8) -> Mm
```

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

### Get Character Left Side Bearing

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Calculates the horizontal space before a character's glyph. Requires the FontCache that loaded the font.

```rust
pub fn char_left_side_bearing(
 &self,
 font_cache: &FontCache,
 c: char,
 font_size: u8,
) -> Mm
```

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

### Create a vertical LinearLayout with setters

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/elements.rs.html

Use the `LinearLayout::vertical()` constructor and the `push` method to add elements sequentially to a vertical layout.

```rust
use genpdfi::elements;
let mut layout = elements::LinearLayout::vertical();
layout.push(elements::Paragraph::new("Test1"));
layout.push(elements::Paragraph::new("Test2"));
```

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

### Implement Metrics Operations

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Provides methods to initialize metrics and calculate the maximum values between two instances.

```rust
impl Metrics {
    /// Create a new metrics instance with the given heights.
    pub fn new(line_height: Mm, glyph_height: Mm, ascent: Mm, descent: Mm) -> Metrics {
        Metrics {
            line_height,
            glyph_height,
            ascent,
            descent,
        }
    }

    /// Returns the maximum metrics from two metrics instances.
    pub fn max(&self, other: &Self) -> Self {
        Self {
            line_height: self.line_height.max(other.line_height),
            glyph_height: self.glyph_height.max(other.glyph_height),
            ascent: self.ascent.max(other.ascent),
            descent: self.descent.max(other.descent),
        }
    }
}
```

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

### Get Character Width

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/fonts/struct.Font.html

Calculates the width of a single character for a given font and font size. Requires the FontCache that loaded the font.

```rust
pub fn char_width(&self, font_cache: &FontCache, c: char, font_size: u8) -> Mm
```

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

### Get Layer by Index

Source: https://docs.rs/genpdfi/0.2.7/genpdfi/render/struct.Page.html

Retrieves a specific layer from the page using its index. Returns an Option<Layer<'_>> which is None if the index is out of bounds.

```rust
pub fn get_layer(&self, idx: usize) -> Option<Layer<'_>>
```

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

### Font Initialization

Source: https://docs.rs/genpdfi/0.2.7/src/genpdfi/fonts.rs.html

Constructs a new Font instance by calculating metrics from a rusttype font.

```rust
impl Font {
    fn new(idx: usize, is_builtin: bool, rt_font: &rusttype::Font<'static>) -> Font {
        let units_per_em = rt_font.units_per_em();
        assert!(units_per_em != 0);

        let units_per_em = f32::from(units_per_em);
        let v_metrics = rt_font.v_metrics_unscaled();
        let glyph_height = (v_metrics.ascent - v_metrics.descent) / units_per_em;
        let scale = rusttype::Scale::uniform(glyph_height);

        let ascent = v_metrics.ascent / units_per_em;
        let descent = v_metrics.descent / units_per_em;
        let line_height = glyph_height + v_metrics.line_gap / units_per_em;

        Font {
            idx,
            is_builtin,
            scale,
            line_height: printpdf::Pt(f32::from(line_height)).into(),
            glyph_height: printpdf::Pt(f32::from(glyph_height)).into(),
            ascent: printpdf::Pt(f32::from(ascent)).into(),
            descent: printpdf::Pt(f32::from(descent)).into(),
        }
    }
```