Documentation – Developer Guide

Python-Net: Manage Presentations in Python

Mon, 01 Jan 0001 00:00:00 +0000

Python-Net: Manage Presentation Slides Using Python

Mon, 01 Jan 0001 00:00:00 +0000

Python-Net: Manage Presentation Content in Python

Mon, 01 Jan 0001 00:00:00 +0000

Python-Net: Design Professional Presentations in Python

Mon, 01 Jan 0001 00:00:00 +0000

Python-Net: Create a Presentation Viewer in Python

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Aspose.Slides for Python is used to create presentation files with slides. These slides can be viewed by opening the presentations in Microsoft PowerPoint, for example. However, developers may sometimes need to view slides as images in their preferred image viewer or use them in a custom presentation viewer. In such cases, Aspose.Slides allows you to export individual slides as images. This article explains how to do that.

Generate an SVG Image from a Slide

To generate an SVG image from a presentation slide with Aspose.Slides, follow the steps below:

Create an instance of the Presentation class.
Get a reference to the slide by its index.
Open a file stream.
Save the slide as an SVG image to the file stream.

import aspose.slides as slides

slide_index = 0

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[slide_index]

    with open("output.svg", "wb") as svg_stream:
        slide.write_as_svg(svg_stream)

Create a Slide Thumbnail Image

Aspose.Slides helps you generate thumbnail images of slides. To generate a thumbnail of a slide using Aspose.Slides, follow the steps below:

Create an instance of the Presentation class.
Get a reference to the slide by its index.
Create a thumbnail image of the referenced slide at the desired scale.
Save the thumbnail image in your preferred image format.

import aspose.slides as slides

slide_index = 0
scale_x = 1
scale_y = scale_x

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[slide_index]

    with slide.get_image(scale_x, scale_y) as image:
        image.save("output.jpg", slides.ImageFormat.JPEG)

Create a Slide Thumbnail with User Defined Dimensions

To create a slide thumbnail image with user-defined dimensions, follow the steps below:

Create an instance of the Presentation class.
Get a reference to the slide by its index.
Generate a thumbnail image of the referenced slide with the specified dimensions.
Save the thumbnail image in your preferred image format.

import aspose.slides as slides
import aspose.pydrawing as pydrawing

slide_index = 0
slide_size = pydrawing.Size(1200, 800)

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[slide_index]

    with slide.get_image(slide_size) as image:
        image.save("output.jpg", slides.ImageFormat.JPEG)

Create a Slide Thumbnail with Speaker Notes

To generate a thumbnail of a slide with speaker notes using Aspose.Slides, follow the steps below:

Create an instance of the RenderingOptions class.
Use the RenderingOptions.slides_layout_options property to set the position of the speaker notes.
Create an instance of the Presentation class.
Get a reference to the slide by its index.
Generate a thumbnail image of the referenced slide using the rendering options.
Save the thumbnail image in your preferred image format.

slide_index = 0

layout_options = slides.export.NotesCommentsLayoutingOptions()
layout_options.notes_position = slides.export.NotesPositions.BOTTOM_TRUNCATED

rendering_options = slides.export.RenderingOptions()
rendering_options.slides_layout_options = layout_options

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[slide_index]

    with slide.get_image(rendering_options) as image:
        image.save("output.png", slides.ImageFormat.PNG)

Live Example

Try Aspose.Slides Viewer free app to see what you can implement with Aspose.Slides API:

FAQ

Can I embed a presentation viewer in an ASP.NET web application?

Yes. You can use Aspose.Slides on the server side to render slides as images or HTML and display them in the browser. Navigation and zoom features can be implemented with JavaScript for an interactive experience.

What is the best way to display slides inside a custom .NET viewer?

The recommended approach is to render each slide as an image (e.g., PNG or SVG) or convert it to HTML using Aspose.Slides, then display the output inside a picture box (for desktop) or HTML container (for web).

How do I handle large presentations with many slides?

For large decks, consider lazy-loading or on-demand rendering of slides. This means generating a slide’s content only when the user navigates to it, reducing memory and load time.

Python-Net: Secure Presentations in Python

Mon, 01 Jan 0001 00:00:00 +0000

Python-Net: Manage Presentation Properties with Python

Mon, 01 Jan 0001 00:00:00 +0000

About Presentation Properties

As we have described earlier that Aspose.Slides for Python via .NET supports two kinds of document properties, which are Built-in and Custom properties. So, developers can access both kinds of properties with the use of Aspose.Slides for Python via .NET API. Aspose.Slides for Python via .NET provides a class IDocumentProperties that represents the document properties associated with a presentation file through Presentation.document_properties property. Developers can use IDocumentProperties property exposed by Presentation object to access the document properties of the presentation files as described below:

Please note that you cannot set values against the Application and Producer fields, because Aspose Ltd. and Aspose.Slides for Python via .NET x.x.x will be displayed against these fields.

Manage Presentation Properties

Microsoft PowerPoint provides a feature to add some properties to the presentation files. These document properties allow some useful information to be stored along with the documents (presentation files). There are two kinds of document properties as follows

System Defined (Built-in) Properties
User Defined (Custom) Properties

Built-in properties contain general information about the document like document title, author’s name, document statistics and so on. Custom properties are those ones, which are defined by the users as Name/Value pairs, where both name and value are defined by the user. Using Aspose.Slides for Python via .NET, developers can access and modify the values of built-in properties as well as custom properties. Microsoft PowerPoint 2007 allows managing the document properties of the presentation files. All you have to do is to click the Office icon and further Prepare | Properties | Advanced Properties menu item of the Microsoft PowerPoint 2007. After you select Advanced Properties menu item, a dialog would appear allowing you to manage the document properties of the PowerPoint file. In the Properties Dialog, you can see that there are many tab pages like General, Summary, Statistics, Contents and Custom. All these tab pages allow configuring different kinds of information related to the PowerPoint files. Custom tab is used to manage the custom properties of the PowerPoint files.

Access Built-in Properties

These properties as exposed by IDocumentProperties object include: Creator(Author), Description, Keywords Created (Creation Date), Modified Modification Date, Printed Last Print Date, LastModifiedBy, Keywords, SharedDoc (Is shared between different producers?), PresentationFormat, Subject and Title

import aspose.slides as slides

# Instantiate the Presentation class that represents the presentation
with slides.Presentation(path + "AccessBuiltin Properties.pptx") as pres:
    # Create a reference to object associated with Presentation
    documentProperties = pres.document_properties

    # Display the builtin properties
    print("category : " + documentProperties.category)
    print("Current Status : " + documentProperties.content_status)
    print("Creation Date : " + str(documentProperties.created_time))
    print("Author : " + documentProperties.author)
    print("Description : " + documentProperties.comments)
    print("KeyWords : " + documentProperties.keywords)
    print("Last Modified By : " + documentProperties.last_saved_by)
    print("Supervisor : " + documentProperties.manager)
    print("Modified Date : " + str(documentProperties.last_saved_time))
    print("Presentation Format : " + documentProperties.presentation_format)
    print("Last Print Date : " + str(documentProperties.last_printed))
    print("Is Shared between producers : " + str(documentProperties.shared_doc))
    print("Subject : " + documentProperties.subject)
    print("Title : " + documentProperties.title)

