Winprint

https://docs.rs/winprint/0.2.0
Admin
A Rust crate for printing to Windows printer devices using Windows API, supporting XPS, PDF, and...
Tokens:83,910
Snippets:832
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get Default Parameters

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Defines all parameters with their default values for the PrintCapabilities.

```rust
pub fn default_parameters(&self) -> impl Iterator<Item = ParameterInit> + '_

```

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

### Get Page Media Sizes

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page media sizes.

```rust
pub fn page_media_sizes(&self) -> impl Iterator<Item = PageMediaSize> + '_

```

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

### Example Usage of Copies Struct

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.Copies.html

Demonstrates how to create and use the `Copies` struct. This snippet shows instantiation and accessing the underlying value.

```rust
use winprint::ticket::Copies;

let copies = Copies(1);
assert_eq!(copies.0, 1);

```

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

### Get Options for a Feature

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves all available options for a given print feature by its name.

```rust
pub fn options_for_feature( &self, feature_name: OwnedName, ) -> impl Iterator<Item = &PrintFeatureOption> + '_

```

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

### Get Page Media Sizes

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page media sizes.

```APIDOC
## page_media_sizes

### Description
Get all page media sizes.

### Method
`pub fn page_media_sizes(&self) -> impl Iterator<Item = PageMediaSize> + '_`

### Response
#### Success Response
- **Iterator<Item = PageMediaSize>** - An iterator yielding `PageMediaSize` values.
```

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

### Get Media Size

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Retrieves the current media size of the PageMediaSize option.

```rust
pub fn size(&self) -> MediaSizeTuple
```

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

### Get Width and Height in Micron

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/media_size_tuple.rs.html

Provides constant time access to the width and height of the media size in micron.

```rust
pub const fn width_in_micron(&self) -> u32 {
        self.0
    }
```

```rust
pub const fn height_in_micron(&self) -> u32 {
        self.1
    }
```

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

### Write ParameterInit to XML

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/writer.rs.html

Serializes a ParameterInit struct into XML format using an EventWriter. It writes the start element, attributes, nested values, and the end element.

```rust
fn write_to<W: Write>(&self, writer: &mut EventWriter<W>) -> Result<(), xml::writer::Error> {
        writer.write(
            XmlEvent::start_element("psf:ParameterInit")
                .attr("name", format_name(&self.name).as_ref()),
        )?;
        self.value.write_to(writer)?;
        writer.write(XmlEvent::end_element())?;
        Ok(())
    }
```

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

### Get All Page Media Sizes

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/print_capabilities.rs.html

Returns an iterator over all supported page media sizes. This method relies on the `PageMediaSize::list` function.

```rust
PageMediaSize::list(self)
```

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

### Get Default Parameters with Filters

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Defines specified parameters with their default values, based on provided filters.

```rust
pub fn default_parameters_for<'a>( &'a self, filters: &'a [OwnedName], ) -> impl Iterator<Item = ParameterInit> + 'a

```

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

### PdfiumGuard Initialization and Management

Source: https://docs.rs/winprint/0.2.0/src/winprint/utils/pdfium/guard.rs.html

This snippet demonstrates the PdfiumGuard struct, which manages PDFium library initialization and destruction. It ensures that FPDF_InitLibrary is called only once and FPDF_DestroyLibrary is called when the guard is dropped. The `get` method provides a static, thread-safe instance, and `guard` ensures initialization before returning the lock.

```rust
use crate::bindings::pdfium::*
use std::sync::Mutex
use std::sync::MutexGuard
use std::sync::OnceLock

pub struct PdfiumGuard {
    inited: bool,
}

