Suche und Ersetze Text in PowerPoint-Präsentationen in C++

Worum es auf dieser Seite geht

Suchen, hervorheben und ersetzen Sie Text in PowerPoint-Präsentationen und sammeln dabei jede Übereinstimmung mit Aspose.Slides für C++.

Übersicht

Aspose.Slides für C++ kann Text in einem einzelnen Textfeld oder über eine gesamte Präsentation hinweg suchen, hervorheben und ersetzen. Jede Operation kann außerdem eine Anwendung über jede Übereinstimmung mittels eines Ergebnis‑Callbacks informieren. Damit ist es möglich, eine Präsentation zu aktualisieren und gleichzeitig ein Prüfprotokoll zu erstellen, das den gefundenen Text, seinen Kontext, die Position, das Textfeld und die Foliennummer enthält.

Diese Funktionen sind nützlich für Überprüfungen, Schwärzungen, Terminologieprüfungen, Vorlagenbereinigung und automatisierte Reporting‑Workflows.

In den folgenden ersten Beispielen verwenden wir eine Datei mit dem Namen “sample.pptx”, die auf der ersten Folie ein einzelnes Textfeld mit folgendem Text enthält:

Sample text

Wählen Sie den Suchbereich

Verwenden Sie Methoden von ITextFrame, um eine Operation auf ein Textfeld zu beschränken. Verwenden Sie Methoden von IPresentation, um allen zutreffenden Text in der Präsentation zu verarbeiten.

Operation	Ein Textfeld	Gesamte Präsentation
Literaltext hervorheben	ITextFrame::HighlightText	IPresentation::HighlightText
Übereinstimmungen von regulären Ausdrücken hervorheben	ITextFrame::HighlightRegex	IPresentation::HighlightRegex
Literaltext ersetzen	ITextFrame::ReplaceText	IPresentation::ReplaceText
Übereinstimmungen von regulären Ausdrücken ersetzen	ITextFrame::ReplaceRegex	IPresentation::ReplaceRegex

Textabgleich konfigurieren

Für Literaltext‑Operationen verwenden Sie ITextSearchOptions, um den Abgleich zu steuern:

ITextSearchOptions::set_WholeWordsOnly beschränkt die Übereinstimmungen auf ganze Wörter.
ITextSearchOptions::set_CaseSensitive steuert, ob die Groß‑ und Kleinschreibung übereinstimmen muss.
ITextSearchOptions::set_IncludeNotes schließt Foliennotizen in die Präsentationsebene‑Suche, -Ersetzung und -Hervorhebung ein.

Reguläre‑Ausdruck‑Operationen verwenden ein System::Text::RegularExpressions::Regex, sodass Regeln wie Groß‑/Kleinschreibung und Wortgrenzen durch den Ausdruck und seine Optionen definiert werden.

Übereinstimmungsinformationen mit einem Callback sammeln

Implementieren Sie IFindResultCallback, um für jede Übereinstimmung eine Benachrichtigung zu erhalten. Seine IFindResultCallback::FoundResult‑Methode liefert das zugehörige Textfeld, den Quelltext, den gefundenen Text und die Position der Übereinstimmung.

Der Callback erhält nicht direkt eine Foliennummer. Die nachstehende Implementierung leitet sie aus ISlideComponent::get_Slide ab und behandelt zudem Text, der in Foliennotizen gefunden wird, über INotesSlide::get_ParentSlide. Eine nullable Foliennummer ermöglicht es, dass dasselbe Ergebnis‑Modell Text zu anderen Folientypen zuzuordnen.

#include <DOM/IBaseSlide.h>
#include <DOM/INotesSlide.h>
#include <DOM/ISlide.h>
#include <DOM/ITextFrame.h>
#include <IFindResultCallback.h>
#include <system/collections/list.h>
#include <system/nullable.h>
#include <system/smart_ptr.h>
#include <system/string.h>