Modify Built-in Properties

Modifying the built-in properties of presentation files is as easy as that of accessing them. You can simply assign a string value to any desired property and the property value would be modified. In the example given below, we have demonstrated that how we can modify the built-in document properties of the presentation file.

import aspose.slides as slides

# Instantiate the Presentation class that represents the Presentation
with slides.Presentation(path + "ModifyBuiltinProperties.pptx") as presentation:
    # Create a reference to object associated with Presentation
    documentProperties = presentation.document_properties

    # Set the builtin properties
    documentProperties.author = "Aspose.Slides for .NET"
    documentProperties.title = "Modifying Presentation Properties"
    documentProperties.subject = "Aspose Subject"
    documentProperties.comments = "Aspose Description"
    documentProperties.manager = "Aspose Manager"

    # save your presentation to a file
    presentation.save("DocumentProperties_out.pptx", slides.export.SaveFormat.PPTX)

Add Custom Presentation Properties

Aspose.Slides for Python via .NET also allows developers to add the custom the values for presentation Document properties. An example is given below that shows how to set the custom properties for a presentation.

import aspose.slides as slides

# Instantiate the Presentation class
with slides.Presentation() as presentation:
    # Getting Document Properties
    documentProperties = presentation.document_properties

    # Adding Custom properties
    documentProperties.set_custom_property_value("New Custom", 12)
    documentProperties.set_custom_property_value("My Nam", "Mudassir")
    documentProperties.set_custom_property_value("Custom", 124)

    # Getting property name at particular index
    getPropertyName = documentProperties.get_custom_property_name(2)

    # Removing selected property
    documentProperties.remove_custom_property(getPropertyName)

    # Saving presentation
    presentation.save("CustomDocumentProperties_out.pptx", slides.export.SaveFormat.PPTX)

Access and Modify Custom Properties

Aspose.Slides for Python via .NET also allows developers to access the values of custom properties. An example is given below that shows how can you access and modify all of these custom properties for a presentation.

import aspose.slides as slides

# Instanciate the Presentation class that represents the PPTX
with slides.Presentation(path + "AccessModifyingProperties.pptx") as presentation:
    # Create a reference to document_properties object associated with Prsentation
    documentProperties = presentation.document_properties

    # Access and modify custom properties
    for i in range(documentProperties.count_of_custom_properties):
        # Display names and values of custom properties
        print("Custom Property Name : " + documentProperties.get_custom_property_name(i))
        print("Custom Property Value : " + documentProperties.get_custom_property_value[documentProperties.get_custom_property_name(i)])

        # Modify values of custom properties
        documentProperties.set_custom_property_value(documentProperties.get_custom_property_name(i), "New Value " + str(i + 1))
    # save your presentation to a file
    presentation.save("CustomDemoModified_out.pptx", slides.export.SaveFormat.PPTX)

Set Proofing Language

Aspose.Slides provides the Language_Id property (exposed by the PortionFormat class) to allow you to set the proofing language for a PowerPoint document. The proofing language is the language for which spellings and grammar in the PowerPoint are checked.

This Python code shows you how to set the proofing language for a PowerPoint:

import aspose.slides as slides

with slides.Presentation(path + "SetProofingLanguage.pptx") as pres:
    auto_shape = pres.slides[0].shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]
    paragraph.portions.clear()

    new_portion = slides.Portion()
    font = slides.FontData("SimSun")
    portion_format = new_portion.portion_format
    portion_format.complex_script_font = font
    portion_format.east_asian_font = font
    portion_format.latin_font = font

    # set the Id of a proofing language
    portion_format.language_id = "zh-CN"
    new_portion.text = "1。"

    paragraph.portions.add(new_portion)

Set Default Language

This Python code shows you how to set the default language for an entire PowerPoint presentation:

import aspose.slides as slides

load_options = slides.LoadOptions()
load_options.default_text_language = "en_US"

with slides.Presentation(load_options) as pres:
    shp = pres.slides[0].shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 50, 50, 150, 150)
    text_frame = shp.text_frame
    text_frame.text = "New Text"

    print(text_frame.paragraphs[0].portions[0].portion_format.language_id)

Live Example

Try Aspose.Slides Metadata online app to see how to work with document properties via Aspose.Slides API:

FAQ

How can I remove a built-in property from a presentation?

Built-in properties are an integral part of the presentation and cannot be removed entirely. However, you can either change their values or set them to empty if allowed by the specific property.

What happens if I add a custom property that already exists?

If you add a custom property that already exists, its existing value will be overwritten with the new one. You do not need to remove or check the property beforehand, as Aspose.Slides automatically updates the property’s value.

Can I access presentation properties without fully loading the presentation?

Yes, you can access presentation properties without fully loading the presentation by using the get_presentation_info method from the PresentationFactory class. Then, utilize the read_document_properties method provided by the PresentationInfo class to read the properties efficiently, saving memory and improving performance.

Python-Net: Retrieve and Update Presentation View Properties in Python

Mon, 01 Jan 0001 00:00:00 +0000

The normal view consists of three content regions: the slide itself, a side content region, and a bottom content region. Properties pertaining to the positioning of the different content regions. This information allows the application to save its view state to the file, so that when reopened the view is in the same state as when the presentation was last saved.

Property ViewProperties.normal_view_properties has been added to provide access to normal view properties of presentation.

NormalViewProperties, NormalViewRestoredProperties classes and its descendants, SplitterBarStateType enum have been added.

About INormalViewProperties

Represents normal view properties.

Property ShowOutlineIcons specifies whether the application should show icons if displaying outline content in any of the content regions of normal view mode.

Property SnapVerticalSplitter specifies whether the vertical splitter should snap to a minimized state when the side region is sufficiently small.

Property PreferSingleView specifies whether the user prefers to see a full-window single-content region over the standard normal view with three content regions. If enabled, the application may choose to display one of the content regions in the entire window.

Properties VerticalBarState and HorizontalBarState specify the state that the horizontal or vertical splitter bar should be shown in. A horizontal splitter bar separates the slide from the content region below the slide, vertical splitter bar separates the slide from the side content region. Possible values are: SplitterBarStateType.Minimized, SplitterBarStateType.Maximized and SplitterBarStateType.Restored.

Properties RestoredLeft and RestoredTop specify the sizing of the top or side slide region of the normal view, when SplitterBarStateType.Restored value applied for VerticalBarState and HorizontalBarState accordingly.

