Struct Slide 

pub struct Slide {
    pub rel_path: String,
    pub slide_number: u32,
    pub elements: Vec<SlideElement>,
    pub speaker_notes: Vec<TextElement>,
    pub comments: Vec<TextElement>,
    pub images: Vec<ImageReference>,
    pub image_data: HashMap<String, Vec<u8>>,
    pub config: ParserConfig,
    pub blocks: Vec<SlideBlock>,
    pub diagnostics: Vec<ParseDiagnostic>,
}

Represents a single slide extracted from a PowerPoint (pptx) file.

Contains structured slide data including slide number, parsed content elements (text, tables, images, lists), speaker notes, and associated image references.

A Slide can be converted into other formats, such as Markdown, or its contained images can be extracted in base64 representation.

Typically, you retrieve instances of Slide through [PptxContainer::parse()].

Fields

rel_path: String

slide_number: u32

elements: Vec<SlideElement>

speaker_notes: Vec<TextElement>

comments: Vec<TextElement>

images: Vec<ImageReference>

image_data: HashMap<String, Vec<u8>>

config: ParserConfig

blocks: Vec<SlideBlock>

diagnostics: Vec<ParseDiagnostic>

Implementations

impl Slide

pub fn new( rel_path: String, slide_number: u32, elements: Vec<SlideElement>, speaker_notes: Vec<TextElement>, comments: Vec<TextElement>, images: Vec<ImageReference>, image_data: HashMap<String, Vec<u8>>, config: ParserConfig, ) -> Self

pub fn new_semantic( rel_path: String, slide_number: u32, elements: Vec<SlideElement>, blocks: Vec<SlideBlock>, speaker_notes: Vec<TextElement>, comments: Vec<TextElement>, images: Vec<ImageReference>, image_data: HashMap<String, Vec<u8>>, config: ParserConfig, diagnostics: Vec<ParseDiagnostic>, ) -> Self

pub fn convert_to_md(&self) -> Result<String>

Converts slide contents into a Markdown formatted string.

Translates internal slide elements (text, tables, lists, images) to valid and readable Markdown. Embedded images will be encoded as base64 inline images.

Returns

Returns an Option<String>:

• Some(String): Markdown representation of slide if conversion succeeds.
• None: If a conversion error occurs during image encoding.

Examples found in repository

examples/legacy_pptx_api.rs (line 28)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let Some(input_path) = args.get(1) else {
        eprintln!("Usage: cargo run --example legacy_pptx_api <presentation.pptx> [output.md]");
        return Ok(());
    };
    let output_path = args.get(2).map(String::as_str).unwrap_or("output.md");

    // This is the pre-PresentationContainer flow: open a PPTX-specific
    // container, parse every slide, and render each slide separately. It does
    // not add the presentation-level metadata header.
    let mut container = PptxContainer::open(Path::new(input_path), ParserConfig::default())?;
    let markdown = container
        .parse_all()?
        .into_iter()
        .map(|slide| slide.convert_to_md())
        .collect::<Result<Vec<_>>>()?
        .join("\n");
    fs::write(output_path, markdown)?;

    println!("Converted PPTX with the legacy entry point to {output_path}");
    Ok(())
}

examples/memory_efficient_streaming.rs (line 29)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let Some(input_path) = args.get(1) else {
        eprintln!(
            "Usage: cargo run --example memory_efficient_streaming <presentation.pptx|presentation.odp>"
        );
        return Ok(());
    };

    let mut presentation =
        PresentationContainer::open(Path::new(input_path), ParserConfig::default())?;
    let output_dir = "output_streaming";
    fs::create_dir_all(output_dir)?;

    // Unlike parse_document(), the iterator only retains the current slide.
    for slide_result in presentation.iter_slides() {
        let slide = slide_result?;
        let output_path = format!("{output_dir}/slide_{}.md", slide.slide_number);
        fs::write(&output_path, slide.convert_to_md()?)?;
        println!(
            "Saved slide {} ({} semantic blocks) to {output_path}",
            slide.slide_number,
            slide.blocks.len()
        );
    }

    Ok(())
}

