Beheer presentatie-eigenschappen in Python

Waar deze pagina over gaat

Beheers presentatie-eigenschappen in Aspose.Slides voor Python via Java en stroomlijn zoeken, branding en workflow in uw PowerPoint- en OpenDocument-bestanden.

Inleiding

Aspose.Slides ondersteunt twee soorten documenteigenschappen: Ingebouwd en Aangepast. Beide eigendomstypen zijn eenvoudig toegankelijk en beheersbaar via de Aspose.Slides‑API.

Aspose.Slides stelt u in staat om te werken met presentatie‑documenteigenschappen via de DocumentProperties‑klasse. Een instantie van deze klasse wordt geretourneerd door Presentation.getDocumentProperties. De volgende voorbeelden laten zien hoe u deze eigenschappen kunt lezen, wijzigen en beheren.

Note

Houd er rekening mee dat de velden Application en AppVersion niet gewijzigd kunnen worden. Aspose.Slides herschrijft ze bij elke opslaan, zodat een opgeslagen presentatie altijd “Aspose.Slides for Java” en de versie van de gebruikte bibliotheek rapporteert. Elke waarde die aan DocumentProperties.setNameOfApplication wordt doorgegeven, wordt genegeerd wanneer de presentatie wordt weggeschreven.

Documenteigenschappen in PowerPoint

Microsoft PowerPoint 2007 laat u de documenteigenschappen van presentaties beheren. Klik op het Office‑pictogram en selecteer Voorbereiden | Eigenschappen | Geavanceerde eigenschappen, zoals hieronder weergegeven:

Geavanceerde eigenschappen selecteren

Nadat u Geavanceerde eigenschappen hebt geselecteerd, verschijnt een dialoogvenster waarin u de documenteigenschappen van het PowerPoint‑bestand kunt beheren:

Eigenschappen‑dialoog

De Eigenschappen‑dialoog bevat tabbladen zoals Algemeen, Samenvatting, Statistieken, Inhoud en Aangepast. Deze tabbladen laten u verschillende soorten informatie over PowerPoint‑bestanden configureren. Gebruik het tabblad Aangepast om aangepaste eigenschappen te beheren.

Werken met documenteigenschappen via Aspose.Slides voor Python via Java

Zoals eerder beschreven, ondersteunt Aspose.Slides voor Python via Java zowel Ingebouwde als Aangepaste documenteigenschappen. De DocumentProperties‑klasse vertegenwoordigt de documenteigenschappen die aan een presentatiebestand gekoppeld zijn.

Gebruik Presentation.getDocumentProperties om deze eigenschappen te benaderen zoals hieronder beschreven.

Openbare eigenschappen lezen uit een versleutelde presentatie

Een openingswachtwoord beschermt normaal zowel de inhoud van de presentatie als de documenteigenschappen. Wanneer een presentatie wordt versleuteld door false door te geven aan ProtectionManager.setEncryptDocumentProperties, blijven de documenteigenschappen openbaar. Een toepassing kan vervolgens true doorgeven aan LoadOptions.setOnlyLoadDocumentProperties en de openbare metadata lezen zonder het openingswachtwoord.

De “alleen‑documenteigenschappen‑laden”‑optie bepaalt wat Aspose.Slides laadt; het ontsleutelt niets. Als de eigenschappen wel bij de versleuteling zijn inbegrepen, mislukt het laden zonder wachtwoord. Als de presentatie niet versleuteld is, wordt de optie genegeerd en wordt de volledige presentatie geladen.

Het volgende voorbeeld controleert de laadmodus via ProtectionManager.isOnlyDocumentPropertiesLoaded en leest vervolgens ingebouwde eigenschappen via Presentation.getDocumentProperties:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, LoadOptions

load_options = LoadOptions()
load_options.setOnlyLoadDocumentProperties(True)