About Restoring INormalViewProperties

Specifies the sizing of the slide region (width when a child of RestoredTop, height when a child of RestoredLeft) of the normal view, when the region is of a variable restored size(neither minimized nor maximized).

Property DimensionSize specifies the size of the slide region (width when a child of restoredTop, height when a child of restoredLeft).

Property AutoAdjust specifies whether the size of the side content region should compensate for the new size when resizing the window containing the view within the application

An example is given below shows how can you access ViewProperties.NormalViewProperties properties for a presentation.

import aspose.slides as slides

with slides.Presentation(path + "AccessSlides.pptx") as pres:
    pres.view_properties.normal_view_properties.horizontal_bar_state = slides.SplitterBarStateType.RESTORED
    pres.view_properties.normal_view_properties.vertical_bar_state = slides.SplitterBarStateType.MAXIMIZED

    # Restore the view properties of the presentation
    pres.view_properties.normal_view_properties.restored_top.auto_adjust = True
    pres.view_properties.normal_view_properties.restored_top.dimension_size = 80
    pres.view_properties.normal_view_properties.show_outline_icons = True

    pres.save("presentation_normal_view_state.pptx", slides.export.SaveFormat.PPTX)

Set Default Zoom Value

Aspose.Slides for Python via .NET now supports setting the default zoom value for presentation such that when the presentation is opened, zoom is set already. This could be done by setting the view_properties of a presentation. Slide View Properties as well as notes_view_properties could be set programmatically. In this topic, we will see with an example how to set the View Properties of Presentation in Aspose.Slides.

In order to set the view properties. Please follow the steps below:

Create an instance of Presentation class
Set view properties of the presentation
Write the presentation as a PPTX file

In the example given below, we have set the zoom value for slide view as well as notes view.

import aspose.slides as slides

with slides.Presentation(path + "AccessSlides.pptx") as presentation:
    # Setting the view properties of the presentation
    presentation.view_properties.slide_view_properties.scale = 100 # Zoom value in percentages for slide view
    presentation.view_properties.notes_view_properties.scale = 100 # Zoom value in percentages for notes view 

    presentation.save("Zoom_out.pptx", slides.export.SaveFormat.PPTX)

FAQ

Can I set different view settings for different sections of a presentation?

View settings are defined at the presentation level (Normal View/Slide View), not per section, so a single set of parameters applies to the entire document when it opens.

Can I predefine different view states for different users?

No. The settings are stored in the file and are shared. Viewer applications may honor user preferences, but the file itself contains one set of view properties.

Can I prepare a template with predefined View Properties so new presentations open the same way?

Yes. Because view properties are stored at the presentation level, you can embed them in a template and create new documents from it with the same initial view configuration.

Python-Net: Manage Presentation Comments in Python

Mon, 01 Jan 0001 00:00:00 +0000

In PowerPoint, a comment appears as a note or annotation on a slide. When a comment is clicked, its contents or messages are revealed.

Why Add Comments to Presentations?

You may want to use comments to provide feedback or communicate with your colleagues when you review presentations.

To allow you to use comments in PowerPoint presentations, Aspose.Slides for Python via .NET provides

The Presentation class , which contains the collections of authors (from the CommentAuthorCollection property). The authors add comments to slides.
The CommentCollection class, which contains the collection of comments for individual authors.
The Comment class, which contains information on authors and their comments: who added the comment, the time the comment was added, the comment’s position, etc.
The CommentAuthor class, which contains information on individual authors: the author’s name, his initials, comments associated with the author’s name, etc.

Add Slide Comment

This Python code shows you how to add a comment to a slide in a PowerPoint presentation:

import aspose.slides as slides
import aspose.pydrawing as draw
import datetime

# Instantiates the Presentation class
with slides.Presentation() as presentation:
    # Adds an empty slide
    presentation.slides.add_empty_slide(presentation.layout_slides[0])

    # Adds an author
    author = presentation.comment_authors.add_author("Jawad", "MF")

    # Sets the position for comments
    point = draw.PointF(0.2, 0.2)

    # Adds slide comment for an author on slide 1
    author.comments.add_comment("Hello Jawad, this is slide comment", presentation.slides[0], point, datetime.date.today())

    # Adds slide comment for an author on slide 2
    author.comments.add_comment("Hello Jawad, this is second slide comment", presentation.slides[1], point, datetime.date.today())

    # Accessing ISlide 1
    slide = presentation.slides[0]

    # When null is passed as an argument, comments from all authors are brought to the selected slide
    comments = slide.get_slide_comments(author)

    # Accesses the comment at index 0 for slide 1
    str = comments[0].text

    presentation.save("Comments_out.pptx", slides.export.SaveFormat.PPTX)

    if comments.length > 0:
        # Selects the Author's comments collection at index 0
        commentCollection = comments[0].author.comments
        print(commentCollection[0].text)

Access Slide Comments

This Python code shows you how to access an existing comment on a slide in a PowerPoint presentation:

import aspose.slides as slides

# Instantiates the Presentation class
with slides.Presentation("Comments1.pptx") as presentation:
    for author in presentation.comment_authors:
        for comment in author.comments:
            print("ISlide :" + str(comment.slide.slide_number) + 
            " has comment: " + comment.text + 
            " with Author: " + comment.author.name + 
            " posted on time :" + str(comment.created_time) + "\n")

Reply Comments

A parent comment is the top or original comment in a hierarchy of comments or replies. Using the parent_comment property (from the Comment class), you can set or get a parent comment.

This Python code shows you how to add comments and get replies to them:

import aspose.slides as slides
import aspose.pydrawing as draw
import datetime

with slides.Presentation() as pres:
    # Adds a comment
    author1 = pres.comment_authors.add_author("Author_1", "A.A.")
    comment1 = author1.comments.add_comment("comment1", pres.slides[0], draw.PointF(10, 10), datetime.date.today())

    # Adds a reply to comment1
    author2 = pres.comment_authors.add_author("Autror_2", "B.B.")
    reply1 = author2.comments.add_comment("reply 1 for comment 1", pres.slides[0], draw.PointF(10, 10), datetime.date.today())
    reply1.parent_comment = comment1

    # Adds another reply to comment1
    reply2 = author2.comments.add_comment("reply 2 for comment 1", pres.slides[0], draw.PointF(10, 10), datetime.date.today())
    reply2.parent_comment = comment1

    # Adds a reply to existing reply
    subReply = author1.comments.add_comment("subreply 3 for reply 2", pres.slides[0], draw.PointF(10, 10), datetime.date.today())
    subReply.parent_comment = reply2

    comment2 = author2.comments.add_comment("comment 2", pres.slides[0], draw.PointF(10, 10), datetime.date.today())
    comment3 = author2.comments.add_comment("comment 3", pres.slides[0], draw.PointF(10, 10), datetime.date.today())

    reply3 = author1.comments.add_comment("reply 4 for comment 3", pres.slides[0], draw.PointF(10, 10), datetime.date.today())
    reply3.parent_comment = comment3

    # Displays the comments hierarchy on console
    slide = pres.slides[0]
    comments = slide.get_slide_comments(None)
    for i in range(comments.length):
        comment = comments[i]
        while comment.parent_comment is not None:
            print("\t")
            comment = comment.parent_comment

        print(comments[i].author.name + " : " + comments[i].text)
        print("\r\n")

    pres.save("parent_comment.pptx", slides.export.SaveFormat.PPTX)

    # Removes comment1 and all replies to it
    comment1.remove()

    pres.save("remove_comment.pptx", slides.export.SaveFormat.PPTX)