examples/manual_image_extraction.rs (line 51)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let Some(input_path) = args.get(1) else {
        eprintln!(
            "Usage: cargo run --example manual_image_extraction <presentation.pptx|presentation.odp>"
        );
        return Ok(());
    };

    println!("Processing presentation: {input_path}");

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Manually)
        .build();

    let mut container = PresentationContainer::open(Path::new(input_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Create output directory
    let output_dir = "extracted_images";
    fs::create_dir_all(output_dir)?;

    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        writeln!(md_file, "{}", slide.convert_to_md()?)?;

        // Manually load the base64 encoded image strings from the slide
        if let Some(images) = slide.load_images_manually() {
            for image in images {
                // Decode the base64 strings back to raw image data
                let image_data = general_purpose::STANDARD
                    .decode(image.base64_content.clone())
                    .expect("parser returned invalid base64 image data");

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = if slide.config.compress_images {
                    "jpg".to_string()
                } else {
                    slide.get_image_extension(&image.img_ref.target.clone())
                };

                // Construct a unique file name
                let file_name = format!(
                    "slide{}_image{}_{}",
                    slide.slide_number, image_count, &image.img_ref.id
                );

                // Save the image
                let output_path = format!("{}/{}.{}", output_dir, &file_name, ext);
                fs::write(&output_path, image_data)?;
                println!("Saved image to {}", output_path);

                // Write the image data into the Markdown file
                writeln!(
                    md_file,
                    "![{}](data:image/{};base64,{})",
                    file_name, ext, image.base64_content
                )?;

                image_count += 1;
            }
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

examples/performance_test.rs (line 117)

fn main() -> Result<()> {
    // Get the PPTX file path and optional iteration count from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!(
            "Usage: cargo run --example performance_test <presentation.pptx|presentation.odp> [iterations]"
        );
        return Ok(());
    };

    let iterations = if args.len() > 2 {
        args[2].parse().unwrap_or(5)
    } else {
        10 // Default to 10 iterations
    };

    println!(
        "Performance testing with {} iterations on: {}",
        iterations, pptx_path
    );

    // =========== Single-threaded Approach ===========
    let mut single_thread_bench = Benchmark::new("Single-threaded parsing");

    let mut total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Single-threaded)", i + 1);

        // Measure container creation
        let mut container = single_thread_bench.measure(|| {
            let config = ParserConfig::builder().extract_images(true).build();
            PresentationContainer::open(Path::new(pptx_path), config)
                .expect("Failed to open presentation")
        });

        // Measure parsing
        let slides =
            single_thread_bench.measure(|| container.parse_all().expect("Failed to parse slides"));
        println!("  Found {} slides in the presentation", slides.len());

        // Measure conversion
        let _md_content = single_thread_bench.measure(|| {
            slides
                .iter()
                .filter_map(|slide| slide.convert_to_md().ok())
                .collect::<Vec<String>>()
        });

        total_slides += slides.len();
    }

    single_thread_bench.report();
    println!(
        "Average slides per presentation: {}",
        total_slides / iterations
    );

    // =========== Single-threaded Streamed Approach ===========
    let mut single_thread_streamed_bench = Benchmark::new("Single-threaded streamed parsing");

    total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Single-threaded streamed)", i + 1);

        // Measure container creation
        let mut container = single_thread_streamed_bench.measure(|| {
            let config = ParserConfig::builder().extract_images(true).build();
            PresentationContainer::open(Path::new(pptx_path), config)
                .expect("Failed to open presentation")
        });

        // Measure slide processing (including parsing and conversion)
        let slides_processed = single_thread_streamed_bench.measure(|| {
            let mut processed = 0;

            // Process slides one by one using the iterator
            for slide_result in container.iter_slides() {
                match slide_result {
                    Ok(slide) => {
                        // Konvertiere den Slide zu Markdown
                        let _md_content = slide.convert_to_md();
                        processed += 1;
                    }
                    Err(e) => {
                        eprintln!("Error processing slide: {:?}", e);
                    }
                }
            }

            processed
        });

        println!("  Processed {} slides", slides_processed);
        total_slides += slides_processed;
    }

    single_thread_streamed_bench.report();
    println!(
        "Average slides per presentation: {}",
        total_slides / iterations
    );

    // =========== Optimized Multi-threaded Approach ===========
    let mut optimized_multi_thread_bench = Benchmark::new("Optimized Multi-threaded parsing");

    total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Optimized Multi-threaded)", i + 1);

        // Container öffnen mit der gewünschten Konfiguration
        let mut container = optimized_multi_thread_bench.measure(|| {
            let config = ParserConfig::builder().extract_images(true).build();
            PresentationContainer::open(Path::new(pptx_path), config)
                .expect("Failed to open presentation")
        });

        let slides = optimized_multi_thread_bench.measure(|| {
            container
                .parse_all_multi_threaded()
                .expect("Failed to parse slides")
        });

        println!("  Successfully processed {} slides", slides.len());

        // Parallel zu Markdown konvertieren (bleibt unverändert)
        let _md_content = optimized_multi_thread_bench.measure(|| {
            slides
                .par_iter()
                .filter_map(|slide| slide.convert_to_md().ok())
                .collect::<Vec<String>>()
        });

        total_slides += slides.len();
    }

    optimized_multi_thread_bench.report();
    println!(
        "Average slides per presentation: {}",
        total_slides / iterations
    );

    // =========== Performance Comparison ===========
    if !single_thread_bench.results.is_empty()
        && !single_thread_streamed_bench.results.is_empty()
        && !optimized_multi_thread_bench.results.is_empty()
    {
        let single_avg: Duration = single_thread_bench.results.iter().sum::<Duration>()
            / single_thread_bench.results.len() as u32;
        let single_streamed_avg: Duration = single_thread_streamed_bench
            .results
            .iter()
            .sum::<Duration>()
            / single_thread_streamed_bench.results.len() as u32;
        let optimized_multi_avg: Duration = optimized_multi_thread_bench
            .results
            .iter()
            .sum::<Duration>()
            / optimized_multi_thread_bench.results.len() as u32;

        println!("\nPerformance Comparison");
        println!("=====================");
        println!("Single-threaded average: {:?}", single_avg);
        println!(
            "Single-threaded streaming average: {:?}",
            single_streamed_avg
        );
        println!(
            "Optimized multi-threaded average: {:?}",
            optimized_multi_avg
        );

        // Compare single-threaded vs single-threaded streaming
        if single_avg > single_streamed_avg {
            let speedup = single_avg.as_secs_f64() / single_streamed_avg.as_secs_f64();
            println!(
                "Single-threaded streaming is {:.2}x faster than single-threaded",
                speedup
            );
        } else {
            let slowdown = single_streamed_avg.as_secs_f64() / single_avg.as_secs_f64();
            println!(
                "Single-threaded streaming is {:.2}x slower than single-threaded",
                slowdown
            );
        }

        // Compare single-threaded vs optimized multithreaded
        if single_avg > optimized_multi_avg {
            let speedup = single_avg.as_secs_f64() / optimized_multi_avg.as_secs_f64();
            println!(
                "Optimized multi-threaded is {:.2}x faster than single-threaded",
                speedup
            );
        } else {
            let slowdown = optimized_multi_avg.as_secs_f64() / single_avg.as_secs_f64();
            println!(
                "Optimized multi-threaded is {:.2}x slower than single-threaded",
                slowdown
            );
        }

        // Compare single-threaded streaming vs optimized multithreaded
        if single_streamed_avg > optimized_multi_avg {
            let speedup = single_streamed_avg.as_secs_f64() / optimized_multi_avg.as_secs_f64();
            println!(
                "Optimized multi-threaded is {:.2}x faster than single-threaded streaming",
                speedup
            );
        } else {
            let slowdown = optimized_multi_avg.as_secs_f64() / single_streamed_avg.as_secs_f64();
            println!(
                "Optimized multi-threaded is {:.2}x slower than single-threaded streaming",
                slowdown
            );
        }

        // Determine the overall fastest approach
        let fastest_approach = if single_avg <= single_streamed_avg
            && single_avg <= optimized_multi_avg
        {
            "Single-threaded"
        } else if single_streamed_avg <= single_avg && single_streamed_avg <= optimized_multi_avg {
            "Single-threaded streaming"
        } else {
            "Optimized multi-threaded"
        };

        println!(
            "\nOverall result: {} approach is the fastest for this workload.",
            fastest_approach
        );
    }

    Ok(())
}