presentation = Presentation("public-properties-encrypted.pptx", load_options)
try:
    if presentation.getProtectionManager().isOnlyDocumentPropertiesLoaded():
        properties = presentation.getDocumentProperties()

        print("Author: ", properties.getAuthor())
        print("Title: ", properties.getTitle())
        print("Keywords: ", properties.getKeywords())
    else:
        print("The presentation was not loaded in document-properties-only mode.")

finally:
    presentation.dispose()

In deze modus wordt de slide‑inhoud niet geladen. Slides, masters, layouts, shapes, media en andere presentatie‑objecten zijn niet beschikbaar. Toepassingen moeten altijd ProtectionManager.isOnlyDocumentPropertiesLoaded controleren voordat ze een bewerking uitvoeren die het volledige presentatie‑objectmodel vereist.

Warning

Openbare metadata kunnen namen van auteurs, titels, onderwerpen, trefwoorden, bedrijfsinformatie, opmerkingen en aangepaste waarden onthullen. Versleutel gevoelige eigenschappen samen met de presentatie. Laat ze alleen openbaar wanneer indexering, classificatie, zoeken of document‑beheersystemen een specifieke eis hebben om zonder wachtwoord toegang te krijgen.

Eigenschappen bijwerken van een versleutelde presentatie

Voor een versleuteld PPTX‑bestand is een presentatie die in “alleen‑documenteigenschappen”‑modus is geladen bedoeld om openbare metadata te lezen. Aspose.Slides kan gewijzigde eigenschappen van dat alleen‑metadata‑object niet opslaan, omdat de openbare eigenschappen consistent moeten blijven met de corresponderende gegevens in de versleutelde presentatie. Bijwerken vereist daarom het juiste openingswachtwoord en een volledige load.

Het volgende voorbeeld opent de presentatie met LoadOptions.setPassword, werkt openbare ingebouwde eigenschappen bij en slaat het resultaat op. Vervolgens wordt met PresentationInfo.isEncrypted gecontroleerd dat de versleuteling behouden blijft en wordt de openbare metadata zonder wachtwoord opnieuw geopend om de nieuwe waarden te verifiëren:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, LoadOptions, PresentationFactory, SaveFormat

input_path = "public-properties-encrypted.pptx"
output_path = "updated-public-properties-encrypted.pptx"

load_options = LoadOptions()
load_options.setPassword("open_password")

presentation = Presentation(input_path, load_options)
try:
    presentation.getDocumentProperties().setTitle("Updated Product Roadmap")
    presentation.getDocumentProperties().setKeywords("roadmap, planning, indexed")
    presentation.save(output_path, SaveFormat.Pptx)
finally:
    presentation.dispose()

presentation_info = PresentationFactory.getInstance().getPresentationInfo(output_path)
print("The presentation is encrypted: ", presentation_info.isEncrypted())

metadata_load_options = LoadOptions()
metadata_load_options.setOnlyLoadDocumentProperties(True)

metadata_presentation = Presentation(output_path, metadata_load_options)
try:
    if metadata_presentation.getProtectionManager().isOnlyDocumentPropertiesLoaded():
        print("Title: ", metadata_presentation.getDocumentProperties().getTitle())
        print("Keywords: ", metadata_presentation.getDocumentProperties().getKeywords())
    else:
        print("The presentation was not loaded in document-properties-only mode.")

finally:
    metadata_presentation.dispose()

Als een toepassing niet gemachtigd is om de presentatie‑inhoud te ontsleutelen of te laden, moet ze openbare eigenschappen van een versleuteld PPTX‑bestand als alleen‑lezen behandelen.

Ingebouwde eigenschappen benaderen

De ingebouwde eigenschappen die door DocumentProperties worden blootgesteld, omvatten: Creator (Auteur), Description, Created (Aanmaakdatum), Modified (Wijzigingsdatum), Printed (Laatste afdrukdatum), LastModifiedBy, Keywords, SharedDoc (Wordt gedeeld tussen verschillende producenten?), PresentationFormat, Subject en Title.

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, DocumentProperties

