Accepter toutes les révisions dans un document de traitement de texte

Article
11/16/2023

Cette rubrique montre comment utiliser le Kit de développement logiciel (SDK) Open XML pour Office afin d’accepter toutes les révisions d’un document de traitement de texte par programme.

Structure d’un document WordProcessingML

La structure de base d’un document WordProcessingML se compose des éléments document et body , suivis d’un ou plusieurs éléments de niveau bloc tels que p, qui représente un paragraphe. Un paragraphe contient un ou plusieurs éléments r. Le r signifie « run » (exécution), qui est une zone de texte avec un ensemble de propriétés courant, comme par exemple la mise en forme. Une exécution contient un ou plusieurs éléments t. L'élément t contient une plage de texte. L’exemple de code suivant montre le balisage WordprocessingML pour un document qui contient le texte « Exemple de texte ».

    <w:document xmlns:w="https://schemas.openxmlformats.org/wordprocessingml/2006/main">
      <w:body>
        <w:p>
          <w:r>
            <w:t>Example text.</w:t>
          </w:r>
        </w:p>
      </w:body>
    </w:document>

À l’aide du Kit de développement logiciel (SDK) Open XML, vous pouvez créer une structure de document et du contenu à l’aide de classes fortement typées qui correspondent à des éléments WordprocessingML . Vous trouverez ces classes dans l'espace de noms DocumentFormat.OpenXml.Wordprocessing . Le tableau suivant répertorie les noms des classes qui correspondent aux éléments document, body, p, r et t.

Élément WordprocessingML	Classe du Kit de développement logiciel (SDK) Open XML	Description
document	Document	Élément racine de la partie principale du document.
body	Body	Conteneur des structures de niveau bloc, telles que paragraphs, tables, annotations et autres structures décrites dans la spécification ISO/IEC 29500.
p	Paragraph	Paragraphe.
r	Run	Exécution.
t	Text	Plage de texte.

Pour plus d’informations sur la structure globale des parties et éléments d’un document WordprocessingML, consultez Structure d’un document WordprocessingML.

    <w:document xmlns:w="https://schemas.openxmlformats.org/wordprocessingml/2006/main">
      <w:body>
        <w:p>
          <w:r>
            <w:t>Example text.</w:t>
          </w:r>
        </w:p>
      </w:body>
    </w:document>

Élément WordprocessingML	Classe du Kit de développement logiciel (SDK) Open XML	Description
document	Document	Élément racine de la partie principale du document.
body	Body	Conteneur des structures de niveau bloc, telles que paragraphs, tables, annotations et autres structures décrites dans la spécification ISO/IEC 29500.
p	Paragraph	Paragraphe.
r	Run	Exécution.
t	Text	Une plage de texte.

Élément ParagraphPropertiesChange

Lorsque vous acceptez une marque de révision, vous modifiez les propriétés d’un paragraphe en supprimant du texte existant ou bien en insérant un nouveau texte. Dans les sections suivantes, vous lisez les trois éléments utilisés dans le code pour modifier le contenu du paragraphe, principalement ( <w: pPrChange\> Informations de révision pour les propriétés de paragraphe), <w:del> (Paragraphe supprimé) et <w:ins> (Ligne de tableau insérée).

Les informations suivantes de la spécification ISO/IEC 29500 présentent l’élément ParagraphPropertiesChange (pPrChange).

*pPrChange (Informations de révision pour les propriétés de paragraphe)

Cet élément spécifie les détails concernant une révision apportée à un ensemble de propriétés de paragraphe dans un document WordprocessingML.

Cet élément stocke cette révision comme suit :

L’élément enfant de cet élément contient l’ensemble complet des propriétés de paragraphe qui ont été appliquées à ce paragraphe avant cette révision.
Les attributs de cet élément contiennent des informations sur le moment où cette révision a eu lieu (en d’autres termes, quand ces propriétés sont devenues un « ancien » ensemble de propriétés de paragraphe).

Considérons un paragraphe d’un document WordprocessingML qui est centré, et cette modification des propriétés du paragraphe fait l’objet d’un suivi en tant que révision. Cette révision sera spécifiée à l’aide du balisage WordprocessingML suivant.

    <w:pPr>
      <w:jc w:val="center"/>
      <w:pPrChange w:id="0" w:date="01-01-2006T12:00:00" w:author="Samantha Smith">
        <w:pPr/>
      </w:pPrChange>
    </w:pPr>

L’élément spécifie qu’il y a eu une révision apportée aux propriétés du paragraphe le 01/01/2006 par Samantha Smith, et le précédent ensemble de propriétés de paragraphe du paragraphe était un ensemble null (en d’autres termes, aucune propriété de paragraphe n’était présente sous l’élément). pPrpPrChange

