Recherche et remplacement de texte dans les présentations PowerPoint en C++

À propos de cette page

Recherchez, mettez en évidence et remplacez du texte dans les présentations PowerPoint tout en collectant chaque correspondance avec Aspose.Slides pour C++.

Vue d’ensemble

Aspose.Slides for C++ peut rechercher, mettre en évidence et remplacer du texte dans un cadre de texte individuel ou dans l’ensemble d’une présentation. Chaque opération peut également notifier une application à chaque correspondance via un rappel de résultat. Cela rend possible la mise à jour d’une présentation tout en construisant simultanément une trace d’audit contenant le texte correspondant, son contexte, sa position, le cadre de texte et le numéro de diapositive.

Ces capacités sont utiles pour la révision, la censure, les vérifications de terminologie, le nettoyage de modèles et les flux de travail de génération de rapports automatisés.

Dans les premiers exemples ci‑dessous, nous utilisons un fichier nommé “sample.pptx”, qui contient une seule zone de texte sur la première diapositive avec le texte suivant :

Texte d’exemple

Choisir la portée de la recherche

Utilisez les méthodes de ITextFrame pour limiter une opération à un seul cadre de texte. Utilisez les méthodes de IPresentation pour traiter tout le texte applicable dans la présentation.

Opération	Un cadre de texte	Présentation entière
Mettre en évidence le texte littéral	ITextFrame::HighlightText	IPresentation::HighlightText
Mettre en évidence les correspondances d’expression régulière	ITextFrame::HighlightRegex	IPresentation::HighlightRegex
Remplacer le texte littéral	ITextFrame::ReplaceText	IPresentation::ReplaceText
Remplacer les correspondances d’expression régulière	ITextFrame::ReplaceRegex	IPresentation::ReplaceRegex

Configurer la correspondance de texte

Pour les opérations de texte littéral, utilisez ITextSearchOptions pour contrôler la correspondance :

ITextSearchOptions::set_WholeWordsOnly limite les correspondances aux mots complets.
ITextSearchOptions::set_CaseSensitive contrôle si la casse des caractères doit correspondre.
ITextSearchOptions::set_IncludeNotes inclut les notes de diapositive dans les opérations de recherche, de remplacement et de mise en évidence au niveau de la présentation.

Les opérations d’expression régulière utilisent un System::Text::RegularExpressions::Regex, de sorte que les règles de correspondance comme la sensibilité à la casse et les limites de mots sont définies par l’expression et ses options.

Collecter les informations de correspondance avec un callback

Implémentez IFindResultCallback pour recevoir une notification pour chaque correspondance. Sa méthode IFindResultCallback::FoundResult fournit le cadre de texte concerné, le texte source, le texte trouvé et la position de la correspondance.

Le callback ne reçoit pas directement le numéro de diapositive. L’implémentation ci‑dessous le dérive de ISlideComponent::get_Slide et gère également le texte trouvé dans les notes de diapositive via INotesSlide::get_ParentSlide. Un numéro de diapositive nullable permet au même modèle de résultat de représenter du texte associé à d’autres types de diapositives.

#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;
    }
};

Pour les opérations de remplacement, FoundText contient le texte original correspondant, de sorte que le callback peut enregistrer exactement quels termes ont été remplacés.

Mettre en évidence le texte

Utilisez la méthode ITextFrame::HighlightText pour mettre en évidence les correspondances de texte littéral dans un cadre de texte. Passez un ITextSearchOptions pour contrôler la recherche et un callback pour collecter les détails des correspondances.

L’exemple de code ci‑dessous met en évidence toutes les occurrences des caractères “try” puis ne met en évidence que le mot complet “to”. Les deux recherches rapportent leurs correspondances au même 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();

Le résultat :

Le texte mis en évidence

Mettre en évidence le texte à l’aide d’expressions régulières

La méthode ITextFrame::HighlightRegex met en évidence les correspondances de texte trouvées par une expression régulière dans un cadre de texte.