# Instantieer de Presentation-klasse die de presentatie vertegenwoordigt
presentation = Presentation("Presentation.pptx")
try:
    # Maak een referentie naar het DocumentProperties-object dat aan de Presentation is gekoppeld
    properties = presentation.getDocumentProperties()

    # Toon de ingebouwde eigenschappen
    print("Category : ", properties.getCategory())
    print("Current Status : ", properties.getContentStatus())
    print("Creation Date : ", properties.getCreatedTime())
    print("Author : ", properties.getAuthor())
    print("Description : ", properties.getComments())
    print("KeyWords : ", properties.getKeywords())
    print("Last Modified By : ", properties.getLastSavedBy())
    print("Supervisor : ", properties.getManager())
    print("Modified Date : ", properties.getLastSavedTime())
    print("Presentation Format : ", properties.getPresentationFormat())
    print("Last Print Date : ", properties.getLastPrinted())
    print("Is Shared between producers : ", properties.getSharedDoc())
    print("Subject : ", properties.getSubject())
    print("Title : ", properties.getTitle())
finally:
    presentation.dispose()

Ingebouwde eigenschappen wijzigen

Het wijzigen van ingebouwde eigenschappen is even simpel als ze benaderen. Gebruik de bijbehorende setter om een nieuwe waarde toe te wijzen. Het volgende voorbeeld wijzigt ingebouwde documenteigenschappen met Aspose.Slides voor Python via Java.

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, SaveFormat, DocumentProperties

presentation = Presentation("Presentation.pptx")
try:
    # Maak een referentie naar het DocumentProperties-object dat aan de Presentation is gekoppeld
    properties = presentation.getDocumentProperties()

    # Stel de ingebouwde eigenschappen in
    properties.setAuthor("Aspose.Slides for Python via Java")
    properties.setTitle("Modifying Presentation Properties")
    properties.setSubject("Aspose Subject")
    properties.setComments("Aspose Description")
    properties.setManager("Aspose Manager")

    # Sla uw presentatie op naar een bestand
    presentation.save("DocProps.pptx", SaveFormat.Pptx)
finally:
    presentation.dispose()

Dit voorbeeld wijzigt de ingebouwde eigenschappen van de presentatie, zoals hieronder te zien is:

Ingebouwde documenteigenschappen na wijziging

Aangepaste documenteigenschappen toevoegen

Aspose.Slides voor Python via Java stelt ontwikkelaars ook in staat om aangepaste documenteigenschappen aan presentaties toe te voegen. Het voorbeeld hieronder voegt drie aangepaste eigenschappen toe, zoekt daarna de naam op die op index 2 is opgeslagen en verwijdert die eigenschap, zodat de opgeslagen presentatie er twee overhoudt. Aangepaste eigenschappen worden alfabetisch geïndexeerd, niet in de volgorde waarin ze zijn toegevoegd.

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, SaveFormat

presentation = Presentation()
try:
    # Documenteigenschappen ophalen
    properties = presentation.getDocumentProperties()

    # Aangepaste eigenschappen toevoegen
    properties.set_Item("New Custom", jpype.JInt(12))
    properties.set_Item("My Name", "Mudassir")
    properties.set_Item("Custom", jpype.JInt(124))

    # Eigenschapsnaam ophalen op een specifieke index
    property_name = properties.getCustomPropertyName(2)

    # Geselecteerde eigenschap verwijderen
    properties.removeCustomProperty(property_name)

    # Presentatie opslaan
    presentation.save("CustomDemo.pptx", SaveFormat.Pptx)
finally:
    presentation.dispose()

Toegevoegde aangepaste documenteigenschappen

Aangepaste eigenschappen benaderen en wijzigen

Aspose.Slides voor Python via Java laat ontwikkelaars ook de waarden van aangepaste eigenschappen raadplegen. Het volgende voorbeeld laat zien hoe u alle aangepaste eigenschappen in een presentatie kunt benaderen en wijzigen.

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, SaveFormat, DocumentProperties