Attention

When the remove method (from the Comment class) is used to delete a comment, the replies to the comment also get deleted.
If the parent_comment setting results in a circular reference, PptxEditException will be thrown.

Add Modern Comment

In 2021, Microsoft introduced modern comments in PowerPoint. The modern comments feature significantly improves collaboration in PowerPoint. Through modern comments, PowerPoint users get to resolve comments, anchor comments to objects and texts, and engage in interactions a lot more easily than before.

We implemented support for modern comments by adding the ModernComment class. The add_modern_comment and insert_modern_comment methods were added to the CommentCollection class.

This Python code shows you how to add a modern comment to a slide in a PowerPoint presentation:

import aspose.pydrawing as draw
import aspose.slides as slides
from datetime import date

with slides.Presentation() as pres:
    newAuthor = pres.comment_authors.add_author("Some Author", "SA")
    modernComment = newAuthor.comments.add_modern_comment("This is a modern comment", pres.slides[0], None, draw.PointF(100, 100), date.today())

    pres.save("example.pptx", slides.export.SaveFormat.PPTX)

Remove Comment

Delete All Comments and Authors

This Python code shows you how to remove all comments and authors in a presentation:

import aspose.slides as slides

with slides.Presentation("example.pptx") as presentation:
    # Deletes all comments from the presentation
    for author in presentation.comment_authors:
        author.comments.clear()

    # Deletes all authors
    presentation.comment_authors.clear()

    presentation.save("example_out.pptx", slides.export.SaveFormat.PPTX)

Delete Specific Comments

This Python code shows you how to delete specific comments on a slide:

import aspose.pydrawing as draw
import aspose.slides as slides
from datetime import date

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    
    # add comments...
    author = presentation.comment_authors.add_author("Author", "A")
    author.comments.add_comment("comment 1", slide, draw.PointF(0.2, 0.2), date.today())
    author.comments.add_comment("comment 2", slide, draw.PointF(0.3, 0.2), date.today())
    
    # remove all comments that contain "comment 1" text
    for commentAuthor in presentation.comment_authors:
        toRemove = []
        for comment in slide.get_slide_comments(commentAuthor):
            if comment.text == "comment 1":
                toRemove.append(comment)
        
        for comment in toRemove:
            commentAuthor.comments.remove(comment)
    
    presentation.save("pres.pptx", slides.export.SaveFormat.PPTX)

FAQ

Does Aspose.Slides support a status like ‘resolved’ for modern comments?

Yes. Modern comments expose a status property; you can read and set a comment’s state (for example, mark it as resolved), and this state is saved in the file and recognized by PowerPoint.

Are threaded discussions (reply chains) supported, and is there a nesting limit?

Yes. Each comment can reference its parent comment, enabling arbitrary reply chains. The API does not declare a specific nesting depth limit.

In what coordinate system is a comment marker’s position defined on a slide?

The position is stored as a floating-point point in the slide’s coordinate system. This lets you place the comment marker precisely where you need it.

Python-Net: Manage Presentation Notes in Python

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Slides supports removing notes slides from a presentation. In this topic, we will introduce this new feature of removing Notes also adding notes style slides from any presentation. Aspose.Slides for Python via .NET provides the feature of removing notes of any slide as well as add style to existing notes. Developers can remove notes in the following ways:

Remove Notes of a Specific Slide of a presentation.
Remove Notes of All Slides of a Presentation.

Remove Notes from Slide

Notes of some specific slide could be removed as shown in the example below:

import aspose.slides as slides

# Instantiate a Presentation object that represents a presentation file 
with slides.Presentation(path + "AccessSlides.pptx") as presentation:
    # Removing notes of first slide
    mgr = presentation.slides[0].notes_slide_manager
    mgr.remove_notes_slide()

    # save presentation to disk
    presentation.save("RemoveNotesAtSpecificSlide_out.pptx", slides.export.SaveFormat.PPTX)

Remove Notes from All Slides

Notes of all the slides of a presentation could be removed as shown in the example below:

import aspose.slides as slides

# Instantiate a Presentation object that represents a presentation file 
with slides.Presentation(path + "AccessSlides.pptx") as presentation:
    # Removing notes of all slides
    for i in range(len(presentation.slides)):
        mgr = presentation.slides[i].notes_slide_manager
        mgr.remove_notes_slide()
    # save presentation to disk
    presentation.save("RemoveNotesFromAllSlides_out.pptx", slides.export.SaveFormat.PPTX)

Add NotesStyle

The notes_style property has been added to the MasterNotesSlide class. This property specifies the style of a notes text. The implementation is demonstrated in the example below.

import aspose.slides as slides

# Instantiate Presentation class that represents the presentation file
with slides.Presentation(path + "AccessSlides.pptx") as presentation:
    notesMaster = presentation.master_notes_slide_manager.master_notes_slide
    if notesMaster != None:
        # Get MasterNotesSlide text style
        notesStyle = notesMaster.notes_style

        #Set symbol bullet for the first level paragraphs
        paragraphFormat = notesStyle.get_level(0)
        paragraphFormat.bullet.type = slides.BulletType.SYMBOL

    # save the PPTX file to the Disk
    presentation.save("AddNotesSlideWithNotesStyle_out.pptx", slides.export.SaveFormat.PPTX)

FAQ

Which API entity provides access to the notes of a specific slide?

Notes are accessed through the slide’s notes manager: the slide has a NotesSlideManager and a property that returns the notes object, or None if there are no notes.

Are there differences in notes support across the PowerPoint versions the library works with?

The library targets a broad range of Microsoft PowerPoint formats (97–newer) and ODP; notes are supported within these formats without depending on an installed copy of PowerPoint.

Python-Net: Enhance PowerPoint Presentations with Animations in Python

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Presentations are designed to convey information, so their visual appearance and interactive behavior are key considerations during creation.

PowerPoint animation plays an important role in making a presentation eye-catching and engaging for viewers. Aspose.Slides for Python via .NET provides a wide range of options to add animation to a PowerPoint presentation. You can:

