Class Presentation

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[Guid("43247d92-4bb9-4883-b807-4b77b186c741")]
public sealed class Presentation

// Instantiate a Presentation object that represents a presentation file
using (Presentation presentation = new Presentation())
{
    // Get the first slide
    ISlide slide = presentation.Slides[0];
    // Add an autoshape of type line
    slide.Shapes.AddAutoShape(ShapeType.Line, 50, 150, 300, 0);
	// Save the presentation file.
    presentation.Save("NewPresentation_out.pptx", SaveFormat.Pptx);
}

// Load any supported file in Presentation e.g. ppt, pptx, odp etc.
using (Presentation presentation = new Presentation("Sample.odp"))
{
	// Save the presentation file.
	presentation.Save("OutputPresenation.pptx", SaveFormat.Pptx);
}

public Presentation()

public Presentation(LoadOptions loadOptions)

public Presentation(Stream stream)

FileStream fis = new FileStream("demo.pptx", FileMode.Open, FileAccess.Read);
Presentation pres = new Presentation(fis);
fis.Close();

Dim fis As FileStream = New FileStream("demo.pptx", FileMode.Open, FileAccess.Read)
Dim pres As Presentation = New Presentation(fis)
fis.Close()

public Presentation(Stream stream, LoadOptions loadOptions)

public Presentation(string file)

Presentation pres = new Presentation("demo.pptx");

Dim pres As Presentation = New Presentation("demo.pptx")

public Presentation(string file, LoadOptions loadOptions)

public ICustomXmlPart[] AllCustomXmlParts { get; }

using (Presentation pres = new Presentation("PresentationWithCustomXml.pptx"))
{
	// Iterate all custom XML Parts
    foreach (ICustomXmlPart item in pres.AllCustomXmlParts)
    {
        item.Remove();
    }
    pres.Save("out.pptx", SaveFormat.Pptx);
}

public IAudioCollection Audios { get; }

using (Presentation pres = new Presentation())
{
    IAudio audio = pres.Audios.AddAudio(File.ReadAllBytes("audio.mp3"));
    IAudioFrame audioFrame = pres.Slides[0].Shapes.AddAudioFrameEmbedded(10, 10, 100, 100, audio);
    audioFrame.HyperlinkClick = new Hyperlink("https://www.aspose.com/");
    audioFrame.HyperlinkClick.Tooltip = "More than 70% Fortune 100 companies trust Aspose APIs";
    pres.Save("pres-out.pptx", SaveFormat.Pptx);
}

public ICommentAuthorCollection CommentAuthors { get; }

public DateTime CurrentDateTime { get; set; }

public ICustomData CustomData { get; }

public ITextStyle DefaultTextStyle { get; }

public IDigitalSignatureCollection DigitalSignatures { get; }

using (Presentation pres = new Presentation("SomePresentationSigned.pptx"))
{
    if (pres.DigitalSignatures.Count > 0)
    {
        bool allSignaturesAreValid = true;

        Console.WriteLine("Signatures used to sign the presentation: ");
        foreach (DigitalSignature signature in pres.DigitalSignatures)
        {
            Console.WriteLine(signature.Certificate.SubjectName.Name + ", "
                    + signature.SignTime.ToString("yyyy-MM-dd HH:mm") + " -- " + (signature.IsValid ? "VALID" : "INVALID"));
            allSignaturesAreValid &= signature.IsValid;
        }

        if (allSignaturesAreValid)
            Console.WriteLine("Presentation is genuine, all signatures are valid.");
        else
            Console.WriteLine("Presentation has been modified since signing.");
    }
}

public IDocumentProperties DocumentProperties { get; }

public int FirstSlideNumber { get; set; }

public IFontsManager FontsManager { get; }

// Load presentation
using (Presentation presentation = new Presentation("Fonts.pptx"))
{
	// Load source font to be replaced
	IFontData sourceFont = new FontData("Arial");
	IFontData[] allFonts = presentation.FontsManager.GetFonts();
	IFontData[] embeddedFonts = presentation.FontsManager.GetEmbeddedFonts();
	foreach (IFontData font in allFonts)
	{
		if (!embeddedFonts.Contains(font))
		{
			presentation.FontsManager.AddEmbeddedFont(font, EmbedFontCharacters.All);
		}
	}
	// Save the presentation
	presentation.Save("AddEmbeddedFont_out.pptx", SaveFormat.Pptx);
}