Élément Deleted

Les informations suivantes de la spécification ISO/IEC 29500 introduisent l’élément Deleted (del).

del (Paragraphe supprimé)

Cet élément spécifie que la marque de paragraphe délimitant la fin d’un paragraphe dans un document WordprocessingML sera traitée comme étant supprimée (autrement dit, le contenu de ce paragraphe ne sera plus délimité par cette marque de paragraphe et sera combiné avec le paragraphe suivant ; ce contenu ne sera cependant pas marqué automatiquement comme étant supprimé) en tant que composant de la révision suivie.

Considérons un document constitué de deux paragraphes (chaque paragraphe étant délimité par un pied-de-mouche « ¶ ») :

Deux paragraphes chacun délimités par un sillon Si le caractère physique délimitant la fin du premier paragraphe est supprimé et que cette modification fait l’objet d’un suivi en tant que révision, les résultats suivants sont les suivants :

Deux paragraphes délimités par un seul sillon Cette révision est représentée à l’aide du wordprocessingML suivant :

    <w:p>
      <w:pPr>
        <w:rPr>
          <w:del w:id="0" … />
        </w:rPr>
      </w:pPr>
      <w:r>
        <w:t>This is paragraph one.</w:t>
      </w:r>
    </w:p>
    <w:p>
      <w:r>
        <w:t>This is paragraph two.</w:t>
      </w:r>
    </w:p>

L’élément del des propriétés de séquence pour la première marque de paragraphe spécifie que cette marque a été supprimée et que cette suppression a fait l’objet d’un suivi en tant que révision.

L’élément Inserted

Les informations suivantes de la spécification ISO/IEC 29500 présentent l’élément Inserted (ins).

ins (Ligne de tableau insérée)

Cet élément spécifie que la ligne de tableau parent sera traitée en tant que ligne insérée dont l’insertion a fait l’objet d’un suivi en tant que révision. Ce paramètre n’impliquera aucun état de révision à propos des cellules de tableau dans cette ligne ou de leur contenu (qui doit être marqué pour révision de façon indépendante), et affectera seulement la ligne de tableau elle-même.

Considérons un tableau de deux lignes par deux colonnes, où la deuxième ligne a été marquée comme étant insérée à l’aide d’une révision. Cette spécification peut être définie à l’aide du code WordprocessingML suivant :

    <w:tbl>
      <w:tr>
        <w:tc>
          <w:p/>
        </w:tc>
        <w:tc>
          <w:p/>
        </w:tc>
      </w:tr>
      <w:tr>
        <w:trPr>
          <w:ins w:id="0" … />
        </w:trPr>
        <w:tc>
          <w:p/>
        </w:tc>
        <w:tc>
          <w:p/>
        </w:tc>
      </w:tr>
    </w:tbl>

L’élément ins sur les propriétés de ligne de tableau pour la deuxième ligne du tableau spécifie que cette ligne a été insérée et que cette insertion a fait l’objet d’un suivi en tant que révision.

Exemple de code

L’exemple de code suivant montre comment accepter la totalité des révisions dans un document de traitement de texte. Pour exécuter le programme, vous pouvez transmettre le chemin d’accès au fichier et le nom de l’auteur :

dotnet run -- [filePath] [authorName]

Après avoir exécuté le programme, ouvrez le fichier de traitement de texte pour vous assurer que toutes les marques de révision ont été acceptées.

C#
Visual Basic

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using System;
using System.Collections.Generic;
using System.Linq;

AcceptAllRevisions(args[0], args[1]);

