Recupera e aggiorna le informazioni della presentazione in C++

Di cosa tratta questa pagina

Esplora diapositive, struttura e metadati nelle presentazioni PowerPoint e OpenDocument usando C++ per ottenere approfondimenti più rapidi e audit dei contenuti più intelligenti.

Panoramica

Aspose.Slides può identificare il formato di una presentazione e leggere i metadati del documento senza creare un modello completo di oggetti della presentazione. Questo è utile quando è necessario classificare i file, creare un inventario o ispezionare le proprietà prima di decidere se caricare ed elaborare il contenuto della presentazione.

Questo articolo dimostra l’ispezione leggera tramite PresentationFactory e IPresentationInfo, nonché aggiornamenti mirati tramite IDocumentProperties.

Verificare il formato di una presentazione

Se hai già una presentazione caricata, consulta Determine the Original Presentation Format per la rilevazione dopo il caricamento e le limitazioni dei flussi legacy PPT, PPS e POT.

Utilizza IPresentationFactory::GetPresentationInfo per ispezionare un file senza creare un’istanza di Presentation. Il metodo IPresentationInfo::get_LoadFormat restituisce il formato rilevato, ad esempio PPTX, PPT o ODP.

#include <DOM/IPresentationInfo.h>
#include <DOM/PresentationFactory.h>
#include <LoadFormat.h>
#include <system/array.h>
#include <system/console.h>
#include <system/object_ext.h>
#include <system/string.h>

using namespace Aspose::Slides;
using namespace System;

auto fileNames = MakeArray<String>({u"pres.pptx", u"pres.ppt", u"pres.odp"});

for (const auto& fileName : fileNames)
{
    auto presentationInfo = PresentationFactory::get_Instance()->GetPresentationInfo(fileName);
    Console::WriteLine(String::Format(u"{0}: {1}", fileName, ObjectExt::ToString(presentationInfo->get_LoadFormat())));
}

Creare un inventario leggero di presentazioni

Quando elabori molti file di presentazione, potresti aver bisogno di un inventario compatto per la convalida, l’indicizzazione o un sistema di gestione dei documenti. In questo scenario, utilizza IPresentationFactory::GetPresentationInfo per ottenere un oggetto IPresentationInfo, e quindi chiama IPresentationInfo::ReadDocumentProperties per leggere i metadati del documento. Questo approccio non crea un’istanza di Presentation né richiede di attraversare l’intero modello di oggetti della presentazione.

Le proprietà estese esposte da IDocumentProperties forniscono i seguenti valori di inventario:

Metodo	Valore dell’inventario
get_Slides	Numero totale di diapositive.
get_HiddenSlides	Numero di diapositive nascoste.
get_Notes	Numero di diapositive che contengono note.
get_Paragraphs	Numero totale di paragrafi, se disponibili.
get_Words	Numero totale di parole.
get_MultimediaClips	Numero totale di clip audio e video.

L’esempio seguente legge questi valori senza creare un oggetto Presentation e stampa un inventario compatto. Combina inoltre IDocumentProperties::get_HeadingPairs con IDocumentProperties::get_TitlesOfParts per visualizzare gruppi di contenuti come caratteri, temi e titoli delle diapositive.

#include <DOM/IDocumentProperties.h>
#include <DOM/IHeadingPair.h>
#include <DOM/IPresentationInfo.h>
#include <DOM/PresentationFactory.h>
#include <LoadFormat.h>
#include <system/console.h>
#include <system/io/path.h>
#include <system/object_ext.h>
#include <system/string.h>

using namespace Aspose::Slides;
using namespace System;
using namespace System::IO;

auto filePath = String(u"sample.pptx");
auto presentationInfo = PresentationFactory::get_Instance()->GetPresentationInfo(filePath);
auto documentProperties = presentationInfo->ReadDocumentProperties();