public IPresentationHeaderFooterManager HeaderFooterManager { get; }

using (Presentation presentation = new Presentation("presentation.ppt"))
{
    IBaseSlideHeaderFooterManager headerFooterManager = presentation.Slides[0].HeaderFooterManager;
	// Property IsFooterVisible is used for indicating that a slide footer placeholder is not present.
    if (!headerFooterManager.IsFooterVisible)
    {
		// Method SetFooterVisibility is used for making a slide footer placeholder visible.
        headerFooterManager.SetFooterVisibility(true);
    }
	// Property IsSlideNumberVisible is used for indicating that a slide page number placeholder is not present.
    if (!headerFooterManager.IsSlideNumberVisible)
    {
		// Method SetSlideNumberVisibility is used for making a slide page number placeholder visible.
        headerFooterManager.SetSlideNumberVisibility(true);
    }
	// Property IsDateTimeVisible is used for indicating that a slide date-time placeholder is not present.
    if (!headerFooterManager.IsDateTimeVisible)
    {
		// Method SetFooterVisibility is used for making a slide date-time placeholder visible.
        headerFooterManager.SetDateTimeVisibility(true);
    }
	// Method SetFooterText is used for setting text to slide footer placeholder.
    headerFooterManager.SetFooterText("Footer text");
	// Method SetDateTimeText is used for setting text to slide date-time placeholder.
    headerFooterManager.SetDateTimeText("Date and time text");
	presentation.Save("Presentation.ppt",SaveFormat.ppt);
}

using (Presentation presentation = new Presentation("presentation.ppt"))
{
    IMasterSlideHeaderFooterManager headerFooterManager = presentation.Masters[0].HeaderFooterManager;
	// Method SetFooterAndChildFootersVisibility is used for making a master slide and all child footer placeholders visible.
    headerFooterManager.SetFooterAndChildFootersVisibility(true);
	// Method SetSlideNumberAndChildSlideNumbersVisibility is used for making a master slide and all child page number placeholders visible.
    headerFooterManager.SetSlideNumberAndChildSlideNumbersVisibility(true);
	// Method SetDateTimeAndChildDateTimesVisibility is used for making a master slide and all child date-time placeholders visible.
    headerFooterManager.SetDateTimeAndChildDateTimesVisibility(true);
	// Method SetFooterAndChildFootersText is used for setting text to master slide and all child footer placeholders.
    headerFooterManager.SetFooterAndChildFootersText("Footer text");
	// Method SetDateTimeAndChildDateTimesText is used for setting text to master slide and all child date-time placeholders.
    headerFooterManager.SetDateTimeAndChildDateTimesText("Date and time text");
}

public IHyperlinkQueries HyperlinkQueries { get; }

public IImageCollection Images { get; }

string pathToLargeImage = "large_image.jpg";
// creates a new presentation to which the image will be added.
using (Presentation pres = new Presentation())
{
	using (FileStream fileStream = new FileStream(pathToLargeImage, FileMode.Open))
	{
		// Let's add the image to the presentation - we choose KeepLocked behavior because we do
		// NOT intend to access the "largeImage.png" file.
		IPPImage img = pres.Images.AddImage(fileStream, LoadingStreamBehavior.KeepLocked);
		pres.Slides[0].Shapes.AddPictureFrame(ShapeType.Rectangle, 0, 0, 300, 200, img);
		// Saves the presentation. While a large presentation gets outputted, the memory consumption
		// stays low through the pres object's lifecycle
		pres.Save("presentationWithLargeImage.pptx", SaveFormat.Pptx);
	}
}

using (Presentation pres = new Presentation())
{
    // Adds image to presentation
    IPPImage image = pres.Images.AddImage(File.ReadAllBytes("image.png"));
    // Creates picture frame on slide 1 based on previously added image
    IPictureFrame pictureFrame = pres.Slides[0].Shapes.AddPictureFrame(ShapeType.Rectangle, 10, 10, 100, 100, image);
    pictureFrame.HyperlinkClick = new Hyperlink("https://www.aspose.com/");
    pictureFrame.HyperlinkClick.Tooltip = "More than 70% Fortune 100 companies trust Aspose APIs";
    pres.Save("pres-out.pptx", SaveFormat.Pptx);
}