presentation = Presentation("Presentation.pptx")
try:
    # Maak een referentie naar het DocumentProperties-object dat aan de Presentation is gekoppeld
    properties = presentation.getDocumentProperties()

    # Toegang krijgen tot en aanpassen van aangepaste eigenschappen
    for i in range(properties.getCountOfCustomProperties()):
        property_name = properties.getCustomPropertyName(i)
        # Toon namen en waarden van aangepaste eigenschappen
        print("Custom Property Name : ", property_name)
        print("Custom Property Value : ", properties.get_Item(property_name))

        # Pas de waarden van aangepaste eigenschappen aan
        properties.set_Item(property_name, f"New Value {i + 1}")

    # Sla uw presentatie op naar een bestand
    presentation.save("CustomDemoModified.pptx", SaveFormat.Pptx)
finally:
    presentation.dispose()

Dit voorbeeld wijzigt de aangepaste eigenschappen van de PPTX‑presentatie. De onderstaande figuren tonen de aangepaste eigenschappen vóór en na wijziging:

Aangepaste eigenschappen vóór wijziging

Aangepaste eigenschappen na wijziging

Geavanceerde documenteigenschappen

Note

Nieuwe methoden readDocumentProperties, updateDocumentProperties en writeBindedPresentation zijn toegevoegd aan de PresentationInfo, en het gedrag van de DocumentProperties.setLastSavedTime‑methode is gewijzigd.

De twee nieuwe methoden readDocumentProperties en updateDocumentProperties zijn toegevoegd aan de PresentationInfo‑klasse. Ze bieden snelle toegang tot documenteigenschappen en laten u eigenschappen wijzigen en bijwerken zonder de volledige presentatie te laden.

De typische workflow van het laden van eigenschappen, het wijzigen van hun waarden en het bijwerken van het document kan als volgt worden geïmplementeerd:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import PresentationFactory

# Lees de presentatie-informatie
presentation_info = PresentationFactory.getInstance().getPresentationInfo("presentation.pptx")

# Verkrijg de huidige eigenschappen
properties = presentation_info.readDocumentProperties()

# Stel de nieuwe waarden voor de velden Auteur en Titel in
properties.setAuthor("New Author")
properties.setTitle("New Title")

# Werk de presentatie bij met de nieuwe waarden
presentation_info.updateDocumentProperties(properties)
presentation_info.writeBindedPresentation("presentation.pptx")

Er is een alternatieve manier om eigenschappen van een specifieke presentatie als sjabloon te gebruiken om eigenschappen in andere presentaties bij te werken:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import PresentationFactory

presentation_info = PresentationFactory.getInstance().getPresentationInfo("template.pptx")
template = presentation_info.readDocumentProperties()

template.setAuthor("Template Author")
template.setTitle("Template Title")
template.setCategory("Template Category")
template.setKeywords("Keyword1, Keyword2, Keyword3")
template.setCompany("Our Company")
template.setComments("Created from template")
template.setContentType("Template Content")
template.setSubject("Template Subject")

for path in ["doc1.pptx", "doc2.odp", "doc3.ppt"]:
    presentation_to_update = PresentationFactory.getInstance().getPresentationInfo(path)
    presentation_to_update.updateDocumentProperties(template)
    presentation_to_update.writeBindedPresentation(path)

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import PresentationFactory

def update_by_template(path, template):
    presentation_to_update = PresentationFactory.getInstance().getPresentationInfo(path)
    presentation_to_update.updateDocumentProperties(template)
    presentation_to_update.writeBindedPresentation(path)

Een nieuwe sjabloon kan van de grond af worden gecreëerd en vervolgens worden gebruikt om meerdere presentaties bij te werken:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import PresentationFactory, DocumentProperties

template = DocumentProperties()

template.setAuthor("Template Author")
template.setTitle("Template Title")
template.setCategory("Template Category")
template.setKeywords("Keyword1, Keyword2, Keyword3")
template.setCompany("Our Company")
template.setComments("Created from template")
template.setContentType("Template Content")
template.setSubject("Template Subject")

for path in ["doc1.pptx", "doc2.odp", "doc3.ppt"]:
    presentation_to_update = PresentationFactory.getInstance().getPresentationInfo(path)
    presentation_to_update.updateDocumentProperties(template)
    presentation_to_update.writeBindedPresentation(path)