Console::WriteLine(String::Format(u"File: {0}", Path::GetFileName(filePath)));
Console::WriteLine(String::Format(u"Format: {0}", ObjectExt::ToString(presentationInfo->get_LoadFormat())));
Console::WriteLine(String::Format(u"Title: {0}", documentProperties->get_Title()));
Console::WriteLine(String::Format(u"Author: {0}", documentProperties->get_Author()));
Console::WriteLine(u"Statistics:");
Console::WriteLine(String::Format(u"  Slides: {0}", documentProperties->get_Slides()));
Console::WriteLine(String::Format(u"  Hidden slides: {0}", documentProperties->get_HiddenSlides()));
Console::WriteLine(String::Format(u"  Slides with notes: {0}", documentProperties->get_Notes()));
Console::WriteLine(String::Format(u"  Paragraphs: {0}", documentProperties->get_Paragraphs()));
Console::WriteLine(String::Format(u"  Words: {0}", documentProperties->get_Words()));
Console::WriteLine(String::Format(u"  Multimedia clips: {0}", documentProperties->get_MultimediaClips()));

auto headingPairs = documentProperties->get_HeadingPairs();
auto titlesOfParts = documentProperties->get_TitlesOfParts();
auto partIndex = 0;

if (headingPairs == nullptr || titlesOfParts == nullptr || headingPairs->get_Length() == 0 || titlesOfParts->get_Length() == 0)
{
    Console::WriteLine(u"Content groups: not available");
}
else
{
    Console::WriteLine(u"Content groups:");

    for (const auto& headingPair : headingPairs)
    {
        auto partCount = headingPair->get_Count();
        Console::WriteLine(String::Format(u"  {0} ({1})", headingPair->get_Name(), partCount));

        for (auto partOffset = 0; partOffset < partCount && partIndex < titlesOfParts->get_Length(); partOffset++)
        {
            Console::WriteLine(String::Format(u"    - {0}", titlesOfParts[partIndex]));
            partIndex++;
        }
    }

    if (partIndex < titlesOfParts->get_Length())
    {
        Console::WriteLine(u"  Other parts:");

        while (partIndex < titlesOfParts->get_Length())
        {
            Console::WriteLine(String::Format(u"    - {0}", titlesOfParts[partIndex]));
            partIndex++;
        }
    }
}

Ogni IHeadingPair fornisce un nome di gruppo tramite IHeadingPair::get_Name e il numero di elementi in quel gruppo tramite IHeadingPair::get_Count. IDocumentProperties::get_TitlesOfParts restituisce un array piatto e ordinato, quindi consumare il numero di titoli consecutivi specificati da ciascuna coppia di intestazione.

Metadati memorizzati e limitazioni del formato

Le proprietà dell’inventario restituite da IPresentationInfo::ReadDocumentProperties riflettono i metadati disponibili nel documento di origine. Aspose.Slides non carica e attraversa il modello di oggetti della presentazione per ricalcolare questi valori per questa chiamata. Le proprietà mancanti sono rappresentate da valori predefiniti e i valori memorizzati possono essere obsoleti se l’applicazione che ha salvato il file per ultima non ha aggiornato le proprietà del documento.

PPTX: Il formato fornisce proprietà di documento estese per conteggi di diapositive, note, diapositive nascoste, paragrafi, parole e contenuti multimediali, nonché coppie di intestazioni e titoli delle parti. La disponibilità dipende dalle proprietà scritte dal produttore del documento.
PPT: Il formato binario può memorizzare le corrispondenti proprietà di riepilogo del documento. Se una proprietà è assente o non è stata aggiornata dal produttore del documento, Aspose.Slides restituisce il suo valore memorizzato o predefinito anziché calcolarlo dalle diapositive.
ODP: I metadati OpenDocument forniscono statistiche generali del documento, come conteggi di pagine, paragrafi e parole, ma questi valori non corrispondono a tutte le proprietà estese specifiche di PowerPoint. I metadati di diapositive nascoste, diapositive con note, multimedia, coppie di intestazioni e titoli delle parti potrebbero non essere disponibili, e le proprietà dell’inventario potrebbero restituire valori predefiniti. Non considerare un valore zero o un array vuoto come prova autorevole dell’assenza del contenuto corrispondente.

Utilizza l’approccio dei metadati leggeri per gli inventari e i controlli preliminari. Carica la presentazione e ispeziona il suo modello di oggetti live quando il risultato deve riflettere le modifiche in memoria o quando è necessario verificare il contenuto reale della presentazione.