public IGlobalLayoutSlideCollection LayoutSlides { get; }

public IMasterHandoutSlideManager MasterHandoutSlideManager { get; }

public IMasterNotesSlideManager MasterNotesSlideManager { get; }

public IMasterTheme MasterTheme { get; }

//Instantiate a presentation object that represents a presentation file
using (Presentation pres = new Presentation("Subtle_Moderate_Intense.pptx"))
{
    pres.MasterTheme.FormatScheme.LineStyles[0].FillFormat.SolidFillColor.Color = Color.Red;
    pres.MasterTheme.FormatScheme.FillStyles[2].FillType = FillType.Solid;
    pres.MasterTheme.FormatScheme.FillStyles[2].SolidFillColor.Color = Color.ForestGreen;
    pres.MasterTheme.FormatScheme.EffectStyles[2].EffectFormat.OuterShadowEffect.Distance = 10f;
    pres.Save("Design_04_Subtle_Moderate_Intense-out.pptx", SaveFormat.Pptx);
}

public IMasterSlideCollection Masters { get; }

using (Presentation pres = new Presentation())
{
    ISlide slide = pres.Slides[0];
    IMasterSlide masterSlide = slide.LayoutSlide.MasterSlide;
    IPPImage image = pres.Images.AddImage(File.ReadAllBytes("image.png"));
    masterSlide.Shapes.AddPictureFrame(ShapeType.Rectangle, 10, 10, 100, 100, image);
    pres.Save("pres.pptx", SaveFormat.Pptx);
}

// Instantiate the Presentation class that represents the presentation file
using (Presentation pres = new Presentation())
{
    // Set the background color of the Master ISlide to Forest Green
    pres.Masters[0].Background.Type = BackgroundType.OwnBackground;
    pres.Masters[0].Background.FillFormat.FillType = FillType.Solid;
    pres.Masters[0].Background.FillFormat.SolidFillColor.Color = Color.ForestGreen;
    // Write the presentation to disk
    pres.Save("SetSlideBackgroundMaster_out.pptx", SaveFormat.Pptx);
}

// Instantiate Presentation class that represents the presentation file
using (Presentation presentation = new Presentation("AccessSlides.pptx"))
{
    // Try to search by layout slide type
    IMasterLayoutSlideCollection layoutSlides = presentation.Masters[0].LayoutSlides;
    ILayoutSlide layoutSlide = layoutSlides.GetByType(SlideLayoutType.TitleAndObject) ?? layoutSlides.GetByType(SlideLayoutType.Title);
    if (layoutSlide == null)
    {
        // The situation when a presentation doesn't contain some type of layouts.
        // presentation File only contains Blank and Custom layout types.
        // But layout slides with Custom types has different slide names,
        // like "Title", "Title and Content", etc. And it is possible to use these
        // names for layout slide selection.
        // Also it is possible to use the set of placeholder shape types. For example,
        // Title slide should have only Title pleceholder type, etc.
        foreach (ILayoutSlide titleAndObjectLayoutSlide in layoutSlides)
        {
            if (titleAndObjectLayoutSlide.Name == "Title and Object")
            {
                layoutSlide = titleAndObjectLayoutSlide;
                break;
            }
        }
        if (layoutSlide == null)
        {
            foreach (ILayoutSlide titleLayoutSlide in layoutSlides)
            {
                if (titleLayoutSlide.Name == "Title")
                {
                    layoutSlide = titleLayoutSlide;
                    break;
                }
            }
            if (layoutSlide == null)
            {
                layoutSlide = layoutSlides.GetByType(SlideLayoutType.Blank);
                if (layoutSlide == null)
                {
                    layoutSlide = layoutSlides.Add(SlideLayoutType.TitleAndObject, "Title and Object");
                }
            }
        }
    }
    // Adding empty slide with added layout slide
    presentation.Slides.InsertEmptySlide(0, layoutSlide);
    // Save presentation
    presentation.Save("AddLayoutSlides_out.pptx", SaveFormat.Pptx);
}