Apply various animation effects to shapes, charts, tables, OLE objects, and other elements.
Use multiple animation effects on a single shape.
Control effects through the animation timeline.
Create custom animations.

In Aspose.Slides for Python via .NET, animation effects can be applied to shapes. Because every element on a slide—including text, pictures, OLE objects, and tables—is treated as a shape, you can apply animation effects to any element on the slide.

The aspose.slides.animation namespace provides the classes for working with PowerPoint animations.

Animation Effects

Aspose.Slides supports 150+ animation effects, including basic effects such as Bounce, PathFootball, and Zoom, as well as specialized effects like OLEObjectShow and OLEObjectOpen. You can find the full list in the EffectType enumeration.

Additionally, these animation effects can be combined with the following effects:

Custom Animation

You can create your own custom animations in Aspose.Slides by combining multiple behaviors into a single effect.

Behavior is the basic building block of any PowerPoint animation effect. Every animation effect is essentially a set of behaviors arranged into one strategy or timeline. You can assemble behaviors into a custom animation once and reuse it across other presentations. If you add a new behavior to a standard PowerPoint animation effect, it becomes a custom animation—for example, adding a repeat behavior to make the animation play several times.

Animation Point marks the moment or position at which a behavior is applied (a keyframe).

Animation Time Line

Sequence is a collection of animation effects applied to a specific shape.

Timeline is the set of sequences used on a specific slide. It was introduced in PowerPoint 2002. In earlier versions of PowerPoint, adding animation effects was difficult and often required workarounds. Timeline replaces the old AnimationSettings class and provides a clearer object model for PowerPoint animation. Each slide can have only one animation timeline.

Interactive Animation

Trigger allows you to define user actions (e.g., a button click) that start a specific animation. Triggers were added only in the latest versions of PowerPoint.

Shape Animation

Aspose.Slides lets you apply animations to shapes—such as text, rectangles, lines, frames, OLE objects, and more.

Animated Charts

To create animated charts, use the same classes as you do for shapes. However, PowerPoint animations can be applied only to chart categories or chart series. You can also apply an animation effect to an individual category element or series element.

Animated text

In addition to animating text, you can apply animation to a paragraph.

FAQ

Will animations be preserved when exporting to PDF?

No. PDF is a static format, so animations and slide transitions don’t play. If you need motion, export to HTML5, animated GIF, or video instead.

Can I turn an animated presentation into a video and control the frame rate and frame size?

Yes. You can render the presentation as frames and encode them into a video (e.g., via ffmpeg), choosing the FPS and resolution. Animations and slide transitions are played during rendering.

Will animations remain intact when working with ODP (not just PPTX)?

PPT, PPTX, and ODP are supported for reading and writing, but format differences mean certain effects may look or behave slightly differently. Validate critical cases with real samples.

Python-Net: Create 3D Presentations in Python

Mon, 01 Jan 0001 00:00:00 +0000

Overview

How do you usually create a 3D PowerPoint presentation? Microsoft PowerPoint lets you add 3D models, apply 3D effects to shapes, create 3D text, insert 3D graphics, and build 3D animations.

Creating 3D effects has a big impact and is often the easiest way to turn a standard deck into a 3D presentation. Since Aspose.Slides 20.9, a new cross-platform 3D engine has been added. This engine enables exporting and rasterizing shapes and text with 3D effects. In earlier versions, shapes with 3D effects were rendered flat; now they can be rendered with full-fledged 3D. You can also create shapes with 3D effects through the Aspose.Slides API.

In the Aspose.Slides API, to make a shape a PowerPoint 3D shape, use the Shape.three_d_format property, which exposes the members of the ThreeDFormat class:

bevel_bottom and bevel_top: set bevels, choose a bevel type (e.g., Angle, Circle, SoftRound), and define bevel height and width.
camera: simulate camera movement around the object; by adjusting camera rotation, zoom, and other properties, you can manipulate shapes like 3D models in PowerPoint.
contour_color and contour_width: set contour properties to make a shape look like a 3D PowerPoint object.
depth, extrusion_color, and extrusion_height: make a shape three-dimensional by setting its depth or extruding it.
light_rig: create lighting effects on a 3D shape; similar to the camera, you can set the light’s rotation relative to the 3D shape and choose a light type.
material: select a material to make the 3D shape more lifelike. Predefined materials include Metal, Plastic, Powder, Matte, and more.

All 3D features can be applied to both shapes and text. The sections below show how to access these properties and then examine them step by step.

import aspose.pydrawing as drawing
import aspose.slides as slides

image_scale = 2

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 150, 200, 200)
    shape.text_frame.text = "3D"
    shape.text_frame.paragraphs[0].paragraph_format.default_portion_format.font_height = 64

    shape.three_d_format.camera.camera_type = slides.CameraPresetType.ORTHOGRAPHIC_FRONT
    shape.three_d_format.camera.set_rotation(20, 30, 40)
    shape.three_d_format.light_rig.light_type = slides.LightRigPresetType.FLAT
    shape.three_d_format.light_rig.direction = slides.LightingDirection.TOP
    shape.three_d_format.material = slides.MaterialPresetType.FLAT
    shape.three_d_format.extrusion_height = 100
    shape.three_d_format.extrusion_color.color = drawing.Color.blue

    with slide.get_image(image_scale, image_scale) as thumbnail:
        thumbnail.save("sample_3d.png")

    presentation.save("sandbox_3d.pptx", slides.export.SaveFormat.PPTX)

The rendered thumbnail looks like that:

3D Rotation

You can rotate PowerPoint 3D shapes in three-dimensional space to add interactivity. To rotate a 3D shape in PowerPoint, use the following menu:

In the Aspose.Slides API, you control a shape’s 3D rotation through the camera property.

shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 150, 200, 200)
shape.three_d_format.camera.set_rotation(20, 30, 40)
# ... set other 3D scene parameters

with slide.get_image(image_scale, image_scale) as thumbnail:
    thumbnail.save("sample_3d.png")

3D Depth and Extrusion

To add a third dimension to your shape and make it truly 3D, use the ThreeDFormat.extrusion_height and ThreeDFormat.extrusion_color properties:

shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 150, 200, 200)
shape.three_d_format.camera.set_rotation(20, 30, 40)
shape.three_d_format.extrusion_height = 100
shape.three_d_format.extrusion_color.color = drawing.Color.purple
# ... set other 3D scene parameters

with slide.get_image(image_scale, image_scale) as thumbnail:
    thumbnail.save("sample_3d.png")

In PowerPoint, you typically use the Depth menu to set a 3D shape’s depth:

3D Gradient

A gradient can be used to fill a PowerPoint 3D shape. Let’s create a shape with a gradient fill and apply a 3D effect to it:

import aspose.pydrawing as drawing
import aspose.slides as slides