static void AcceptAllRevisions(string fileName, string authorName)
{
    using (WordprocessingDocument wdDoc = WordprocessingDocument.Open(fileName, true))
    {
        if (wdDoc.MainDocumentPart is null || wdDoc.MainDocumentPart.Document.Body is null)
        {
            throw new ArgumentNullException("MainDocumentPart and/or Body is null.");
        }

        Body body = wdDoc.MainDocumentPart.Document.Body;

        // Handle the formatting changes.
        List<OpenXmlElement> changes = body.Descendants<ParagraphPropertiesChange>()
            .Where(c => c.Author is not null && c.Author.Value == authorName).Cast<OpenXmlElement>().ToList();

        foreach (OpenXmlElement change in changes)
        {
            change.Remove();
        }

        // Handle the deletions.
        List<OpenXmlElement> deletions = body
            .Descendants<Deleted>()
            .Where(c => c.Author is not null && c.Author.Value == authorName)
            .Cast<OpenXmlElement>().ToList();

        deletions.AddRange(body.Descendants<DeletedRun>()
            .Where(c => c.Author is not null && c.Author.Value == authorName).Cast<OpenXmlElement>().ToList());

        deletions.AddRange(body.Descendants<DeletedMathControl>()
            .Where(c => c.Author is not null && c.Author.Value == authorName).Cast<OpenXmlElement>().ToList());

        foreach (OpenXmlElement deletion in deletions)
        {
            deletion.Remove();
        }

        // Handle the insertions.
        List<OpenXmlElement> insertions =
            body.Descendants<Inserted>()
            .Where(c => c.Author is not null && c.Author.Value == authorName).Cast<OpenXmlElement>().ToList();

        insertions.AddRange(body.Descendants<InsertedRun>()
            .Where(c => c.Author is not null && c.Author.Value == authorName).Cast<OpenXmlElement>().ToList());

        insertions.AddRange(body.Descendants<InsertedMathControl>()
            .Where(c => c.Author is not null && c.Author.Value == authorName).Cast<OpenXmlElement>().ToList());

        foreach (OpenXmlElement insertion in insertions)
        {
            // Found new content.
            // Promote them to the same level as node, and then delete the node.
            foreach (var run in insertion.Elements<Run>())
            {
                if (run == insertion.FirstChild)
                {
                    insertion.InsertAfterSelf(new Run(run.OuterXml));
                }
                else
                {
                    OpenXmlElement nextSibling = insertion.NextSibling()!;
                    nextSibling.InsertAfterSelf(new Run(run.OuterXml));
                }
            }

            insertion.RemoveAttribute("rsidR", "https://schemas.openxmlformats.org/wordprocessingml/2006/main");
            insertion.RemoveAttribute("rsidRPr", "https://schemas.openxmlformats.org/wordprocessingml/2006/main");
            insertion.Remove();
        }
    }
}

Imports DocumentFormat.OpenXml
Imports DocumentFormat.OpenXml.Packaging
Imports DocumentFormat.OpenXml.Wordprocessing

Module Program
    Sub Main(args As String())
        Dim fileName = args(0)
        Dim authorName = args(1)

        'Public Sub AcceptRevisions(ByVal fileName As String, ByVal authorName As String)
        ' Given a document name and an author name, accept revisions. 
        Using wdDoc As WordprocessingDocument = WordprocessingDocument.Open(fileName, True)
            Dim body As Body = wdDoc.MainDocumentPart.Document.Body

            ' Handle the formatting changes.
            Dim changes As List(Of OpenXmlElement) =
                body.Descendants(Of ParagraphPropertiesChange)() _
                .Where(Function(c) c.Author.Value = authorName).Cast(Of OpenXmlElement)().ToList()

            For Each change In changes
                change.Remove()
            Next

            ' Handle the deletions.
            Dim deletions As List(Of OpenXmlElement) =
                body.Descendants(Of Deleted)() _
                .Where(Function(c) c.Author.Value = authorName).Cast(Of OpenXmlElement)().ToList()

            deletions.AddRange(body.Descendants(Of DeletedRun)() _
            .Where(Function(c) c.Author.Value = authorName).Cast(Of OpenXmlElement)().ToList())

            deletions.AddRange(body.Descendants(Of DeletedMathControl)() _
            .Where(Function(c) c.Author.Value = authorName).Cast(Of OpenXmlElement)().ToList())

            For Each deletion In deletions
                deletion.Remove()
            Next

            ' Handle the insertions.
            Dim insertions As List(Of OpenXmlElement) =
                body.Descendants(Of Inserted)() _
                .Where(Function(c) c.Author.Value = authorName).Cast(Of OpenXmlElement)().ToList()

            insertions.AddRange(body.Descendants(Of InsertedRun)() _
            .Where(Function(c) c.Author.Value = authorName).Cast(Of OpenXmlElement)().ToList())

            insertions.AddRange(body.Descendants(Of InsertedMathControl)() _
            .Where(Function(c) c.Author.Value = authorName).Cast(Of OpenXmlElement)().ToList())

            For Each insertion In insertions
                ' Found new content. Promote them to the same level as node, and then
                ' delete the node.
                For Each run In insertion.Elements(Of Run)()
                    If run Is insertion.FirstChild Then
                        insertion.InsertAfterSelf(New Run(run.OuterXml))
                    Else
                        insertion.NextSibling().InsertAfterSelf(New Run(run.OuterXml))
                    End If
                Next
                insertion.RemoveAttribute("rsidR", "https://schemas.openxmlformats.org/wordprocessingml/2006/main")
                insertion.RemoveAttribute("rsidRPr", "https://schemas.openxmlformats.org/wordprocessingml/2006/main")
                insertion.Remove()
            Next
        End Using
    End Sub
End Module

Voir aussi

Informations de référence sur la bibliothèque de classes du Kit de développement logiciel (SDK) Open XML

Partager via