public INotesSize NotesSize { get; }

public IProtectionManager ProtectionManager { get; }

public ISectionCollection Sections { get; }

using (Presentation pres = new Presentation())
{
    ISlide defaultSlide = pres.Slides[0];
    ISlide newSlide1 = pres.Slides.AddEmptySlide(pres.LayoutSlides[0]);
    ISlide newSlide2 = pres.Slides.AddEmptySlide(pres.LayoutSlides[0]);
    ISlide newSlide3 = pres.Slides.AddEmptySlide(pres.LayoutSlides[0]);
    ISlide newSlide4 = pres.Slides.AddEmptySlide(pres.LayoutSlides[0]);
    ISection section1 = pres.Sections.AddSection("Section 1", newSlide1);
	// section1 will be ended at newSlide2 and after it section2 will start
    ISection section2 = pres.Sections.AddSection("Section 2", newSlide3);
    pres.Save("pres-sections.pptx", SaveFormat.Pptx);
    pres.Sections.ReorderSectionWithSlides(section2, 0);
    pres.Save("pres-sections-moved.pptx", SaveFormat.Pptx);
    pres.Sections.RemoveSectionWithSlides(section2);
    pres.Sections.AppendEmptySection("Last empty section");
    pres.Save("pres-section-with-empty.pptx",SaveFormat.Pptx);
}

using (Presentation pres = new Presentation("pres.pptx"))
{
   ISection section = pres.Sections[0];
   section.Name = "My section";
}

public SlideShowSettings SlideShowSettings { get; }

public ISlideSize SlideSize { get; }

using (Presentation pres = new Presentation("pres-4x3-aspect-ratio.pptx"))
{
    pres.SlideSize.SetSize(SlideSizeType.OnScreen16x9, SlideSizeScaleType.DoNotScale);
    pres.Save("pres-4x3-aspect-ratio.pptx", SaveFormat.Pptx);
}

// Instantiate a Presentation object that represents a presentation file
using(Presentation presentation = new Presentation("AccessSlides.pptx")) {
  using(Presentation auxPresentation = new Presentation()) {
    ISlide slide = presentation.Slides[0];
    // Set the slide size of generated presentations to that of source
    presentation.SlideSize.SetSize(540, 720, SlideSizeScaleType.EnsureFit); // Method SetSize is used for set slide size with scale content to ensure fit
    presentation.SlideSize.SetSize(SlideSizeType.A4Paper, SlideSizeScaleType.Maximize); // Method SetSize is used for set slide size with maximize size of content
    // Save Presentation to disk
    auxPresentation.Save("Set_Size&Type_out.pptx", SaveFormat.Pptx);
  }
}

using (Presentation pres = new Presentation("pres.pptx"))
{
    pres.SlideSize.SetSize(780, 540, SlideSizeScaleType.DoNotScale); // A4 paper size
    pres.Save("pres-a4-slide-size.pptx", SaveFormat.Pptx);
}

public ISlideCollection Slides { get; }

// Instantiate the Presentation class that represents the presentation file
using (Presentation pres = new Presentation())
{
    // Set the background color of the first ISlide to Blue
    pres.Slides[0].Background.Type = BackgroundType.OwnBackground;
    pres.Slides[0].Background.FillFormat.FillType = FillType.Solid;
    pres.Slides[0].Background.FillFormat.SolidFillColor.Color = Color.Blue;
    pres.Save("ContentBG_out.pptx", SaveFormat.Pptx);
}

// Instantiate the Presentation class that represents the presentation file
using (Presentation pres = new Presentation("SetImageAsBackground.pptx"))
{
    // Set the background with Image
    pres.Slides[0].Background.Type = BackgroundType.OwnBackground;
    pres.Slides[0].Background.FillFormat.FillType = FillType.Picture;
    pres.Slides[0].Background.FillFormat.PictureFillFormat.PictureFillMode = PictureFillMode.Stretch;
    // Set the picture
    System.Drawing.Image img = (System.Drawing.Image)new Bitmap(dataDir + "Tulips.jpg");
    // Add image to presentation's images collection
    IPPImage imgx = pres.Images.AddImage(img);
    pres.Slides[0].Background.FillFormat.PictureFillFormat.Picture.Image = imgx;
    // Write the presentation to disk
    pres.Save("ContentBG_Img_out.pptx", SaveFormat.Pptx);
}