image_scale = 2

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 150, 250, 250)
    shape.text_frame.text = "3D Gradient"
    shape.text_frame.paragraphs[0].paragraph_format.default_portion_format.font_height = 64

    shape.fill_format.fill_type = slides.FillType.GRADIENT
    shape.fill_format.gradient_format.gradient_stops.add(0, drawing.Color.blue)
    shape.fill_format.gradient_format.gradient_stops.add(100, drawing.Color.orange)
   
    shape.three_d_format.camera.camera_type = slides.CameraPresetType.ORTHOGRAPHIC_FRONT
    shape.three_d_format.camera.set_rotation(10, 20, 30)
    shape.three_d_format.light_rig.light_type = slides.LightRigPresetType.FLAT
    shape.three_d_format.light_rig.direction = slides.LightingDirection.TOP
    shape.three_d_format.extrusion_height = 150
    shape.three_d_format.extrusion_color.color = drawing.Color.dark_orange
   
    with slide.get_image(image_scale, image_scale) as thumbnail:
        thumbnail.save("sample_3d.png")

And here is the result:

In addition to gradient fills, you can fill shapes with an image:

with open("image.png", "rb") as image_file:
    image_data = image_file.read()

    shape.fill_format.fill_type = slides.FillType.PICTURE
    shape.fill_format.picture_fill_format.picture.image = presentation.images.add_image(image_data)
    shape.fill_format.picture_fill_format.picture_fill_mode = slides.PictureFillMode.STRETCH
    # ... setup 3D: shape.three_d_format.camera, shape.three_d_format.light_rig, shape.three_d_format.Extrusion* properties

    with slide.get_image(image_scale, image_scale) as thumbnail:
        thumbnail.save("sample_3d.png")

That’s how it looks like:

3D Text (WordArt)

Aspose.Slides allows you to apply 3D effects to text as well. To create 3D text, you can use the WordArt transform effect:

import aspose.pydrawing as drawing
import aspose.slides as slides

image_scale = 2

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 150, 250, 250)
    shape.fill_format.fill_type = slides.FillType.NO_FILL
    shape.fill_format.fill_type = slides.FillType.NO_FILL
    shape.line_format.fill_format.fill_type = slides.FillType.NO_FILL
    shape.text_frame.text = "3D text"
   
    portion = shape.text_frame.paragraphs[0].portions[0]
    portion.portion_format.fill_format.fill_type = slides.FillType.PATTERN
    portion.portion_format.fill_format.pattern_format.fore_color.color = drawing.Color.dark_orange
    portion.portion_format.fill_format.pattern_format.back_color.color = drawing.Color.white
    portion.portion_format.fill_format.pattern_format.pattern_style = slides.PatternStyle.LARGE_GRID
   
    shape.text_frame.paragraphs[0].paragraph_format.default_portion_format.font_height = 128
   
    text_frame_format = shape.text_frame.text_frame_format
    # setup "Arch Up" WordArt transform effect
    text_frame_format.transform = slides.TextShapeType.ARCH_UP

    text_frame_format.three_d_format.extrusion_height = 3.5
    text_frame_format.three_d_format.depth = 3
    text_frame_format.three_d_format.material = slides.MaterialPresetType.PLASTIC
    text_frame_format.three_d_format.light_rig.direction = slides.LightingDirection.TOP
    text_frame_format.three_d_format.light_rig.light_type = slides.LightRigPresetType.BALANCED
    text_frame_format.three_d_format.light_rig.set_rotation(0, 0, 40)
    text_frame_format.three_d_format.camera.camera_type = slides.CameraPresetType.PERSPECTIVE_CONTRASTING_RIGHT_FACING
   
    with slide.get_image(image_scale, image_scale) as thumbnail:
        thumbnail.save("text3d.png")

    presentation.save("text3d.pptx", slides.export.SaveFormat.PPTX)

Here is the result:

FAQ

Will 3D effects be preserved when exporting a presentation to images/PDF/HTML?

Yes. The Slides 3D engine renders 3D effects when exporting to supported formats (images, PDF, HTML, etc.).

Can I retrieve the “effective” (final) 3D parameter values that account for themes, inheritance, etc.?

Yes. Slides provides APIs to read effective values (including for 3D—lighting, bevels, etc.) so you can see the final applied settings.

Do 3D effects work when converting a presentation to video?

Yes. When generating frames for the video, 3D effects are rendered just as they are for exported images.

Python-Net: Manage VBA Projects in Presentations with Python

Mon, 01 Jan 0001 00:00:00 +0000

Overview

This article examines the key capabilities of Aspose.Slides for Python via .NET for working with macros in PowerPoint presentations. The library provides convenient tools for adding, removing, and extracting macros, which enables you to automate the creation and modification of presentations.

With Aspose.Slides, you can:

Accelerate presentation development—the automation of routine tasks reduces the time needed to prepare materials.
Ensure flexibility—the ability to manage macros allows you to tailor presentations to specific tasks and scenarios.
Integrate data—simple integration with external data sources helps keep slide content up to date.
Simplify maintenance—centralized macro management makes it easier to apply changes and update presentations.

The article goes on to present practical examples of how to use Aspose.Slides to work effectively with macros in PowerPoint.

The aspose.slides.vba namespace provides classes for working with macros and VBA code.

Note

When you convert a presentation that contains macros to another format (PDF, HTML, etc.), Aspose.Slides ignores the macros—they are not transferred to the output file.

When you add macros to a presentation or resave a presentation that contains macros, Aspose.Slides writes the macro bytes as-is.

Aspose.Slides never executes macros in a presentation.

Add VBA Macros

Aspose.Slides provides the VbaProject class to create VBA projects (and project references) and to edit existing modules.

Create an instance of the Presentation class.
Use the VbaProject constructor to add a new VBA project.
Add a module to the VBA project.
Set the module’s source code.
Add a reference to <stdole>.
Add a reference to Microsoft Office.
Associate the references with the VBA project.
Save the presentation.

The following Python code shows how to add a VBA macro from scratch to a presentation:

import aspose.slides as slides

# Create an instance of the Presentation class.
with slides.Presentation() as presentation:

    # Create a new VBA project.
    presentation.vba_project = slides.vba.VbaProject()

    # Add an empty module to the VBA project.
    module = presentation.vba_project.modules.add_empty_module("Module")

    # Set the module source code.
    module.source_code = """
        Sub Test(oShape As Shape)
            MsgBox "Hello, world!"
        End Sub
    """

    # Create a reference to <stdole>.
    stdole_reference = slides.vba.VbaReferenceOleTypeLib("stdole",
        "*\\G{00020430-0000-0000-C000-000000000046}#2.0#0#C:\\Windows\\system32\\stdole2.tlb#OLE Automation")

    # Create a reference to Microsoft Office.
    office_reference = slides.vba.VbaReferenceOleTypeLib("Office",
        "*\\G{2DF8D04C-5BFA-101B-BDE5-00AA0044DE52}#2.0#0#C:\\Program Files\\Common Files\\Microsoft Shared\\OFFICE14\\MSO.DLL#Microsoft Office 14.0 Object Library")

    # Add the references to the VBA project.
    presentation.vba_project.references.add(stdole_reference)
    presentation.vba_project.references.add(office_reference)

    # Save the presentation.
    presentation.save("macros.pptm", slides.export.SaveFormat.PPTM)