pub fn to_markdown(&self, options: &MarkdownOptions) -> Result<String>

pub fn extract_slide_number(path: &str) -> Option<u32>

Extracts the numeric slide identifier from a slide path.

Helper method to parse slide numbers from internal pptx slide paths (e.g., “ppt/slides/slide1.xml” → 1).

pub fn link_images(&mut self)

Links slide images references with their corresponding targets.

Ensures that each image referenced by its ID is correctly linked to the actual internal resource paths stored in the slide. This method is typically used internally after parsing a slide

Notes

Internally those are the values image references are holding

Parameter	Example value
id	rId2
target	../media/image2.png

pub fn get_image_extension(&self, path: &str) -> String

Extracts the file extension from image paths

Examples found in repository

examples/manual_image_extraction.rs (line 65)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let Some(input_path) = args.get(1) else {
        eprintln!(
            "Usage: cargo run --example manual_image_extraction <presentation.pptx|presentation.odp>"
        );
        return Ok(());
    };

    println!("Processing presentation: {input_path}");

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Manually)
        .build();

    let mut container = PresentationContainer::open(Path::new(input_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Create output directory
    let output_dir = "extracted_images";
    fs::create_dir_all(output_dir)?;

    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        writeln!(md_file, "{}", slide.convert_to_md()?)?;

        // Manually load the base64 encoded image strings from the slide
        if let Some(images) = slide.load_images_manually() {
            for image in images {
                // Decode the base64 strings back to raw image data
                let image_data = general_purpose::STANDARD
                    .decode(image.base64_content.clone())
                    .expect("parser returned invalid base64 image data");

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = if slide.config.compress_images {
                    "jpg".to_string()
                } else {
                    slide.get_image_extension(&image.img_ref.target.clone())
                };

                // Construct a unique file name
                let file_name = format!(
                    "slide{}_image{}_{}",
                    slide.slide_number, image_count, &image.img_ref.id
                );

                // Save the image
                let output_path = format!("{}/{}.{}", output_dir, &file_name, ext);
                fs::write(&output_path, image_data)?;
                println!("Saved image to {}", output_path);

                // Write the image data into the Markdown file
                writeln!(
                    md_file,
                    "![{}](data:image/{};base64,{})",
                    file_name, ext, image.base64_content
                )?;

                image_count += 1;
            }
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

pub fn compress_image(&self, image_data: &[u8]) -> Option<Vec<u8>>

Compresses the image data and returning it as a jpg byte slice

Parameter

• image_data: The raw image data as a byte array

Returns

• Vec<u8>: Returns the compressed and converted jpg byte array

Notes

All images will be converted to jpg

pub fn load_images_manually(&self) -> Option<Vec<ManualImage>>

Examples found in repository

examples/manual_image_extraction.rs (line 54)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let Some(input_path) = args.get(1) else {
        eprintln!(
            "Usage: cargo run --example manual_image_extraction <presentation.pptx|presentation.odp>"
        );
        return Ok(());
    };

    println!("Processing presentation: {input_path}");

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Manually)
        .build();

    let mut container = PresentationContainer::open(Path::new(input_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Create output directory
    let output_dir = "extracted_images";
    fs::create_dir_all(output_dir)?;

    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        writeln!(md_file, "{}", slide.convert_to_md()?)?;

        // Manually load the base64 encoded image strings from the slide
        if let Some(images) = slide.load_images_manually() {
            for image in images {
                // Decode the base64 strings back to raw image data
                let image_data = general_purpose::STANDARD
                    .decode(image.base64_content.clone())
                    .expect("parser returned invalid base64 image data");

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = if slide.config.compress_images {
                    "jpg".to_string()
                } else {
                    slide.get_image_extension(&image.img_ref.target.clone())
                };

                // Construct a unique file name
                let file_name = format!(
                    "slide{}_image{}_{}",
                    slide.slide_number, image_count, &image.img_ref.id
                );

                // Save the image
                let output_path = format!("{}/{}.{}", output_dir, &file_name, ext);
                fs::write(&output_path, image_data)?;
                println!("Saved image to {}", output_path);

                // Write the image data into the Markdown file
                writeln!(
                    md_file,
                    "![{}](data:image/{};base64,{})",
                    file_name, ext, image.base64_content
                )?;

                image_count += 1;
            }
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

Trait Implementations

impl Debug for Slide

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.