// Instantiate Presentation class to load the source presentation file
using (Presentation presentation = new Presentation("AccessSlides.pptx"))
{
    // Apply circle type transition on slide 1
    presentation.Slides[0].SlideShowTransition.Type = TransitionType.Circle;
    // Apply comb type transition on slide 2
    presentation.Slides[1].SlideShowTransition.Type = TransitionType.Comb;
    // Write the presentation to disk
    presentation.Save("SampleTransition_out.pptx", SaveFormat.Pptx);
}

// Instantiate Presentation class that represents a presentation file
using (Presentation pres = new Presentation("BetterSlideTransitions.pptx"))
{
    // Apply circle type transition on slide 1
    pres.Slides[0].SlideShowTransition.Type = TransitionType.Circle;
    // Set the transition time of 3 seconds
    pres.Slides[0].SlideShowTransition.AdvanceOnClick = true;
    pres.Slides[0].SlideShowTransition.AdvanceAfterTime = 3000;
    // Apply comb type transition on slide 2
    pres.Slides[1].SlideShowTransition.Type = TransitionType.Comb;
    // Set the transition time of 5 seconds
    pres.Slides[1].SlideShowTransition.AdvanceOnClick = true;
    pres.Slides[1].SlideShowTransition.AdvanceAfterTime = 5000;
    // Apply zoom type transition on slide 3
    pres.Slides[2].SlideShowTransition.Type = TransitionType.Zoom;
    // Set the transition time of 7 seconds
    pres.Slides[2].SlideShowTransition.AdvanceOnClick = true;
    pres.Slides[2].SlideShowTransition.AdvanceAfterTime = 7000;
    // Write the presentation to disk
    pres.Save("SampleTransition_out.pptx", SaveFormat.Pptx);
}

public SourceFormat SourceFormat { get; }

public IVbaProject VbaProject { get; set; }

public IVideoCollection Videos { get; }

// Instantiate Presentation class that represents the PPTX
using (Presentation pres = new Presentation())
{
    // Get the first slide
    ISlide sld = pres.Slides[0];
    // Embedd vide inside presentation
    IVideo vid = pres.Videos.AddVideo(new FileStream("Wildlife.mp4", FileMode.Open));
    // Add Video Frame
    IVideoFrame vf = sld.Shapes.AddVideoFrame(50, 150, 300, 350, vid);
    // Set video to Video Frame
    vf.EmbeddedVideo = vid;
    // Set Play Mode and Volume of the Video
    vf.PlayMode = VideoPlayModePreset.Auto;
    vf.Volume = AudioVolumeMode.Loud;
    // Write the PPTX file to disk
    pres.Save("VideoFrame_out.pptx", SaveFormat.Pptx);
}

using (Presentation pres = new Presentation())
{
    ISlide sld = pres.Slides[0];
    IVideoFrame vf = sld.Shapes.AddVideoFrame(50, 150, 300, 150, "video1.avi");
}

const string pathToVeryLargeVideo = "veryLargeVideo.avi";
// Creates a new presentation to which the video will be added
using (Presentation pres = new Presentation())
{
    using (FileStream fileStream = new FileStream(pathToVeryLargeVideo, FileMode.Open))
    {
        // Let's add the video to the presentation - we chose the KeepLocked behavior because we do
        //not intend to access the "veryLargeVideo.avi" file.
        IVideo video = pres.Videos.AddVideo(fileStream, LoadingStreamBehavior.KeepLocked);
        pres.Slides[0].Shapes.AddVideoFrame(0, 0, 480, 270, video);
        // Saves the presentation. While a large presentation gets outputted, the memory consumption
        // stays low through the pres object's lifecycle
        pres.Save("presentationWithLargeVideo.pptx", SaveFormat.Pptx);
    }
}