You may want to try the Aspose Macro Remover, a free web app for removing macros from PowerPoint, Excel, and Word documents.

Remove VBA Macros

Using the vba_project property of the Presentation class, you can remove a VBA macro.

Create an instance of the Presentation class and load the presentation that contains the macro.
Access the macro module and remove it.
Save the modified presentation.

The following Python code shows how to remove a VBA macro:

import aspose.slides as slides

# Load the presentation that contains the macro.
with slides.Presentation("VBA.pptm") as presentation:
    
    # Access the VBA module.
    vba_module = presentation.vba_project.modules[0]

    # Remove the VBA module.
    presentation.vba_project.modules.remove(vba_module)

    # Save the presentation.
    presentation.save("removed_macro.pptm", slides.export.SaveFormat.PPTM)

Extract VBA Macros

Using the modules property in the VbaProject class, you can access all modules of a VBA project. The VbaModule class can be used to extract module properties such as the name and the code.

Create an instance of the Presentation class and load the presentation that contains the macro.
Check whether the presentation contains a VBA project.
Loop through all modules in the VBA project to view the macros.

The following Python code shows how to extract VBA macros from a presentation:

import aspose.slides as slides

with slides.Presentation("VBA.pptm") as presentation:
    # Check whether the presentation contains a VBA project.
    if presentation.vba_project is not None:
        for module in presentation.vba_project.modules:
            print(module.name)
            print(module.source_code)

Check Whether a VBA Project Is Password-Protected

Using the VbaProject.is_password_protected property, you can determine whether a project’s properties are password-protected.

Create an instance of the Presentation class and load a presentation that contains a macro.
Check whether the presentation contains a VBA project.
Check whether the VBA project is password-protected to view its properties.

import aspose.slides as slides

with slides.Presentation("VBA.pptm") as presentation:
    # Check whether the presentation contains a VBA project.
    if presentation.vba_project is not None:
        if presentation.vba_project.is_password_protected:
            print(f"The VBA Project '{presentation.vba_project.name}' is protected by password to view project properties.")

FAQ

What happens to macros if I save the presentation as PPTX?

Macros will be removed because PPTX does not support VBA. To keep macros, choose PPTM, PPSM, or POTM.

Can Aspose.Slides run macros inside a presentation to, for example, refresh data?

No. The library never executes VBA code; execution is only possible inside PowerPoint with the appropriate security settings.

Is working with ActiveX controls linked to VBA code supported?

Yes, you can access existing ActiveX controls, modify their properties, and remove them. This is useful when macros interact with ActiveX.

Python-Net: Technical Articles

Mon, 01 Jan 0001 00:00:00 +0000

Python-Net: Enhance Image Processing with the Modern API

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

The Aspose.Slides for Python public API currently depends on the following aspose.pydrawing types:

aspose.pydrawing.Graphics
aspose.pydrawing.Image
aspose.pydrawing.Bitmap
aspose.pydrawing.printing.PrinterSettings

As of version 24.4, this public API is deprecated due to changes in the Aspose.Slides for Python public API.

To eliminate aspose.pydrawing from the public API, we introduced the Modern API. Methods that use aspose.pydrawing.Image and aspose.pydrawing.Bitmap are deprecated and will be replaced by their Modern API equivalents. Methods that use aspose.pydrawing.Graphics are deprecated, and support for them will be removed from the public API.

Removal of the deprecated API that depends on aspose.pydrawing is planned for release 24.8.

Modern API

The following classes and enums have been added to the public API:

aspose.slides.IImage — represents a raster or vector image.
aspose.slides.ImageFormat — represents an image file format.
aspose.slides.Images — provides methods to create and work with IImage.

A typical usage scenario for the new API looks like this:

import aspose.slides as slides
import aspose.pydrawing as drawing

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    with slides.Images.from_file("image.png") as image:
        pp_image = presentation.images.add_image(image)

    slide.shapes.add_picture_frame(slides.ShapeType.RECTANGLE, 10, 10, 100, 100, pp_image)

    with slide.get_image(drawing.Size(1920, 1080)) as slide_image:
        slide_image.save("slide1.jpeg", slides.ImageFormat.JPEG)

Replace Old Code with the Modern API

For an easier transition, the new IImage class mirrors the separate APIs of the Image and Bitmap classes. In most cases, you only need to replace calls to methods that use aspose.pydrawing with their Modern API equivalents.

Get a Slide Thumbnail

Deprecated API:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]

    slide.get_thumbnail().save("slide1.png")

Modern API:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    slide = presentation.slides[0]

    with slide.get_image() as image:
        image.save("slide1.png")

Get a Shape Thumbnail

Deprecated API:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    shape = presentation.slides[0].shapes[0]
    
    shape.get_thumbnail().save("shape.png")

Modern API:

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    shape = presentation.slides[0].shapes[0]

    with shape.get_image() as image:
        image.save("shape.png")

Get a Presentation Thumbnail

Deprecated API:

import aspose.slides as slides
import aspose.pydrawing as drawing

with slides.Presentation("sample.pptx") as presentation:
    thumbnails = presentation.get_thumbnails(slides.export.RenderingOptions(), drawing.Size(1980, 1028))

    for index, thumbnail in enumerate(thumbnails):
        thumbnail.save(f"slide_{index}.png", drawing.imaging.ImageFormat.png)

Modern API:

import aspose.slides as slides
import aspose.pydrawing as drawing

with slides.Presentation("sample.pptx") as presentation:
    thumbnails = presentation.get_images(slides.export.RenderingOptions(), drawing.Size(1980, 1028))

    for index, thumbnail in enumerate(thumbnails):
        thumbnail.save(f"slide_{index}.png", slides.ImageFormat.PNG)

Add a Picture to a Presentation

Deprecated API:

import aspose.slides as slides
import aspose.pydrawing as drawing

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    image = drawing.Image.from_file("image.png")
    pp_image = presentation.images.add_image(image)
    slide.shapes.add_picture_frame(slides.ShapeType.RECTANGLE, 10, 10, 100, 100, pp_image)

Modern API:

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    with slides.Images.from_file("image.png") as image:
        pp_image = presentation.images.add_image(image)

    slide.shapes.add_picture_frame(slides.ShapeType.RECTANGLE, 10, 10, 100, 100, pp_image)