using Aspose::Slides::IBaseSlide;
using Aspose::Slides::IFindResultCallback;
using Aspose::Slides::INotesSlide;
using Aspose::Slides::ISlide;
using Aspose::Slides::ITextFrame;
using System::AsCast;
using System::MakeObject;
using System::Nullable;
using System::SharedPtr;
using System::String;
using System::Collections::Generic::List;

class TextMatch : public System::Object
{
public:
    TextMatch(SharedPtr<ITextFrame> textFrame, String sourceText, String foundText,
        int32_t textPosition, Nullable<int32_t> slideNumber)
        : TextFrame(textFrame), SourceText(sourceText), FoundText(foundText),
          TextPosition(textPosition), SlideNumber(slideNumber)
    {
    }

    SharedPtr<ITextFrame> TextFrame;
    String SourceText;
    String FoundText;
    int32_t TextPosition;
    Nullable<int32_t> SlideNumber;
};

class TextSearchCallback : public IFindResultCallback
{
public:
    TextSearchCallback()
        : Results(MakeObject<List<SharedPtr<TextMatch>>>())
    {
    }

    void FoundResult(SharedPtr<ITextFrame> textFrame, String sourceText,
        String foundText, int32_t textPosition) override
    {
        auto slideNumber = GetSlideNumber(textFrame);
        auto result = MakeObject<TextMatch>(textFrame, sourceText, foundText,
            textPosition, slideNumber);

        Results->Add(result);
    }

    SharedPtr<List<SharedPtr<TextMatch>>> Results;

private:
    static Nullable<int32_t> GetSlideNumber(SharedPtr<ITextFrame> textFrame)
    {
        SharedPtr<IBaseSlide> baseSlide = textFrame->get_Slide();
        auto slide = AsCast<ISlide>(baseSlide);

        if (slide != nullptr)
        {
            return slide->get_SlideNumber();
        }

        auto notesSlide = AsCast<INotesSlide>(baseSlide);
        if (notesSlide != nullptr)
        {
            auto parentSlide = notesSlide->get_ParentSlide();
            return parentSlide->get_SlideNumber();
        }

        return nullptr;
    }
};

Für Ersetzungs‑Operationen enthält FoundText den ursprünglichen gefundenen Text, sodass der Callback exakt aufzeichnen kann, welche Begriffe ersetzt wurden.

Text hervorheben

Verwenden Sie die ITextFrame::HighlightText‑Methode, um Literaltext‑Übereinstimmungen in einem Textfeld hervorzuheben. Übergeben Sie [ITextSearchOptions], um die Suche zu steuern, und einen Callback, um die Details der Übereinstimmungen zu sammeln.

Das untenstehende Code‑Beispiel hebt alle Vorkommen der Zeichen “try” hervor und anschließend nur das ganze Wort “to”. Beide Suchen melden ihre Treffer an denselben Callback.

#include <DOM/IAutoShape.h>
#include <DOM/ITextFrame.h>
#include <DOM/Presentation.h>
#include <DOM/TextFind/TextSearchOptions.h>
#include <Export/SaveFormat.h>
#include <drawing/color.h>
#include <system/console.h>
#include <system/smart_ptr.h>

using Aspose::Slides::IAutoShape;
using Aspose::Slides::Presentation;
using Aspose::Slides::TextSearchOptions;
using Aspose::Slides::Export::SaveFormat;
using System::ExplicitCast;
using System::MakeObject;

auto presentation = MakeObject<Presentation>(u"sample.pptx");

// Get the first shape from the first slide.
auto shape = ExplicitCast<IAutoShape>(presentation->get_Slide(0)->get_Shape(0));
auto callback = MakeObject<TextSearchCallback>();

auto substringSearchOptions = MakeObject<TextSearchOptions>();
substringSearchOptions->set_CaseSensitive(false);

// Highlight every occurrence of "try" in the text frame.
shape->get_TextFrame()->HighlightText(
    u"try", System::Drawing::Color::get_LightBlue(), substringSearchOptions, callback);

auto wholeWordSearchOptions = MakeObject<TextSearchOptions>();
wholeWordSearchOptions->set_WholeWordsOnly(true);
wholeWordSearchOptions->set_CaseSensitive(false);