Le code suivant met en évidence tous les mots contenant sept caractères ou plus et collecte chaque correspondance :

#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();

Le résultat :

Le texte mis en évidence à l’aide de l’expression régulière

Mettre en évidence le texte dans toute une présentation

Utilisez IPresentation::HighlightText et IPresentation::HighlightRegex pour rechercher tous les cadres de texte applicables dans une présentation. L’exemple suivant met en évidence un terme littéral et toutes les adresses e‑mail tout en conservant des collections de résultats distinctes pour les deux recherches.

#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();

Remplacer le texte dans un cadre de texte

Utilisez ITextFrame::ReplaceText pour le texte littéral et ITextFrame::ReplaceRegex pour le remplacement basé sur un motif. Ces méthodes mettent à jour le texte correspondant à l’intérieur du cadre de texte existant, qui conserve le formatage de la portion environnante au lieu de reconstruire le cadre de texte à partir d’une chaîne brute.

L’exemple suivant standardise une variante orthographique puis remplace les libellés de version. Le même callback enregistre les termes originaux correspondants aux deux opérations.

#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();

Si une correspondance s’étend sur des portions avec un formatage différent, examinez le résultat pour confirmer quel format doit s’appliquer au texte de remplacement.

Remplacer le texte dans toute une présentation

Utilisez IPresentation::ReplaceText et IPresentation::ReplaceRegex pour appliquer les mêmes opérations à travers la présentation. Ceci est utile pour le nettoyage de modèles, les mises à jour de terminologie et la censure.

#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();

Grouper les correspondances pour le reporting

Comme chaque résultat stocke son numéro de diapositive et son cadre de texte, les applications peuvent regrouper les correspondances pour l’audit, le reporting ou les flux de travail de révision. L’exemple suivant regroupe les résultats collectés d’abord par diapositive, puis par cadre de texte :

#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

Comment puis‑je rechercher uniquement une zone de texte plutôt que toute la présentation ?

Obtenez le cadre de texte de la forme et appelez ITextFrame::HighlightText, ITextFrame::HighlightRegex, ITextFrame::ReplaceText ou ITextFrame::ReplaceRegex sur ce cadre de texte. Les méthodes au niveau de la présentation traitent toutes les zones de texte applicables à la place.

Comment puis‑je faire correspondre des mots complets avec la casse correcte ?

Appelez ITextSearchOptions::set_WholeWordsOnly et ITextSearchOptions::set_CaseSensitive avec true, puis transmettez les options à une méthode de mise en évidence ou de remplacement de texte littéral. Pour les expressions régulières, définissez les limites de mots et la sensibilité à la casse directement dans le System::Text::RegularExpressions::Regex.

La recherche et le remplacement peuvent‑ils inclure le texte des notes de diapositive ?

Oui. Appelez ITextSearchOptions::set_IncludeNotes avec true lors de l’utilisation d’une opération de texte littéral au niveau de la présentation. L’implémentation du callback présentée ci‑dessus associe une correspondance dans une note de diapositive à son numéro de diapositive parent.

Comment créer un rapport sans analyser la présentation une seconde fois ?

Passez une implémentation de IFindResultCallback à l’opération de mise en évidence ou de remplacement. Le callback reçoit chaque correspondance pendant l’exécution de l’opération, ce qui permet à l’application de stocker le texte source, le texte trouvé, la position, le cadre de texte et le numéro de diapositive dérivé pour un regroupement ou une exportation ultérieure.

Le remplacement du texte préserve‑t‑il son formatage ?

ITextFrame::ReplaceText et ITextFrame::ReplaceRegex modifient le texte correspondant à l’intérieur du cadre de texte existant et conservent le formatage de la portion environnante. Si une correspondance couvre des portions avec un formatage différent, inspectez le résultat pour vous assurer que le remplacement utilise le style souhaité.

Formater le texte d'une présentation en C++ Animer le texte PowerPoint en C++