const string hugePresentationWithAudiosAndVideosFile = @"Large  Video File Test1.pptx";
LoadOptions loadOptions = new LoadOptions
{
	BlobManagementOptions = {
		// Locks the source file and does NOT load it into memory
		PresentationLockingBehavior = PresentationLockingBehavior.KeepLocked,
	}
};
// Creates a Presentation's instance, locks the "hugePresentationWithAudiosAndVideos.pptx" file.
using (Presentation pres = new Presentation(hugePresentationWithAudiosAndVideosFile, loadOptions))
{
	// Let's save each video to a file. To prevent high memory usage, we need a buffer that will be used
	// to transfer the data from the presentation's video stream to a stream for a newly created video file.
	byte[] buffer = new byte[8 * 1024];
	// Iterates through the videos
	for (var index = 0; index < pres.Videos.Count; index++)
	{
		IVideo video = pres.Videos[index];
		// Opens the presentation video stream. Please, note that we intentionally avoided accessing properties
		// like video.BinaryData - because this property returns a byte array containing a full video, which then
		// causes bytes to be loaded into memory. We use video.GetStream, which will return Stream - and does NOT
		//  require us to load the whole video into the memory.
		using (Stream presVideoStream = video.GetStream())
		{
			using (FileStream outputFileStream = File.OpenWrite($"video{index}.avi"))
			{
				int bytesRead;
				while ((bytesRead = presVideoStream.Read(buffer, 0, buffer.Length)) > 0)
				{
					outputFileStream.Write(buffer, 0, bytesRead);
				}
			}
		}
		// Memory consumption will remain low regardless of the size of the video or presentation,
	}
	// If necessary, you can apply the same steps for audio files.
}

using (Presentation pres = new Presentation())
{
    IVideo video = pres.Videos.AddVideo(File.ReadAllBytes("video.avi"));
    IVideoFrame videoFrame = pres.Slides[0].Shapes.AddVideoFrame(10, 10, 100, 100, video);
    videoFrame.HyperlinkClick = new Hyperlink("https://www.aspose.com/");
    videoFrame.HyperlinkClick.Tooltip = "More than 70% Fortune 100 companies trust Aspose APIs";
    pres.Save("pres-out.pptx", SaveFormat.Pptx);
}

public static void Run()
{
    using (Presentation pres = new Presentation())
    {
        AddVideoFromYouTube(pres, "Tj75Arhq5ho");
        pres.Save("AddVideoFrameFromWebSource_out.pptx", SaveFormat.Pptx);
    }
}
private static void AddVideoFromYouTube(Presentation pres, string videoId)
{
    //add videoFrame
    IVideoFrame videoFrame = pres.Slides[0].Shapes.AddVideoFrame(10, 10, 427, 240, "https://www.youtube.com/embed/" + videoId);
    videoFrame.PlayMode = VideoPlayModePreset.Auto;
    //load thumbnail
    using (WebClient client = new WebClient())
    {
        string thumbnailUri = "http://img.youtube.com/vi/" + videoId + "/hqdefault.jpg";
        videoFrame.PictureFormat.Picture.Image = pres.Images.AddImage(client.DownloadData(thumbnailUri));
    }
}

// Instantiate a Presentation object that represents a presentation file
using (Presentation presentation = new Presentation("Video.pptx"))
{
	foreach (ISlide slide in presentation.Slides)
	{
		foreach (IShape shape in presentation.Slides[0].Shapes)
		{
			if (shape is VideoFrame)
			{
				IVideoFrame vf = shape as IVideoFrame;
				String type = vf.EmbeddedVideo.ContentType;
				int ss = type.LastIndexOf('/');
				type = type.Remove(0, type.LastIndexOf('/') + 1);
				Byte[] buffer = vf.EmbeddedVideo.BinaryData;
				using (FileStream stream = new FileStream("NewVideo_out." + type, FileMode.Create, FileAccess.Write, FileShare.Read))
				{
					stream.Write(buffer, 0, buffer.Length);
				}
			}
		}
	}
}

public IViewProperties ViewProperties { get; }

public void Dispose()

protected ~Presentation()

public IImage[] GetImages(IRenderingOptions options)

public IImage[] GetImages(IRenderingOptions options, int[] slides)