// Highlight only the complete word "to".
shape->get_TextFrame()->HighlightText(
    u"to", System::Drawing::Color::get_Violet(), wholeWordSearchOptions, callback);

for (auto&& result : callback->Results)
{
    auto slideLabel = result->SlideNumber.get_HasValue()
        ? System::String::Format(u"{0}", result->SlideNumber.get_Value())
        : u"Other";

    System::Console::WriteLine(u"Found '{0}' at position {1} on slide {2}.",
        result->FoundText, result->TextPosition, slideLabel);
}

presentation->Save(u"highlighted_text.pptx", SaveFormat::Pptx);
presentation->Dispose();

Das Ergebnis:

The highlighted text

Text mithilfe regulärer Ausdrücke hervorheben

Die ITextFrame::HighlightRegex‑Methode hebt Text‑Übereinstimmungen hervor, die durch einen regulären Ausdruck in einem Textfeld gefunden wurden.

Das folgende Beispiel hebt alle Wörter mit sieben oder mehr Zeichen hervor und sammelt jede Übereinstimmung:

#include <DOM/IAutoShape.h>
#include <DOM/ITextFrame.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <drawing/color.h>
#include <system/smart_ptr.h>
#include <system/text/regularexpressions/regex.h>

using Aspose::Slides::IAutoShape;
using Aspose::Slides::Presentation;
using Aspose::Slides::Export::SaveFormat;
using System::ExplicitCast;
using System::MakeObject;
using System::Text::RegularExpressions::Regex;

auto presentation = MakeObject<Presentation>(u"sample.pptx");

auto shape = ExplicitCast<IAutoShape>(presentation->get_Slide(0)->get_Shape(0));
auto callback = MakeObject<TextSearchCallback>();
auto regex = MakeObject<Regex>(u"\\b[^\\s]{7,}\\b");

shape->get_TextFrame()->HighlightRegex(
    regex, System::Drawing::Color::get_Yellow(), callback);

presentation->Save(u"highlighted_text_using_regex.pptx", SaveFormat::Pptx);
presentation->Dispose();

Das Ergebnis:

The highlighted text using the regular expression

Text über eine gesamte Präsentation hinweg hervorheben

Verwenden Sie IPresentation::HighlightText und IPresentation::HighlightRegex, um alle zutreffenden Textfelder in einer Präsentation zu durchsuchen. Das folgende Beispiel hebt einen Literalbegriff und alle E‑Mail‑Adressen hervor, wobei separate Ergebnis‑Sammlungen für die beiden Suchen geführt werden.

#include <DOM/Presentation.h>
#include <DOM/TextFind/TextSearchOptions.h>
#include <Export/SaveFormat.h>
#include <drawing/color.h>
#include <system/smart_ptr.h>
#include <system/text/regularexpressions/regex.h>
#include <system/text/regularexpressions/regex_options.h>

using Aspose::Slides::Presentation;
using Aspose::Slides::TextSearchOptions;
using Aspose::Slides::Export::SaveFormat;
using System::MakeObject;
using System::Text::RegularExpressions::Regex;
using System::Text::RegularExpressions::RegexOptions;

auto presentation = MakeObject<Presentation>(u"presentation.pptx");

auto termCallback = MakeObject<TextSearchCallback>();
auto searchOptions = MakeObject<TextSearchOptions>();
searchOptions->set_WholeWordsOnly(true);
searchOptions->set_CaseSensitive(false);

presentation->HighlightText(
    u"confidential", System::Drawing::Color::get_Orange(), searchOptions, termCallback);

auto emailCallback = MakeObject<TextSearchCallback>();
auto emailRegex = MakeObject<Regex>(
    u"\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}\\b", RegexOptions::IgnoreCase);

presentation->HighlightRegex(
    emailRegex, System::Drawing::Color::get_Yellow(), emailCallback);

presentation->Save(u"highlighted_presentation.pptx", SaveFormat::Pptx);
presentation->Dispose();