Aggiornare le proprietà della presentazione

Le proprietà restituite da IPresentationInfo::ReadDocumentProperties possono anche essere modificate senza creare un’istanza di Presentation. Applica le modifiche con IPresentationInfo::UpdateDocumentProperties, quindi scrivi la presentazione collegata con IPresentationInfo::WriteBindedPresentation.

L’immagine seguente mostra le proprietà originali del documento della presentazione PowerPoint.

Proprietà originali del documento della presentazione PowerPoint

L’esempio seguente modifica il titolo e l’ora dell’ultimo salvataggio e scrive il risultato in un nuovo file:

#include <DOM/IDocumentProperties.h>
#include <DOM/IPresentationInfo.h>
#include <DOM/PresentationFactory.h>
#include <system/date_time.h>
#include <system/string.h>

using namespace Aspose::Slides;
using namespace System;

auto sourceFile = String(u"sample.pptx");
auto outputFile = String(u"sample_with_updated_properties.pptx");
auto presentationInfo = PresentationFactory::get_Instance()->GetPresentationInfo(sourceFile);
auto documentProperties = presentationInfo->ReadDocumentProperties();

documentProperties->set_Title(u"Quarterly sales report");
documentProperties->set_LastSavedTime(DateTime::get_UtcNow());

presentationInfo->UpdateDocumentProperties(documentProperties);
presentationInfo->WriteBindedPresentation(outputFile);

L’immagine seguente mostra le proprietà del documento modificate della presentazione PowerPoint.

Proprietà del documento modificate della presentazione PowerPoint

Link utili

Per controlli di sicurezza correlati e impostazioni di protezione, consulta i seguenti articoli:

FAQ

Come posso verificare se i font sono incorporati e quali sono?

Carica la presentazione e utilizza Presentation::get_FontsManager. Chiama FontsManager::GetEmbeddedFonts per ottenere i font incorporati e FontsManager::GetFonts per ottenere i font utilizzati dalla presentazione. Confronta i due risultati per trovare i font necessari per il rendering ma non incorporati.

Come posso capire rapidamente se il file contiene diapositive nascoste e quante?

Quando i metadati del documento memorizzati sono sufficienti, leggi IDocumentProperties::get_HiddenSlides tramite IPresentationFactory::GetPresentationInfo e IPresentationInfo::ReadDocumentProperties. Questo è adatto per un inventario leggero. Se la presentazione è stata modificata in memoria, i metadati memorizzati potrebbero mancare o essere obsoleti, oppure è necessario verificare i valori live; in tal caso, itera su Presentation::get_Slides e ispeziona il metodo Slide::get_Hidden di ciascuna diapositiva.

Posso rilevare se viene utilizzata una dimensione e orientamento della diapositiva personalizzati e se differiscono dai valori predefiniti?

Sì. Carica la presentazione e leggi Presentation::get_SlideSize. Ispeziona ISlideSize::get_Type, ISlideSize::get_Size, e ISlideSize::get_Orientation per confrontare le impostazioni attuali con le preimpostazioni e le dimensioni previste.

Esiste un modo rapido per vedere se i grafici fanno riferimento a fonti di dati esterne?

Sì. Individua ogni Chart e ispeziona ChartData::get_DataSourceType. Per una cartella di lavoro esterna, leggi ChartData::get_ExternalWorkbookPath. Il tipo di origine dati e il percorso identificano un riferimento esterno, ma verificare se la destinazione è disponibile richiede un controllo delle risorse separato.

Come posso valutare le diapositive ‘pesanti’ che possono rallentare il rendering o l’esportazione PDF?

Non esiste una singola proprietà di complessità. Attraversa Presentation::get_Slides e la collezione IBaseSlide::get_Shapes di ciascuna diapositiva. Usa il conteggio delle forme e la presenza di immagini grandi, effetti, animazioni o contenuti multimediali come segnali di segnalazione, e misura un rendering o un’esportazione rappresentativa prima di considerare una diapositiva come un collo di bottiglia di prestazioni confermato.

Aprire presentazioni in C++ Determinare il formato originale della presentazione in C++