public IImage[] GetImages(IRenderingOptions options, float scaleX, float scaleY)

public IImage[] GetImages(IRenderingOptions options, int[] slides, float scaleX, float scaleY)

public IImage[] GetImages(IRenderingOptions options, Size imageSize)

public IImage[] GetImages(IRenderingOptions options, int[] slides, Size imageSize)

public IBaseSlide GetSlideById(uint id)

public void HighlightRegex(Regex regex, Color highlightColor, IFindResultCallback callback)

using (Presentation presentation = new Presentation("SomePresentation.pptx"))
{
	Regex regex = new Regex(@"\b[^\s]{10,}\b");
	// highlighting all words with 10 or more characters
	presentation.HighlightRegex(regex, Color.Blue, null);
	presentation.Save("SomePresentation-out.pptx", SaveFormat.Pptx);
}

public void HighlightText(string text, Color highlightColor)

using (Presentation presentation = new Presentation("SomePresentation.pptx"))
{
	// highlighting all separate 'the' occurrences
	presentation.HighlightText("the", Color.Violet);
	presentation.Save("SomePresentation-out2.pptx", SaveFormat.Pptx);
}

public void HighlightText(string text, Color highlightColor, ITextSearchOptions options, IFindResultCallback callback)

using (Presentation presentation = new Presentation("SomePresentation.pptx"))
{
	// highlighting all separate 'the' occurrences
	presentation.HighlightText("the", Color.Violet, new TextSearchOptions() {WholeWordsOnly = true}, null);
	presentation.Save("SomePresentation-out2.pptx", SaveFormat.Pptx);
}

public void JoinPortionsWithSameFormatting()

public void ReplaceRegex(Regex regex, string newText, IFindResultCallback callback)

using (Presentation presentation = new Presentation("SomePresentation.pptx"))
{
	Regex regex = new Regex(@"\b[^\s]{10,}\b");
	// Replace all words with 10 or more characters with '***'
	presentation.ReplaceRegex(regex, "***", null);
	presentation.Save("SomePresentation-out.pptx", SaveFormat.Pptx);
}

public void ReplaceText(string oldText, string newText, ITextSearchOptions options, IFindResultCallback callback)

using (Presentation presentation = new Presentation("SomePresentation.pptx"))
{
	// Replace all separate 'the' occurrences with '***'
	presentation.ReplaceText("the", "***", new TextSearchOptions() {WholeWordsOnly = true}, null);
	presentation.Save("SomePresentation-out2.pptx", SaveFormat.Pptx);
}

public void Save(string fname, SaveFormat format)

public void Save(Stream stream, SaveFormat format)

public void Save(string fname, SaveFormat format, ISaveOptions options)

public void Save(Stream stream, SaveFormat format, ISaveOptions options)

public void Save(IXamlOptions options)

using (Presentation pres = new Presentation("pres.pptx"))
{
	pres.Save(new XamlOptions { ExportHiddenSlides = true });
}

public void Save(string fname, int[] slides, SaveFormat format)

public void Save(string fname, int[] slides, SaveFormat format, ISaveOptions options)

public void Save(Stream stream, int[] slides, SaveFormat format)

public void Save(Stream stream, int[] slides, SaveFormat format, ISaveOptions options)

using (Presentation pres = new Presentation("pres.pptx"))
{
    for (var index = 0; index < pres.Slides.Count; index++)
    {
        ISlide slide = pres.Slides[index];
        slide.GetThumbnail().Save($"slide_{index}.png", ImageFormat.Png);
    }
}

using (Presentation pres = new Presentation("pres.pptx"))
{
    float scaleX = 2f;
    float scaleY = 2f;
    for (var index = 0; index < pres.Slides.Count; index++)
    {
        ISlide slide = pres.Slides[index];
        slide.GetThumbnail(scaleX, scaleY).Save($"slide_{index}.png", ImageFormat.Png);
    }
}

using (Presentation pres = new Presentation("pres.pptx"))
{
    Size size = new Size(960, 720);
    for (var index = 0; index < pres.Slides.Count; index++)
    {
        ISlide slide = pres.Slides[index];
        slide.GetThumbnail(size).Save($"slide_{index}.png", ImageFormat.Png);
    }
}