Text in einem Textfeld ersetzen

Verwenden Sie ITextFrame::ReplaceText für Literaltext und ITextFrame::ReplaceRegex für ersatzbasierte Muster. Diese Methoden aktualisieren den gefundenen Text innerhalb des bestehenden Textfelds, wodurch die umgebende Formatierung erhalten bleibt, anstatt das Textfeld aus einem reinen String neu zu erstellen.

Das folgende Beispiel vereinheitlicht eine Rechtschreibvariante und ersetzt anschließend Versionsbezeichnungen. Derselbe Callback zeichnet die ursprünglichen Begriffe auf, die von beiden Operationen gefunden wurden.

#include <DOM/IAutoShape.h>
#include <DOM/ITextFrame.h>
#include <DOM/Presentation.h>
#include <DOM/TextFind/TextSearchOptions.h>
#include <Export/SaveFormat.h>
#include <system/smart_ptr.h>
#include <system/text/regularexpressions/regex.h>
#include <system/text/regularexpressions/regex_options.h>

using Aspose::Slides::IAutoShape;
using Aspose::Slides::Presentation;
using Aspose::Slides::TextSearchOptions;
using Aspose::Slides::Export::SaveFormat;
using System::ExplicitCast;
using System::MakeObject;
using System::Text::RegularExpressions::Regex;
using System::Text::RegularExpressions::RegexOptions;

auto presentation = MakeObject<Presentation>(u"presentation.pptx");

auto shape = ExplicitCast<IAutoShape>(presentation->get_Slide(0)->get_Shape(0));
auto callback = MakeObject<TextSearchCallback>();
auto searchOptions = MakeObject<TextSearchOptions>();
searchOptions->set_WholeWordsOnly(true);
searchOptions->set_CaseSensitive(false);

shape->get_TextFrame()->ReplaceText(u"colour", u"color", searchOptions, callback);

auto versionRegex = MakeObject<Regex>(
    u"\\bv\\d+(?:\\.\\d+)*\\b", RegexOptions::IgnoreCase);
shape->get_TextFrame()->ReplaceRegex(versionRegex, u"current version", callback);

presentation->Save(u"updated_text_frame.pptx", SaveFormat::Pptx);
presentation->Dispose();

Falls eine Übereinstimmung über Textteile mit unterschiedlicher Formatierung hinweg reicht, prüfen Sie die Ausgabe, um zu bestätigen, welche Formatierung auf den Ersetzungstext angewendet werden soll.

Text über eine gesamte Präsentation hinweg ersetzen

Verwenden Sie IPresentation::ReplaceText und IPresentation::ReplaceRegex, um dieselben Operationen über die gesamte Präsentation anzuwenden. Dies ist nützlich für Vorlagenbereinigung, Terminologie‑Updates und Schwärzungen.

#include <DOM/Presentation.h>
#include <DOM/TextFind/TextSearchOptions.h>
#include <Export/SaveFormat.h>
#include <system/smart_ptr.h>
#include <system/text/regularexpressions/regex.h>

using Aspose::Slides::Presentation;
using Aspose::Slides::TextSearchOptions;
using Aspose::Slides::Export::SaveFormat;
using System::MakeObject;
using System::Text::RegularExpressions::Regex;

auto presentation = MakeObject<Presentation>(u"presentation.pptx");

auto callback = MakeObject<TextSearchCallback>();
auto searchOptions = MakeObject<TextSearchOptions>();
searchOptions->set_WholeWordsOnly(true);
searchOptions->set_CaseSensitive(true);

presentation->ReplaceText(u"Contoso", u"Example Corp", searchOptions, callback);

auto accountNumberRegex = MakeObject<Regex>(u"\\bACCT-\\d{6}\\b");
presentation->ReplaceRegex(accountNumberRegex, u"ACCT-REDACTED", callback);

presentation->Save(u"updated_presentation.pptx", SaveFormat::Pptx);
presentation->Dispose();