Controleertaal instellen

Aspose.Slides biedt de PortionFormat.setLanguageId‑methode om de controleertaal voor een PowerPoint‑document in te stellen. De controleertaal is de taal waarvoor spelling en grammatica in de presentatie worden gecontroleerd.

Deze Python‑code toont hoe u de controleertaal voor een PowerPoint‑document instelt:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, Portion, FontData

pptx_file_name = "presentation.pptx"

presentation = Presentation(pptx_file_name)
try:
    auto_shape = presentation.getSlides().get_Item(0).getShapes().get_Item(0)

    paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
    paragraph.getPortions().clear()

    new_portion = Portion()

    font = FontData("SimSun")
    portion_format = new_portion.getPortionFormat()
    portion_format.setComplexScriptFont(font)
    portion_format.setEastAsianFont(font)
    portion_format.setLatinFont(font)

    portion_format.setLanguageId("zh-CN") # stel de ID van een controleertaal in

    new_portion.setText("1。")
    paragraph.getPortions().add(new_portion)
finally:
    presentation.dispose()

Standaardtaal instellen

Deze Python‑code toont hoe u de standaardtaal voor een volledige PowerPoint‑presentatie instelt:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, LoadOptions, ShapeType

load_options = LoadOptions()
load_options.setDefaultTextLanguage("en-US")

presentation = Presentation(load_options)
try:
    # Voegt een rechthoekige vorm met tekst toe
    shape = presentation.getSlides().get_Item(0).getShapes().addAutoShape(ShapeType.Rectangle, 50, 50, 150, 50)
    shape.getTextFrame().setText("New Text")

    # Controleert de taal van de eerste portion
    print(shape.getTextFrame().getParagraphs().get_Item(0).getPortions().get_Item(0).getPortionFormat().getLanguageId())
finally:
    presentation.dispose()

Live‑voorbeeld

Probeer de Aspose.Slides Metadata‑online‑app om te zien hoe u met documenteigenschappen werkt via de Aspose.Slides‑API:

FAQ

Hoe kan ik een ingebouwde eigenschap uit een presentatie verwijderen?

Ingebouwde eigenschappen maken een integraal onderdeel van de presentatie uit en kunnen niet volledig worden verwijderd. U kunt echter hun waarden wijzigen of ze leeg maken als de specifieke eigenschap dat toelaat.

Wat gebeurt er als ik een aangepaste eigenschap toevoeg die al bestaat?

Als u een aangepaste eigenschap toevoegt die reeds bestaat, wordt de bestaande waarde overschreven met de nieuwe. U hoeft de eigenschap niet vooraf te verwijderen of te controleren; Aspose.Slides werkt de waarde automatisch bij.

Kan ik presentatieweigenschappen benaderen zonder de volledige presentatie te laden?

Ja. Gebruik PresentationFactory.getPresentationInfo en vervolgens PresentationInfo.readDocumentProperties om de opgeslagen documentmetadata te lezen zonder een Presentation‑instantie te creëren. Zie Build a Lightweight Presentation Inventory voor een volledig rapportage‑voorbeeld en format‑specifieke beperkingen.

Kan ik openbare eigenschappen van een versleutelde presentatie lezen zonder het openingswachtwoord?

Ja. De versleuteling van documenteigenschappen moet zijn uitgeschakeld voordat de presentatie werd versleuteld, en de presentatie moet in “alleen‑documenteigenschappen”‑modus worden geladen.

Kan ik een versleuteld PPTX‑bestand bijwerken in alleen‑documenteigenschappen‑modus?

Nee. Publieke en versleutelde eigenschapsdata moeten consistent blijven, dus het bijwerken van een versleuteld PPTX‑bestand vereist het volledige laden van de presentatie met het juiste openingswachtwoord.

Veilige presentaties in Python via Java Ophalen en bijwerken van presentatieweergave‑eigenschappen in Python via Java