impl PdfiumGuard {
    fn new() -> PdfiumGuard {
        PdfiumGuard { inited: false }
    }
    pub fn init(&mut self) {
        if !self.inited {
            unsafe {
                FPDF_InitLibrary();
            }
            self.inited = true;
        }
    }
    #[allow(unused)]
    pub fn init_with_config(&mut self, config: &FPDF_LIBRARY_CONFIG) {
        if !self.inited {
            unsafe {
                FPDF_InitLibraryWithConfig(config);
            }
            self.inited = true;
        }
    }
    pub fn get() -> MutexGuard<'static, PdfiumGuard> {
        static PDFIUM_GUARD: OnceLock<Mutex<PdfiumGuard>> = OnceLock::new();
        PDFIUM_GUARD
            .get_or_init(|| Mutex::new(PdfiumGuard::new()))
            .lock()
            .unwrap()
    }
    pub fn guard() -> MutexGuard<'static, PdfiumGuard> {
        let mut x = Self::get();
        x.init();
        x
    }
}
impl Drop for PdfiumGuard {
    fn drop(&mut self) {
        if self.inited {
            unsafe {
                FPDF_DestroyLibrary();
            }
        }
    }
}
```

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

### Test Get Properties from Parameter Definition

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/print_schema.rs.html

Tests the `get_property` functionality by creating a `ParameterDef` and verifying its properties using `check_test_properties`.

```rust
#[test]
fn get_properties_from_parameter_def() {
    let parameter_def = super::ParameterDef {
        name: OwnedName::local("Test"),
        properties: new_test_properties(),
    };
    check_test_properties(&parameter_def);
}
```

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

### Create and Print PDF using WinPdfPrinter

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/win_pdf.rs.html

Demonstrates how to instantiate WinPdfPrinter, specify a PDF file path, and print the document. Requires the `WinPdfPrinter` and `Path` types.

```rust
let pdf = WinPdfPrinter::new(device);
let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("test_data/test_document.pdf");
pdf.print(path.as_path(), Default::default()).unwrap();
```

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

### Get Predefined Name for PageMediaSize

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Attempts to get the predefined name of the PageMediaSize option. Returns None if the option is not predefined.

```rust
fn as_predefined_name(&self) -> Option<Self::PredefinedName>
```

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

### Get All Supported Page Resolutions

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/print_capabilities.rs.html

Returns an iterator over all supported page resolutions. This method relies on the `PageResolution::list` function.

```rust
PageResolution::list(self)
```

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

### Initialize DirectX and Direct2D Devices

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/dxgi.rs.html

This snippet demonstrates the initialization of Direct3D 11 and Direct2D devices and contexts. It includes error handling for DirectX initialization failures and casting the Direct3D device to an IDXGIDevice.

```rust
            let mut d3d_device: Option<ID3D11Device> = None;
            let mut d3d_context: Option<ID3D11DeviceContext> = None;
            D3D11CreateDevice(
                None,
                D3D_DRIVER_TYPE_HARDWARE,
                None,
                D3D11_CREATE_DEVICE_BGRA_SUPPORT,
                None,
                D3D11_SDK_VERSION,
                Some(ptr::addr_of_mut!(d3d_device)),
                None,
                Some(ptr::addr_of_mut!(d3d_context)),
            )
            .map_err(DxgiPrintContextError::InitializeDirectX)?;
            let d3d_device = d3d_device.ok_or(DxgiPrintContextError::InitializeDirectX(
                windows::core::Error::from_hresult(E_UNEXPECTED),
            ))?;
            let d3d_context = d3d_context.ok_or(DxgiPrintContextError::InitializeDirectX(
                windows::core::Error::from_hresult(E_UNEXPECTED),
            ))?;
            let dxgi_device = d3d_device
                .cast::<IDXGIDevice>()
                .map_err(DxgiPrintContextError::InitializeDirectX)?;

            let d2d_factory_options = D2D1_FACTORY_OPTIONS::default();
            let d2d_factory: ID2D1Factory1 = D2D1CreateFactory(
                D2D1_FACTORY_TYPE_SINGLE_THREADED,
                Some(&d2d_factory_options),
            )
            .map_err(DxgiPrintContextError::InitializeDirectX)?;

            let d2d_device = d2d_factory
                .CreateDevice(&dxgi_device)
                .map_err(DxgiPrintContextError::InitializeDirectX)?;
            let d2d_context = d2d_device
                .CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE)
                .map_err(DxgiPrintContextError::InitializeDirectX)?;
```

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

### WithScoredProperties Trait Definition

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/trait.WithScoredProperties.html

Defines the interface for types that have scored properties. It includes a required method to get all properties and a provided method to get a specific property by name and optional namespace.

```rust
pub trait WithScoredProperties {
    // Required method
    fn scored_properties(&self) -> &[ScoredProperty];