Übereinstimmungen für Reporting gruppieren

Da jedes Ergebnis seine Foliennummer und sein Textfeld speichert, können Anwendungen die Treffer für Audits, Berichte oder Review‑Workflows gruppieren. Das folgende Beispiel gruppiert die gesammelten Ergebnisse zuerst nach Folie und dann nach Textfeld:

#include <DOM/ITextFrame.h>
#include <system/console.h>
#include <system/string.h>
#include <map>
#include <vector>

std::map<int32_t, std::map<Aspose::Slides::ITextFrame*,
    std::vector<System::SharedPtr<TextMatch>>>> matchesBySlide;

for (auto&& result : callback->Results)
{
    int32_t slideKey = result->SlideNumber.get_HasValue()
        ? result->SlideNumber.get_Value()
        : 0;
    auto textFrameKey = result->TextFrame.get();

    matchesBySlide[slideKey][textFrameKey].push_back(result);
}

for (const auto& slideGroup : matchesBySlide)
{
    auto slideLabel = slideGroup.first == 0
        ? System::String(u"Other")
        : System::String::Format(u"{0}", slideGroup.first);
    System::Console::WriteLine(u"Slide: {0}", slideLabel);

    for (const auto& textFrameGroup : slideGroup.second)
    {
        auto textFrameText = textFrameGroup.first->get_Text();
        System::Console::WriteLine(u"  Text frame: {0}", textFrameText);

        for (const auto& result : textFrameGroup.second)
        {
            System::Console::WriteLine(
                u"    '{0}' at position {1}; context: '{2}'",
                result->FoundText, result->TextPosition, result->SourceText);
        }
    }
}

FAQ

Wie kann ich nur ein Textfeld anstatt der gesamten Präsentation durchsuchen?

Rufen Sie das Textfeld der Shape ab und verwenden Sie ITextFrame::HighlightText, ITextFrame::HighlightRegex, ITextFrame::ReplaceText oder ITextFrame::ReplaceRegex für dieses Textfeld. Methoden auf Präsentationsebene verarbeiten alle zutreffenden Textfelder.

Wie kann ich vollständige Wörter mit korrekter Groß‑ und Kleinschreibung abgleichen?

Rufen Sie ITextSearchOptions::set_WholeWordsOnly und ITextSearchOptions::set_CaseSensitive mit true auf und übergeben Sie die Optionen an eine Literaltext‑Hervorhebungs‑ oder Ersetzungs‑Methode. Bei regulären Ausdrücken definieren Sie Wortgrenzen und Groß‑/Kleinschreibung im System::Text::RegularExpressions::Regex selbst.

Können Suche und Ersetzung Text in Foliennotizen einschließen?

Ja. Rufen Sie ITextSearchOptions::set_IncludeNotes mit true auf, wenn Sie eine Literaltext‑Operation auf Präsentationsebene verwenden. Die oben gezeigte Callback‑Implementierung ordnet eine Übereinstimmung in einer Notizfolie ihrer übergeordneten Foliennummer zu.

Wie kann ich einen Bericht erstellen, ohne die Präsentation ein zweites Mal zu scannen?

Übergeben Sie eine IFindResultCallback-Implementierung an die Hervorhebungs‑ oder Ersetzungs‑Operation. Der Callback erhält jede Übereinstimmung während der Ausführung, sodass die Anwendung Quelltext, gefundenen Text, Position, Textfeld und abgeleitete Foliennummer für spätere Gruppierung oder Export speichern kann.

Erhält das Ersetzen von Text dessen Formatierung?

ITextFrame::ReplaceText und ITextFrame::ReplaceRegex ändern den gefundenen Text innerhalb des bestehenden Textfelds und behalten die umgebende Formatierung bei. Falls eine Übereinstimmung über Textteile mit unterschiedlicher Formatierung hinweg reicht, prüfen Sie das Ergebnis, um sicherzustellen, dass die Ersetzung den gewünschten Stil verwendet.

Präsentationstext in C++ formatieren PowerPoint-Text in C++ animieren