Methods and Properties to Be Removed and Their Modern Replacements

Presentation Class

Method Signature	Replacement Method Signature
get_thumbnails(options)	get_images(options)
get_thumbnails(options, slides)	get_images(options, slides)
get_thumbnails(options, scale_x, scale_y)	get_images(options, scale_x, scale_y)
get_thumbnails(options, slides, scale_x, scale_y)	get_images(options, slides, scale_x, scale_y)
get_thumbnails(options, image_size)	get_images(options, image_size)
get_thumbnails(options, slides, image_size)	get_images(options, slides, image_size)
save(fname, format, response, show_inline)	Will be deleted completely
save(fname, format, options, response, show_inline)	Will be deleted completely
print()	Will be deleted completely
print(printer_settings)	Will be deleted completely
print(printer_name)	Will be deleted completely
print(printer_settings, pres_name)	Will be deleted completely

Slide Class

Method Signature	Replacement Method Signature
get_thumbnail()	get_image()
get_thumbnail(scale_x, scale_y)	get_image(scale_x, scale_y)
get_thumbnail(image_size)	get_image(image_size)
get_thumbnail(options)	get_image(options: ITiffOotions)
get_thumbnail(options)	get_image(options: IRenderingOptions)
get_thumbnail(options, scale_x, scale_y)	get_image(options, scale_x, scale_y)
get_thumbnail(options, image_size)	get_image(options, image_size)
render_to_graphics(options, graphics)	Will be deleted completely
render_to_graphics(options, graphics, scale_x, scale_y)	Will be deleted completely
render_to_graphics(options, graphics, rendering_size)	Will be deleted completely

Shape Class

Method Signature	Replacement Method Signature
get_thumbnail()	get_image()
get_thumbnail(bounds, scale_x, scale_y)	get_image(bounds, scale_x, scale_y)

ImageCollection Class

Method Signature	Replacement Method Signature
add_image(image: aspose.pydrawing.Image)	add_image(image)

PPImage Class

Method/Property Signature	Replacement Method/Property Signature
replace_image(new_image: aspose.pydrawing.Image)	replace_image(new_image)
system_image	image

ImageWrapperFactory Class

Method Signature	Replacement Method Signature
create_image_wrapper(image: aspose.pydrawing.Image)	create_image_wrapper(image)

PatternFormat Class

Method Signature	Replacement Method Signature
get_tile_image(background, foreground)	get_tile(background, foreground)
get_tile_image(style_color)	get_tile(style_color)

IPatternFormatEffectiveData Class

Method Signature	Replacement Method Signature
get_tile_image(background, foreground)	get_tile_i_image(background, foreground)

Output Class

Method Signature	Replacement Method Signature
add(path, image: aspose.pydrawing.Image)	add(path, image)

API Support for aspose.pydrawing.Graphics Will Be Discontinued

Methods that use aspose.pydrawing.Graphics are deprecated; support for them will be removed from the public API.

The API members that rely on aspose.pydrawing.Graphics and will be removed include:

aspose.pydrawing.Slide.render_to_graphics(options, graphics)
aspose.pydrawing.Slide.render_to_graphics(options, graphics, scale_x, scale_y)
aspose.pydrawing.Slide.render_to_graphics(options, graphics, rendering_size)

FAQ

Why was aspose.pydrawing.Graphics dropped?

Support for Graphics is being removed from the public API to unify work with rendering and images, eliminate ties to platform-specific dependencies, and switch to a cross-platform approach with IImage. All rendering methods to Graphics will be removed.

What is the practical benefit of IImage compared to Image/Bitmap?

IImage unifies working with both raster and vector images, simplifies saving to various formats via ImageFormat, reduces dependence on pydrawing, and makes code more portable across environments.

Will the Modern API affect the performance of generating thumbnails?

Switching from get_thumbnail to get_image does not worsen scenarios: the new methods provide the same capabilities for producing images with options and sizes, while retaining support for rendering options. The specific gain or drop depends on the scenario, but functionally the replacements are equivalent.

Python-Net: Known Issues

Mon, 01 Jan 0001 00:00:00 +0000

Python-Net: FAQ

Mon, 01 Jan 0001 00:00:00 +0000

Supported File Formats

Q: What file formats does Aspose.Slides for Python via .NET support?

A: Aspose.Slides for Python via .NET supports the file formats described in Supported File Formats.

Exceptions

Q: I am getting an out of memory exception while loading a large PPT file with images. Is there a limitation in Aspose.Slides regarding file size?

A: There is no specific formula for calculating the presentation size supported by Aspose.Slides. There should be enough space to accommodate the whole presentation structure and images in memory. Normally, images in the memory occupy more space than the hard disk, especially when images have additional effects.

In general, Aspose.Slides for Python via .NET can easily handle presentation files of around 300 MB on a server with 4 GB RAM.

Working with Slides

Q: Can I change the size of the slides in a presentation?

A: You can use the slide_size property exposed by the Presentation class to define the size of the slides in a presentation.

Q: Is there a way to define slides of different size in a presentation?

A: Since the size of slides is defined at presentation level in Microsoft PowerPoint documents, there is no way to do this.

Q: Does Aspose.Slides for Python via .NET support previewing a slide before saving?

A: You can render the presentation slides to images and can use these images for previewing the slides.

Working with Text

Q: Is it possible to retrieve all the text from a presentation?

A: Aspose.Slides for Python via .NET provides the SlideUtil class under the aspose.slides.util namespace that provides various methods for retrieving whole text from the presentations.

Q: Why are paragraph sizes different on Windows and Linux operating systems?

A: The calculation of paragraph sizes is based on the calculation of the text size representing the given paragraph. The text size calculation is based on the metrics of the font specified in the PowerPoint presentation. If the specified font is missing, it is replaced with the most similar font, but this font has metrics different from the original ones. As a result, the calculation of paragraph sizes in different systems will lead to different results depending on the set of installed fonts. To achieve the same result on different operating systems, you need to install the same fonts on the systems or load them at runtime as external fonts.

Formatting and Images

Q: How can I set the color of a table border?

A: You can change the color of all table borders or just the border around the entire table. For changing all borders, please use the cell_format property from the Cell class. For the border of the entire table, you should iterate cells and change the color of the outer borders.

Q: What measure does Aspose.Slides for Python via .NET use to place pictures?

A: The coordinates and sizes of all shapes on the slides are measured in points (72 dpi).

Working with Fonts

Q: When converting PPT to PDF or images, why are the fonts different in the output documents?

A: This issue might indicate that the fonts used in the presentation are missing from the operating system on which the code was executed. You should install the fonts on the operating system or load them as external fonts using the FontsLoader class as shown below:

folders = [ "path_to_a_folder_with_fonts" ]
aspose.slides.FontsLoader.load_external_fonts(folders)