    // Provided method
    fn get_scored_property(
        &self,
        name: &str,
        namespace: Option<&str>,
    ) -> Option<&ScoredProperty> {
        // ... implementation details ...
    }
}
```

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

### DxgiPrintContext::new Function

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/dxgi.rs.html

Creates a new DxgiPrintContext instance. This function initializes COM and sets up the necessary DirectX devices and factories for printing.

```rust
impl DxgiPrintContext {
    /// Create a new print context, used for printing via DXGI.
    pub fn new(
        device: &PrinterDevice,
        options: &PrintTicket,
        job_name: &OsStr,
    ) -> Result<Self, DxgiPrintContextError> {
        // Initialize COM before calling any COM functions.
        let _com_initializer = ComInitializer::new();
        unsafe {

```

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

### Write XML Start Element with Optional Name Attribute

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/writer.rs.html

Writes a start element to an `EventWriter`, optionally adding a 'name' attribute formatted using `format_name`. This function simplifies the creation of elements that may have a qualified name.

```rust
fn start_element_with_optional_name<W: Write>(
    writer: &mut EventWriter<W>,
    elem_name: &str,
    name: Option<&OwnedName>,
) -> Result<(), xml::writer::Error> {
    if let Some(name) = name {
        writer
            .write(XmlEvent::start_element(elem_name).attr("name", format_name(name).as_ref()))?;
    } else {
        writer.write(XmlEvent::start_element(elem_name))?;
    }
    Ok(())
}
```

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

### Get Printer Device OS Server

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.PrinterDevice.html

Retrieves a reference to the operating system's server name for the printer device as an OsStr.

```rust
pub fn os_server(&self) -> &OsStr
```

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

### XmlSerializer Implementation for ParameterInit

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.ParameterInit.html

Provides methods for collecting namespaces and writing ParameterInit instances as XML.

```rust
fn collect_namespace(&self, ns: &mut Namespace)
```

```rust
fn write_to<W: Write>(&self, writer: &mut EventWriter<W>) -> Result<(), Error>
```

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

### Get Page Resolutions

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page resolutions.

```APIDOC
## page_resolutions

### Description
Get all supported page resolutions.

### Method
`pub fn page_resolutions(&self) -> impl Iterator<Item = PageResolution> + '_`

### Response
#### Success Response
- **Iterator<Item = PageResolution>** - An iterator yielding `PageResolution` values.
```

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

### Print XPS File

Source: https://docs.rs/winprint/0.2.0/src/winprint/lib.rs.html

Creates an XPS printer instance and prints an XPS file to the specified device. Requires a valid printer device and an XPS file path.

```rust
use std::path::Path;
use winprint::printer::FilePrinter;
use winprint::printer::PrinterDevice;
use winprint::printer::XpsPrinter;
# use winprint::test_utils::null_device::thread_local as get_my_device;

let my_device = get_my_device();
let xps = XpsPrinter::new(my_device);
let path = Path::new("path/to/test/document.xps");
# let path_buf = Path::new(env!("CARGO_MANIFEST_DIR")).join("test_data/test_document.xps");
# let path = path_buf.as_path();
xps.print(path, Default::default()).unwrap();

```

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

### Get Page Orientations

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page orientations.

```APIDOC
## page_orientations

### Description
Get all supported page orientations.

### Method
`pub fn page_orientations(&self) -> impl Iterator<Item = PageOrientation> + '_`

### Response
#### Success Response
- **Iterator<Item = PageOrientation>** - An iterator yielding `PageOrientation` values.
```

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

### FPDF_VIEWERREF_GetPrintPageRangeCount

Source: https://docs.rs/winprint/0.2.0/src/winprint/bindings/pdfium.rs.html

Gets the number of page ranges specified in the print settings.

```APIDOC
## FPDF_VIEWERREF_GetPrintPageRangeCount

### Description
Gets the number of page ranges specified in the print settings.

### Method
extern "C"

### Signature
```c
FPDF_VIEWERREF_GetPrintPageRangeCount(FPDF_PAGERANGE pagerange) -> usize
```

### Parameters
*   **pagerange** (FPDF_PAGERANGE) - The handle to the page range structure obtained from FPDF_VIEWERREF_GetPrintPageRange.

### Returns
Returns the number of page ranges.
```

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

### XpsPrinter::new

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.XpsPrinter.html

Creates a new XpsPrinter instance for a given printer device. This is the entry point for using the XpsPrinter to print XPS documents.

```APIDOC
## XpsPrinter::new

### Description
Creates a new `XpsPrinter` for the given printer device.

### Method
`new`

### Parameters
#### Path Parameters
- **printer** (PrinterDevice) - Required - The printer device to associate with the XpsPrinter.

### Response
#### Success Response
- **Self** (XpsPrinter) - A new instance of XpsPrinter.
```

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

### Create New PdfiumPrinter

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.PdfiumPrinter.html

Constructs a new PdfiumPrinter instance for a specified printer device. This is the entry point for using the Pdfium printer.

```rust
pub fn new(printer: PrinterDevice) -> Self
```

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

### Get Page Resolutions

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page resolutions.

```rust
pub fn page_resolutions(&self) -> impl Iterator<Item = PageResolution> + '_

```

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

### Get Page Orientations

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page orientations.

```rust
pub fn page_orientations(&self) -> impl Iterator<Item = PageOrientation> + '_

```

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

### PartialEq Implementation for ParameterInit

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.ParameterInit.html

Enables equality comparison between ParameterInit instances.

```rust
fn eq(&self, other: &ParameterInit) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### Test Simple PDF Document Printing

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/pdfium.rs.html

This test case demonstrates printing a simple PDF document using PdfiumPrinter. It sets up a null device, initializes the printer, and prints a specified PDF file.

```rust
mod tests {
    use super::PdfiumPrinter;
    use crate::{printer::FilePrinter, test_utils::null_device};
    use std::path::Path;

    #[test]
    fn print_simple_pdf_document() {
        let device = null_device::thread_local();
        let pdf = PdfiumPrinter::new(device);
        let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("test_data/test_document.pdf");
        pdf.print(path.as_path(), Default::default()).unwrap();
    }
}
```

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

### Hash Implementation for ParameterInit

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.ParameterInit.html

Provides methods to hash ParameterInit instances and slices of them.

```rust
fn hash<__H: Hasher>(&self, state: &mut __H)
```

```rust
fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher,
Self: Sized,
```

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

### Get Height in Microns

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.MediaSizeTuple.html

Retrieves the height of the media size in microns.

```rust
pub const fn height_in_micron(&self) -> u32
```

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

### Create and Check Property

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/print_schema.rs.html

Illustrates the creation of a Property instance with a name and test properties, followed by a check using a helper function. This is useful for testing property-related logic.

```rust
let property = Property {
            name: OwnedName::local("Test"),
            value: None,
            properties: new_test_properties(),
        };
        check_test_properties(&property);
```

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

### Get Width in Microns

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.MediaSizeTuple.html

Retrieves the width of the media size in microns.

```rust
pub const fn width_in_micron(&self) -> u32
```

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

### Build a Print Ticket

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/builder.rs.html

Demonstrates the basic usage of building a print ticket using the PrintTicketBuilder.

```rust
let _ticket = builder.build().unwrap();
```

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

### Get Parameters from PageMediaSize

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Retrieves a slice of the parameters used by the PageMediaSize option.

```rust
fn parameters(&self) -> &[ParameterInit]
```

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

### List PageMediaSize Options from Capabilities

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Iterates over all possible PageMediaSize options defined within the provided PrintCapabilities.

```rust
fn list(capabilities: &PrintCapabilities) -> impl Iterator<Item = Self> + '_ 
```

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

### Get PrintFeatureOption from PageMediaSize

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Retrieves a reference to the PrintFeatureOption within the PageMediaSize instance.

```rust
fn option(&self) -> &PrintFeatureOption
```

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

### Create a new PrintTicketBuilder

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/builder.rs.html

Initializes a new `PrintTicketBuilder` for a specific printer device. This requires opening a print ticket provider associated with the printer's name. Errors during provider opening are captured.

```rust
pub fn new(device: &PrinterDevice) -> Result<Self, PrintTicketBuilderError> {
        let provider = unsafe {
            PTOpenProvider(PCWSTR(wchar::to_wide_chars(device.os_name()).as_ptr()), 1)
                .map_err(PrintTicketBuilderError::OpenProviderFailed)?
        };
        Ok(Self {
            xml: DEFAULT_PRINT_TICKET_XML.into(),
            provider,
        })
    }
```

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

### Get Page Output Colors

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page output colors.

```APIDOC
## page_output_colors

### Description
Get all supported page output colors.

### Method
`pub fn page_output_colors(&self) -> impl Iterator<Item = PageOutputColor> + '_`

### Response
#### Success Response
- **Iterator<Item = PageOutputColor>** - An iterator yielding `PageOutputColor` values.
```

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

### Create DXGI Print Context

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/dxgi.rs.html

Initializes and returns a new DXGI Print Context. This involves setting up various DirectX and WIC factories, creating a print control, and advising for status events. Ensure COM is initialized before calling.

```rust
pub fn new(
        d3d_device: ID3D11Device,
        d3d_context: ID3D11DeviceContext,
        dxgi_device: IDXGIDevice,
        d2d_factory: ID2D1Factory1,
        d2d_device: ID2D1Device,
        d2d_context: ID2D1DeviceContext,
        wic_factory: IWICImagingFactory,
        document_target_factory: IDocumentPackageTargetFactory,
        document_target: IDocumentPackageTarget,
        print_control: IPrintDocumentPackageTarget,
    ) -> Result<Self, DxgiPrintContextError> {
        let _com_initializer = ComInitializer::new();
        let completion_waiter = CompletionWaiter::new();

        let mut completion_source: ComPtr<IPrintDocumentPackageStatusEvent> = ComPtr::null();
        completion_source
            .from_raw(completion_waiter.as_raw_event())
            .map_err(DxgiPrintContextError::FailedToCreateEvent)?;

        unsafe {
            cpc.FindConnectionPoint(&IPrintDocumentPackageStatusEvent::IID)
                .map_err(DxgiPrintContextError::FailedToCreateEvent)?
                .Advise(&completion_source)
                .map_err(DxgiPrintContextError::FailedToCreateEvent)?;
        }

        Ok(Self {
            d3d_device,
            d3d_context,
            dxgi_device,
            d2d_factory,
            d2d_device,
            d2d_context,
            wic_factory,
            document_target_factory,
            document_target,
            print_control,
            completion_waiter,
            _com_initializer,
        })
    }
```

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

### Eq Implementation for ParameterInit

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.ParameterInit.html

Indicates that ParameterInit supports total equality comparison.

```rust
impl Eq for ParameterInit
```

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

### Clone Implementation for ParameterInit

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.ParameterInit.html

Provides methods to create a duplicate of a ParameterInit instance or copy its contents.

```rust
fn clone(&self) -> ParameterInit
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Get Options for Feature

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all available options for a specified print feature.

```APIDOC
## options_for_feature

### Description
Get all options for the given feature.

### Method
`pub fn options_for_feature( &self, feature_name: OwnedName, ) -> impl Iterator<Item = &PrintFeatureOption> + '_`

### Parameters
#### Path Parameters
- **feature_name** (*OwnedName*) - Required - The name of the feature to get options for.

### Response
#### Success Response
- **Iterator<Item = &PrintFeatureOption>** - An iterator yielding references to `PrintFeatureOption` for the specified feature.
```

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

### Get Page Output Colors

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported page output colors.

```rust
pub fn page_output_colors(&self) -> impl Iterator<Item = PageOutputColor> + '_

```

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

### PdfiumPrinter New Function

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/pdfium.rs.html

Constructor for PdfiumPrinter. Initializes the printer with a given PrinterDevice.

```rust
/// A printer that uses Pdfium to print PDF documents.
pub struct PdfiumPrinter {
    printer: PrinterDevice,
}

impl PdfiumPrinter {
    /// Create a new [`PdfiumPrinter`] for the given printer device.
    pub fn new(printer: PrinterDevice) -> Self {
        Self { printer }
    }
}
```

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

### StructuralPartialEq Implementation for ParameterInit

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.ParameterInit.html

Indicates that ParameterInit supports structural equality comparison.

```rust
impl StructuralPartialEq for ParameterInit
```

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

### Print an XPS Document

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/xps.rs.html

This snippet shows how to print a local XPS file. It constructs the path to the XPS file and then calls the print method.

```rust
let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("test_data/test_document.xps");
xps.print(path.as_path(), Default::default()).unwrap();
```

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

### Get PrintTicket XML

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintTicket.html

Retrieves the XML data of the PrintTicket as a byte slice (&[u8]).

```rust
pub fn get_xml(&self) -> &[u8]
```

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

### Create New PrintTicketBuilder

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintTicketBuilder.html

Initializes a new PrintTicketBuilder for a specific printer device. Handles potential errors during creation.

```rust
pub fn new(device: &PrinterDevice) -> Result<Self, PrintTicketBuilderError>
```

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

### Get Default Parameters

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all parameters with their default values, as defined by the print capabilities.

```APIDOC
## default_parameters

### Description
Defines all parameters with default values.

### Method
`pub fn default_parameters(&self) -> impl Iterator<Item = ParameterInit> + '_`

### Response
#### Success Response
- **Iterator<Item = ParameterInit>** - An iterator yielding `ParameterInit` items representing default parameters.
```

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

### Any Trait Implementation

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Provides a method to get the `TypeId` of a type, useful for runtime type identification.

```rust
fn type_id(&self) -> TypeId

```

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

### Print with Specified Preferences

Source: https://docs.rs/winprint/0.2.0/src/winprint/lib.rs.html

Prints an XPS file using a custom print ticket to specify preferences like media size and orientation. This involves fetching capabilities, building a ticket, and then printing.

```rust
use std::path::Path;
use winprint::printer::FilePrinter;
use winprint::printer::PrinterDevice;
use winprint::printer::XpsPrinter;
use winprint::ticket::FeatureOptionPackWithPredefined;
use winprint::ticket::PredefinedMediaName;
use winprint::ticket::PrintCapabilities;
use winprint::ticket::PrintTicket;
use winprint::ticket::PrintTicketBuilder;
# use winprint::test_utils::null_device::thread_local as get_my_device;

let my_device = get_my_device();
let capabilities = PrintCapabilities::fetch(&my_device).unwrap();
let a4_media = capabilities
    .page_media_sizes()
    .find(|x| x.as_predefined_name() == Some(PredefinedMediaName::ISOA4))
    .unwrap();
let mut builder = PrintTicketBuilder::new(&my_device).unwrap();
builder.merge(a4_media).unwrap();
let ticket = builder.build().unwrap();
let xps = XpsPrinter::new(my_device);
let path = Path::new("path/to/test/document.xps");
# let path_buf = Path::new(env!("CARGO_MANIFEST_DIR")).join("test_data/test_document.xps");
# let path = path_buf.as_path();
xps.print(path, ticket).unwrap();

```

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

### Get Page Resolution DPI

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageResolution.html

Retrieves the resolution of the page in DPI (dots per inch).

```rust
pub fn dpi(&self) -> (u32, u32)
```

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

### DxgiPrintContext::new

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.DxgiPrintContext.html

Creates a new DxgiPrintContext, which is essential for initiating a printing operation using DXGI.

```APIDOC
## DxgiPrintContext::new

### Description
Creates a new print context, used for printing via DXGI.

### Method

```
pub fn new( device: &PrinterDevice, options: &PrintTicket, job_name: &OsStr, ) -> Result<Self, DxgiPrintContextError>
```

### Parameters

* `device`: A reference to the `PrinterDevice`.
* `options`: A reference to the `PrintTicket` options.
* `job_name`: The name of the print job as an `OsStr`.

### Returns

A `Result` containing the new `DxgiPrintContext` on success, or a `DxgiPrintContextError` on failure.
```

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

### Serialize ParameterInit to XML

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/writer.rs.html

Implements the `XmlSerializer` trait for `ParameterInit`. It collects namespaces, including those derived from the parameter's name.

```rust
impl XmlSerializer for super::ParameterInit {
    fn collect_namespace(&self, ns: &mut Namespace) {
        ns.put("psf", NS_PSF);
        collect_namespace_from_name(&self.name, ns);
    }
}
```

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

### Get Printer Device Name

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.PrinterDevice.html

Retrieves a reference to the printer device's name as a string slice.

```rust
pub fn name(&self) -> &str
```

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

### ParameterInit Struct

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/print_schema.rs.html

Represents a parameter initialization used in a PrintTicketDocument, with a name and a value.

```rust
51#[derive(Clone, PartialEq, Eq, Hash, fmt_derive::Debug)]
52/// Represents a parameter initialization used in a [`PrintTicketDocument`].
53pub struct ParameterInit {
54    /// The name of the parameter.
55    #[fmt("{}", self.name)]
56    pub name: OwnedName,
57    /// The value of the parameter.
58    #[fmt("{:?}", self.value)]
59    pub value: PropertyValue,
60}

```

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

### Get Display Name for PageMediaSize

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Retrieves the display name for the page orientation associated with the PageMediaSize option, if available.

```rust
fn display_name(&self) -> Option<&str>
```

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

### Get Mutable PrintFeatureOption from PageMediaSize

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Retrieves a mutable reference to the PrintFeatureOption within the PageMediaSize instance, allowing modifications.

```rust
fn option_mut(&mut self) -> &mut PrintFeatureOption
```

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

### DxgiPrintContext::new

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/dxgi.rs.html

Constructs a new DXGI Print Context. This involves creating Direct3D and Direct2D devices, factories, and print control objects, and setting up an event listener for print job completion.

```APIDOC
## DxgiPrintContext::new

### Description
Constructs a new DXGI Print Context. This involves creating Direct3D and Direct2D devices, factories, and print control objects, and setting up an event listener for print job completion.

### Method
Associated function (constructor)

### Parameters
None explicitly documented for direct invocation, but internally requires parameters for device and factory creation.

### Returns
- `Result<Self, DxgiPrintContextError>` - Returns a new `DxgiPrintContext` instance on success, or a `DxgiPrintContextError` on failure.
```

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

### Test Get Properties from Feature

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/print_schema.rs.html

Tests the `get_property` functionality by creating a `PrintFeature` and verifying its properties using `check_test_properties`.

```rust
#[test]
fn get_properties_from_feature() {
    let feature = super::PrintFeature {
        name: OwnedName::local("Test"),
        properties: new_test_properties(),
        options: vec![],
        features: vec![],
    };
    check_test_properties(&feature);
}
```

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

### Parsing ParameterInit Element

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/reader.rs.html

Handles the parsing of a 'ParameterInit' element. It ensures the value is found and that the element is correctly placed within its container. Errors are reported with position and reason.

```rust
323                                // check it, and if not found, return error
324                                let value = parsed_value.take().ok_or_else(|| {
325                                    ParsePrintSchemaError::InvalidPrintSchema {
326                                        pos: reader.position(),
327                                        reason: "ParameterInit value not found".to_string(),
328                                    }
329                                })?;
330
331                                let parent =
332                                    parameter_init_container.as_mut().ok_or_else(|| {
333                                        ParsePrintSchemaError::InvalidPrintSchema {
334                                            pos: reader.position(),
335                                            reason: "ParameterInit cannot be here".to_string(),
336                                        }
337                                })?;
338                                parent.push(ParameterInit {
339                                    name: parameter_init_name,
340                                    value,
341                                });
342                            }
```

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

### DxgiPrintContext::new Function

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.DxgiPrintContext.html

Creates a new print context for DXGI-based printing. Requires a PrinterDevice, PrintTicket options, and a job name.

```rust
pub fn new( device: &PrinterDevice, options: &PrintTicket, job_name: &OsStr, ) -> Result<Self, DxgiPrintContextError>
```

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

### Get Properties of PrintSchemaDocument

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/enum.PrintSchemaDocument.html

Retrieves a slice of properties associated with the PrintSchemaDocument. This can be used to inspect metadata or configuration details.

```rust
fn properties(&self) -> &[Property]
```

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

### WinPdfPrinter::new

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.WinPdfPrinter.html

Creates a new instance of WinPdfPrinter for a specified printer device.

```APIDOC
## WinPdfPrinter::new

### Description
Creates a new `WinPdfPrinter` for the given printer device.

### Method
```rust
pub fn new(printer: PrinterDevice) -> Self
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Assuming PrinterDevice is defined elsewhere
// let printer_device: PrinterDevice = ...;
// let pdf_printer = WinPdfPrinter::new(printer_device);
```

### Response
#### Success Response
- **Self** (WinPdfPrinter) - A new instance of WinPdfPrinter.

#### Response Example
```rust
// let pdf_printer: WinPdfPrinter = ...;
```
```

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

### Get Printer Device

Source: https://docs.rs/winprint/0.2.0/src/winprint/lib.rs.html

Retrieves all available printer devices and filters for a specific printer by name. This is a prerequisite for printing.

```rust
#![cfg(windows)]
#![warn(missing_docs)]

//! A crate for printing to a Windows printer device using Windows API.
//!
//! # Examples
//! ## Print a file
//! For a simple example presenting how to print a file:
//! - Filter for the device you want to use.
//! - Wrap the printer device with a printer.
//! - Send a file to the printer.
//!
//! First, get all printer devices via `PrinterDevice::all()` and filter for the device you want to use.
//!
//! ```rust
//! use winprint::printer::PrinterDevice;
//!
//! fn get_my_device() -> PrinterDevice {
//!     let printers = PrinterDevice::all().expect("Failed to get printers");
//!     printers
//!         .into_iter()
//!         .find(|x| x.name() == "My Printer")
//!         .expect("My Printer not found")
//! }
//! ```
//!
```

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

### Create New PrintCompletionSource

Source: https://docs.rs/winprint/0.2.0/src/winprint/utils/print_completion_source.rs.html

Creates a new instance of PrintCompletionSource. It initializes a Windows event object that will be used to signal print job status changes. Requires the `windows` crate.

```rust
impl PrintCompletionSource {
    pub fn new() -> windows::core::Result<Self> {
        let event = unsafe { CreateEventW(None, true, false, None)? };
        Ok(Self { event })
    }
    // ... other methods
}
```

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

### Get Mutable Parameters from PageMediaSize

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Retrieves a mutable reference to the vector of parameters used by the PageMediaSize option, allowing modifications.

```rust
fn parameters_mut(&mut self) -> &mut Vec<ParameterInit>
```

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

### Get Feature Name for PageMediaSize

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Returns the feature name associated with the PageMediaSize option. This is used to identify the type of feature.

```rust
fn feature_name() -> OwnedName
```

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

### Try to fetch PageImageableSize

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/page_imageable_size.rs.html

Fetches the imageable size for a given printer device and media size by retrieving and parsing print capabilities.

```rust
impl PageImageableSize {
    /// Try to fetch the imageable size for the given printer device and media size.
    pub fn try_fetch(
        device: &PrinterDevice,
        media: PageMediaSize,
    ) -> Result<Self, PageImageableSizeError> {
        let ticket = PrintTicket::from(media);
        let caps_xml = PrintCapabilities::fetch_xml_for_ticket(device, Some(&ticket))?;
        let caps = PrintCapabilitiesDocument::parse_from_bytes(&caps_xml)?;
        let imageable_size = caps.get_property("PageImageableSize", Some(NS_PSK)).ok_or(
            PageImageableSizeError::FieldError {
                field: "PageImageableSize",
            },
        )?;
        let size_w = get_u32_property(imageable_size, "ImageableSizeWidth", Some(NS_PSK))?;
        let size_h = get_u32_property(imageable_size, "ImageableSizeHeight", Some(NS_PSK))?;
        let imageable_area = imageable_size
            .get_property("ImageableArea", Some(NS_PSK))
            .ok_or(PageImageableSizeError::FieldError {
                field: "ImageableArea",
            })?;
        let origin_w = get_u32_property(imageable_area, "OriginWidth", Some(NS_PSK))?;
        let origin_h = get_u32_property(imageable_area, "OriginHeight", Some(NS_PSK))?;
        let extent_w = get_u32_property(imageable_area, "ExtentWidth", Some(NS_PSK))?;
        let extent_h = get_u32_property(imageable_area, "ExtentHeight", Some(NS_PSK))?;
        Ok(Self {
            size: MediaSizeTuple::micron(size_w, size_h),
            origin: MediaSizeTuple::micron(origin_w, origin_h),
            extent: MediaSizeTuple::micron(extent_w, extent_h),
        })
    }
}
```

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

### ParameterInit Struct Definition

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.ParameterInit.html

Defines the structure of a parameter initialization, including its name and value.

```rust
pub struct ParameterInit {
    pub name: OwnedName,
    pub value: PropertyValue,
}
```

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

### Test Get Properties from Feature Option

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/print_schema.rs.html

Tests the `get_property` functionality by creating a `PrintFeatureOption` and verifying its properties using `check_test_properties`.

```rust
#[test]
fn get_properties_from_option() {
    let option = super::PrintFeatureOption {
        name: None,
        scored_properties: vec![],
        properties: new_test_properties(),
    };
    check_test_properties(&option);
}
```

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

### MediaSizeTuple Utility Methods

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.MediaSizeTuple.html

Provides utility functions for checking media properties.

```APIDOC
## MediaSizeTuple Utility Methods

### `is_roll(&self) -> bool`

Determines if the media is a roll media.
```

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

### Get Scored Properties of PrintFeatureOption

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/document/struct.PrintFeatureOption.html

Retrieves the scored properties associated with a PrintFeatureOption. This method is part of the WithScoredProperties trait implementation.

```rust
fn scored_properties(&self) -> &[ScoredProperty]
```

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

### Test Fetching Printer Devices

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/device.rs.html

A basic test case to ensure that the `PrinterDevice::all()` function can be called without panicking and returns a result.

```rust
#[cfg(test)]
mod tests {
    use super::PrinterDevice;
    use crate::test_utils::null_device;

    #[test]
    fn fetch_printer_device() {
        let _devices = PrinterDevice::all().unwrap();
    }

```

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

### Test Get Properties from Capabilities

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/print_schema.rs.html

Tests the `get_property` functionality by creating a `PrintSchemaDocument` from a `PrintCapabilitiesDocument` and verifying its properties using `check_test_properties`.

```rust
#[test]
fn get_properties_from_capabilities() {
    let document1: PrintSchemaDocument = PrintCapabilitiesDocument {
        properties: new_test_properties(),
        parameter_defs: vec![],
        features: vec![],
    }
    .into();
    check_test_properties(&document1);
}
```

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

### Rendering and Printing an Image with Direct2D

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/image.rs.html

This snippet demonstrates the process of rendering a bitmap onto a Direct2D command list and then adding that command list as a page to the print control. It includes error handling for rendering and command list operations. Use this when you need to programmatically draw an image onto a print job.

```rust
d2d_context.SetTarget(&command_list);

                d2d_context.BeginDraw();
                d2d_context.DrawBitmap(
                    &bitmap,
                    Some(&D2D_RECT_F {
                        left: 0.0,
                        top: 0.0,
                        right: page_size.width,
                        bottom: page_size.height,
                    }),
                    1.0,
                    D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC,
                    None,
                    None,
                );
                d2d_context
                    .EndDraw(None, None)
                    .map_err(ImagePrinterError::RenderError)?;
                command_list
                    .Close()
                    .map_err(ImagePrinterError::RenderError)?;
                print_control
                    .AddPage(&command_list, page_size, None, None, None)
                    .map_err(ImagePrinterError::RenderError)?;
```

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

### Test Get Properties from Ticket

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/print_schema.rs.html

Tests the `get_property` functionality by creating a `PrintSchemaDocument` from a `PrintTicketDocument` and verifying its properties using `check_test_properties`.

```rust
#[test]
fn get_properties_from_ticket() {
    let document1: PrintSchemaDocument = PrintTicketDocument {
        properties: new_test_properties(),
        parameter_inits: vec![],
        features: vec![],
    }
    .into();
    check_test_properties(&document1);
}
```

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

### Test Fetching and Merging Page Media Sizes

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/page_media_size.rs.html

Tests the functionality of fetching print capabilities and merging media size options into a print ticket builder. This ensures that media size features can be correctly applied.

```rust
use crate::{
    test_utils::null_device,
    ticket::{
        FeatureOptionPack, FeatureOptionPackWithPredefined, PredefinedMediaName,
        PrintCapabilities, PrintTicketBuilder,
    },
};

#[test]
fn use_page_media_size() {
    let device = null_device::thread_local();
    let capabilities = PrintCapabilities::fetch(&device).unwrap();
    for media in capabilities.page_media_sizes() {
        let mut builder = PrintTicketBuilder::new(&device).unwrap();
        builder.merge(media).unwrap();
    }
}
```

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

### Get Printer Device OS Name

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.PrinterDevice.html

Retrieves a reference to the operating system's name for the printer device as an OsStr.

```rust
pub fn os_name(&self) -> &OsStr
```

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

### Get All Supported Page Orientations

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/print_capabilities.rs.html

Returns an iterator over all supported page orientations. This method relies on the `PageOrientation::list` function.

```rust
PageOrientation::list(self)
```

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

### Fetch All Printer Devices

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.PrinterDevice.html

Use the `all` function to retrieve a vector of all available printer devices. This function can return an error if device enumeration fails.

```rust
pub fn all() -> Result<Vec<Self>, EnumDeviceError>
```

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

### ImagePrinter::new

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.ImagePrinter.html

Creates a new ImagePrinter instance for a given printer device. This is the entry point for using the ImagePrinter to print images.

```APIDOC
## ImagePrinter::new

### Description
Create a new `ImagePrinter` for the given printer device.

### Method
```
pub fn new(printer: PrinterDevice) -> Self
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response
- **Self** (ImagePrinter) - A new instance of ImagePrinter.

### Response Example
None
```

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

### Get Printer Device OS Attributes

Source: https://docs.rs/winprint/0.2.0/winprint/printer/struct.PrinterDevice.html

Returns the operating system-specific attributes of the printer device as a 32-bit unsigned integer.

```rust
pub fn os_attributes(&self) -> u32
```

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

### Parsing ParameterInit Element

Source: https://docs.rs/winprint/0.2.0/src/winprint/ticket/document/reader.rs.html

Parses the 'ParameterInit' element and extracts its name attribute.

```rust
"ParameterInit" => {
    parameter_init_name = parse_name_attribute(&attributes, &namespace);
}
// ... other matches
```

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

### Get Printer Device

Source: https://docs.rs/winprint/0.2.0/index.html

Retrieves all available printer devices and filters for a specific printer by name. This is a prerequisite for most printing operations.

```rust
use winprint::printer::PrinterDevice;

fn get_my_device() -> PrinterDevice {
    let printers = PrinterDevice::all().expect("Failed to get printers");
    printers
        .into_iter()
        .find(|x| x.name() == "My Printer")
        .expect("My Printer not found")
}
```

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

### Create New PageMediaSize Instance

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PageMediaSize.html

Creates a new instance of PageMediaSize with the specified print feature option and parameters. This is the constructor for the struct.

```rust
fn new(option: PrintFeatureOption, parameters: Vec<ParameterInit>) -> Self
```

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

### Get Duplex Options

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over all supported job duplex types. This corresponds to the Print Schema’s `JobDuplexAllDocumentsContiguously` keyword.

```APIDOC
## duplexes

### Description
Get all supported job duplex types.

### Note
This corresponds to the Print Schema’s `JobDuplexAllDocumentsContiguously` keyword, not the `DocumentDuplex` keyword.

### Method
`pub fn duplexes(&self) -> impl Iterator<Item = JobDuplex> + '_`

### Response
#### Success Response
- **Iterator<Item = JobDuplex>** - An iterator yielding `JobDuplex` values.
```

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

### Get Default Parameters with Filters

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintCapabilities.html

Retrieves an iterator over specified parameters with their default values, allowing filtering by a list of parameter names.

```APIDOC
## default_parameters_for

### Description
Defines the given parameters with default values.

### Method
`pub fn default_parameters_for<'a>( &'a self, filters: &'a [OwnedName], ) -> impl Iterator<Item = ParameterInit> + 'a`

### Parameters
#### Path Parameters
- **filters** (*&[OwnedName]*) - Required - A slice of `OwnedName` specifying which parameters to include.

### Response
#### Success Response
- **Iterator<Item = ParameterInit>** - An iterator yielding `ParameterInit` items for the filtered parameters.
```

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

### PrintTicketBuilder::new

Source: https://docs.rs/winprint/0.2.0/winprint/ticket/struct.PrintTicketBuilder.html

Creates a new PrintTicketBuilder instance for a given printer device. This is the entry point for building a print ticket.

```APIDOC
## PrintTicketBuilder::new

### Description
Creates a new print ticket builder for the given printer device.

### Method
`new`

### Parameters
#### Path Parameters
- **device** (*PrinterDevice*) - Required - The printer device to associate with this builder.

### Returns
- `Result<Self, PrintTicketBuilderError>` - A new `PrintTicketBuilder` instance or an error if creation fails.
```

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

### WinPdfPrinter print implementation

Source: https://docs.rs/winprint/0.2.0/src/winprint/printer/win_pdf.rs.html

Implements the print method for WinPdfPrinter, handling PDF file loading, rendering, and sending to the print control. Requires DxgiPrintContext for device and print control access.

```rust
45impl FilePrinter for WinPdfPrinter {
46    type Options = PrintTicket;
47    type Error = WinPdfPrinterError;
48    fn print(
49        &self,
50        path: &Path,
51        options: PrintTicket,
52    ) -> std::result::Result<(), WinPdfPrinterError> {
53        let context = DxgiPrintContext::new(
54            &self.printer,
55            &options,
56            path.file_name().unwrap_or(path.as_ref()),
57        )?;
58        let dxgi_device = &context.dxgi_device;
59        let print_control = &context.print_control;
60        let d2d_context = &context.d2d_context;
61        unsafe {
62            let absolute_path =
63                std::path::absolute(path).map_err(WinPdfPrinterError::InvalidPath)?;
64            let file = StorageFile::GetFileFromPathAsync(&HSTRING::from(absolute_path.as_path()))
65                .map_err(WinPdfPrinterError::FailedToOpenDocument)?
66                .get()
67                .map_err(WinPdfPrinterError::FailedToOpenDocument)?;
68            let pdf_document = PdfDocument::LoadFromFileAsync(&file)
69                .map_err(WinPdfPrinterError::FailedToOpenDocument)?
70                .get()
71                .map_err(WinPdfPrinterError::FailedToOpenDocument)?;
72
73            let pdf_renderer =
74                PdfCreateRenderer(dxgi_device).map_err(WinPdfPrinterError::RenderError)?;
75            let pdf_render_options = PDF_RENDER_PARAMS {
76                IgnoreHighContrast: true.into(),
77                ..Default::default()
78            };
79            let page_count = pdf_document
80                .PageCount()
81                .map_err(WinPdfPrinterError::RenderError)?;
82            for i in 0..page_count {
83                let pdf_page = pdf_document
84                    .GetPage(i)
85                    .map_err(WinPdfPrinterError::RenderError)?;
86
87                let command_list =
88                    d2d_context
89                        .CreateCommandList()
90                        .map_err(WinPdfPrinterError::RenderError)?;
91                d2d_context.SetTarget(&command_list);
92                d2d_context.BeginDraw();
93                pdf_renderer
94                    .RenderPageToDeviceContext(&pdf_page, d2d_context, Some(&pdf_render_options))
95                    .map_err(WinPdfPrinterError::RenderError)?;
96                d2d_context
97                    .EndDraw(None, None)
98                    .map_err(WinPdfPrinterError::RenderError)?;
99                command_list
100                        .Close()
101                        .map_err(WinPdfPrinterError::RenderError)?;
102
103                let pdf_size = pdf_page.Size().map_err(WinPdfPrinterError::RenderError)?;
104                let dx_size = D2D_SIZE_F {
105                    width: pdf_size.Width as f32,
106                    height: pdf_size.Height as f32,
107                };
108                print_control
109                    .AddPage(&command_list, dx_size, None, None, None)
110                    .map_err(WinPdfPrinterError::RenderError)?;
111            }
112        }
113        context.close_and_wait()?;
114        Ok(())
115    }
116}
117
118#[cfg(test)]
119mod tests {
120    use super::WinPdfPrinter;
121    use crate::{printer::FilePrinter, test_utils::null_device};
122    use std::path::Path;
123
124    #[test]
125    fn print_simple_pdf_document() {
126        let device = null_device::thread_local();
127
```
Tokens:
Raw