Partager via

Modifier une diapositive vers une nouvelle position dans une présentation

  • Article

Cette rubrique montre comment utiliser les classes du Kit de développement logiciel (SDK) Open XML pour Office pour déplacer une diapositive vers une nouvelle position dans une présentation par programmation.

Obtention d’un objet Presentation

Dans le Kit de développement logiciel (SDK) Open XML, la classe PresentationDocument représente un package de documents de présentation. Pour utiliser un document de présentation, créez d’abord une instance de la classe PresentationDocument, puis utilisez cette instance. Pour créer la classe instance à partir du document, appelez la méthode Open(String, Boolean) qui utilise un chemin d’accès de fichier et une valeur booléenne comme deuxième paramètre pour spécifier si un document est modifiable. Pour pouvoir compter le nombre de diapositives d’une présentation, il est préférable d’ouvrir le fichier pour un accès en lecture seule de façon à éviter d’écrire accidentellement dans le fichier. Pour cela, spécifiez la valeur false pour le paramètre booléen, comme le montre l’instruction using suivante. Dans ce code, le paramètre presentationFile est une chaîne qui représente le chemin d’accès du fichier à partir duquel vous voulez ouvrir le document.

    // Open the presentation as read-only.
    using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, false))
    {
        // Insert other code here.
    }

L'instruction using offre une alternative recommandée pour la séquence .Open, .Save, .Close standard. Elle garantit que la méthode Dispose (méthode interne utilisée par le kit de développement Open XML pour nettoyer les ressources) est automatiquement appelée lorsque l'accolade de fermeture est atteinte. Le bloc qui suit l’instruction using établit une étendue pour l’objet créé ou nommé dans l’instruction using, dans le cas présent presentationDocument.

Structure de document de présentation de base

La structure de document de base d’un document PresentationML est constituée d’un certain nombre de composants, parmi lesquels le composant principal qui contient la définition de la présentation. Le texte suivant de la spécification ISO/IEC 29500 présente la forme globale d’un package PresentationML .

La partie main d’un package PresentationML commence par un élément racine de présentation. Cet élément contient une présentation qui, à son tour, fait référence à une liste de diapositives, à une liste de diapositives master, à une liste de notes master et à un document master liste. La liste des diapositives référence toutes les diapositives de la présentation ; la liste de masques de diapositive référence tous les masques de diapositive utilisés dans la présentation ; le masque de pages de note contient des informations sur la mise en forme des pages de notes et le masque de document décrit comment un document se présente.

Un document à distribuer est un ensemble imprimé de diapositives qui peut être distribué aux personnes de l’audience.

En plus de textes et de graphiques, chaque diapositive peut contenir des commentaires et des notes, peut avoir une disposition et peut faire partie d’une ou plusieurs présentations personnalisées. Un commentaire est une annotation destinée à la personne qui gère le jeu de diapositives de la présentation. Une note est un rappel ou un élément de texte destiné au présentateur ou à l’audience.

Les autres fonctionnalités qu’un document PresentationML peut inclure les suivantes : animation, audio, vidéo et transitions entre les diapositives.

Un document PresentationML n’est pas stocké sous la forme d’un corps de grande taille dans un même composant. Au lieu de cela, les éléments qui implémentent certains groupes de fonctionnalités sont stockés dans des composants distincts. Par exemple, tous les commentaires d’un document sont stockés dans un même composant Commentaires, alors que chaque diapositive a son propre composant.

© ISO/IEC29500: 2008.

L’exemple de code XML suivant représente une présentation qui contient deux diapositives ayant les numéros d’identification 267 et 256.

    <p:presentation xmlns:p="…" … > 
       <p:sldMasterIdLst>
          <p:sldMasterId
             xmlns:rel="https://…/relationships" rel:id="rId1"/>
       </p:sldMasterIdLst>
       <p:notesMasterIdLst>
          <p:notesMasterId
             xmlns:rel="https://…/relationships" rel:id="rId4"/>
       </p:notesMasterIdLst>
       <p:handoutMasterIdLst>
          <p:handoutMasterId
             xmlns:rel="https://…/relationships" rel:id="rId5"/>
       </p:handoutMasterIdLst>
       <p:sldIdLst>
          <p:sldId id="267"
             xmlns:rel="https://…/relationships" rel:id="rId2"/>
          <p:sldId id="256"
             xmlns:rel="https://…/relationships" rel:id="rId3"/>
       </p:sldIdLst>
           <p:sldSz cx="9144000" cy="6858000"/>
       <p:notesSz cx="6858000" cy="9144000"/>
    </p:presentation>

À 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 aux éléments PresentationML. Vous trouverez ces classes dans l’espace de noms DocumentFormat.OpenXml.Presentation . Le tableau suivant répertorie les noms des classes qui correspondent aux éléments sld, sldLayout, sldMaster et notesMaster.

Élément PresentationML Classe du Kit de développement logiciel (SDK) Open XML Description
Sld Slide Diapositive de présentation. Il s’agit de l’élément racine de SlidePart.
sldLayout SlideLayout Mise en page des diapositives. Il s’agit de l’élément racine de SlideLayoutPart.
sldMaster SlideMaster Masque des diapositives. Il s’agit de l’élément racine de SlideMasterPart.
Notesmaster NotesMaster Masque des pages de notes (ou handoutMaster). Il s’agit de l’élément racine de NotesMasterPart.

Fonctionnement de l’exemple de code

Pour pouvoir déplacer une diapositive spécifique d’un fichier de présentation à une nouvelle position, vous devez d’abord connaître le nombre de diapositives de la présentation. Le code de cette rubrique est donc divisé en deux parties. La première compte le nombre de diapositives et la seconde déplace une diapositive à une nouvelle position.

Comptage du nombre de diapositives

L’exemple de code pour le comptage du nombre de diapositives est constitué de deux surcharges de la méthode CountSlides. La première surcharge utilise un paramètre de chaîne et la deuxième surcharge utilise un paramètre PresentationDocument . Dans la première méthode CountSlides, l’exemple de code ouvre le document de présentation dans l’instruction using. Il passe ensuite l’objet PresentationDocument à la deuxième méthode CountSlides, qui retourne un nombre entier représentant le nombre de diapositives de la présentation.

    // Pass the presentation to the next CountSlides method
    // and return the slide count.
    return CountSlides(presentationDocument);

Dans la deuxième méthode CountSlides, le code vérifie que l’objet PresentationDocument passé n’est pas null et, si ce n’est pas le cas, obtient un objet PresentationPart à partir de l’objet PresentationDocument. À l’aide de SlideParts , le code obtient le slideCount et le retourne.

    // Check for a null document object.
    if (presentationDocument == null)
    {
        throw new ArgumentNullException("presentationDocument");
    }

    int slidesCount = 0;

    // Get the presentation part of document.
    PresentationPart presentationPart = presentationDocument.PresentationPart;

    // Get the slide count from the SlideParts.
    if (presentationPart != null)
    {
        slidesCount = presentationPart.SlideParts.Count();
    }
    // Return the slide count to the previous method.
    return slidesCount;

Déplacement d’une diapositive d’une position à une autre

Le déplacement d’une diapositive à une nouvelle position requiert l’ouverture du fichier pour un accès en lecture/écriture en spécifiant la valeur true pour le paramètre booléen, comme montré dans l’instruction using suivante. Le code pour déplacer une diapositive est constitué de deux surcharges de la méthode MoveSlide. La première méthode MoveSlide surchargée prend trois paramètres : une chaîne qui représente le nom et le chemin d’accès au fichier de présentation et deux entiers qui représentent respectivement la position d’index actuelle de la diapositive et la position d’index vers laquelle déplacer la diapositive. Il ouvre le fichier de présentation, obtient un objet PresentationDocument , puis transmet cet objet et les deux entiers, de et à, à la deuxième méthode MoveSlide surchargée, qui effectue le déplacement réel.

    // Move a slide to a different position in the slide order in the presentation.
    public static void MoveSlide(string presentationFile, int from, int to)
    {
        using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, true))
        {
            MoveSlide(presentationDocument, from, to);
        }
    }

Dans la deuxième méthode MoveSlide surchargée, la méthode CountSlides est appelée pour obtenir le nombre de diapositives de la présentation. Le code vérifie ensuite si les index (commençant à zéro) from et to sont dans la plage et sont différents l’un de l’autre.

    public static void MoveSlide(PresentationDocument presentationDocument, int from, int to)
    {
        if (presentationDocument == null)
        {
            throw new ArgumentNullException("presentationDocument");
        }

        // Call the CountSlides method to get the number of slides in the presentation.
        int slidesCount = CountSlides(presentationDocument);

        // Verify that both from and to positions are within range and different from one another.
        if (from < 0 || from >= slidesCount)
        {
            throw new ArgumentOutOfRangeException("from");
        }

        if (to < 0 || from >= slidesCount || to == from)
        {
            throw new ArgumentOutOfRangeException("to");
        }

Un objet PresentationPart est déclaré et défini comme étant égal au composant de présentation de l’objet PresentationDocument passé en entrée. L’objet PresentationPart est utilisé pour créer un objet Presentation, puis pour créer un objet SlideIdList qui représente la liste des diapositives de la présentation à partir de l’objet Presentation. Un ID de diapositive de la diapositive source (la diapositive à déplacer) est obtenu, puis la position de la diapositive cible (la diapositive après laquelle la diapositive source doit être déplacée) est identifiée.

    // Get the presentation part from the presentation document.
    PresentationPart presentationPart = presentationDocument.PresentationPart;

    // The slide count is not zero, so the presentation must contain slides.            
    Presentation presentation = presentationPart.Presentation;
    SlideIdList slideIdList = presentation.SlideIdList;

    // Get the slide ID of the source slide.
    SlideId sourceSlide = slideIdList.ChildElements[from] as SlideId;

    SlideId targetSlide = null;

    // Identify the position of the target slide after which to move the source slide.
    if (to == 0)
    {
        targetSlide = null;
    }
    else if (from < to)
    {
        targetSlide = slideIdList.ChildElements[to] as SlideId;
    }
    else
    {
        targetSlide = slideIdList.ChildElements[to - 1] as SlideId;
    }

La méthode Remove de l’objet SlideID est utilisé pour supprimer la diapositive source de sa position actuelle, puis la méthode InsertAfter de l’objet SlideIdList est utilisée pour insérer la diapositive source à la position d’index après la diapositive cible. Enfin, la présentation modifiée est enregistrée.

    // Remove the source slide from its current position.
    sourceSlide.Remove();

    // Insert the source slide at its new position after the target slide.
    slideIdList.InsertAfter(sourceSlide, targetSlide);

    // Save the modified presentation.
    presentation.Save();

Exemple de code

Voici l’exemple de code complet que vous pouvez utiliser pour déplacer par programme une diapositive d’une position à une autre dans le même fichier de présentation. Par instance, vous pouvez utiliser l’appel suivant dans votre programme pour déplacer une diapositive de la position 0 à la position 1 dans un fichier de présentation nommé « Myppt11.pptx ».

    MoveSlide(@"C:\Users\Public\Documents\Myppt11.pptx", 0, 1);

Après avoir exécuté le programme, examinez votre fichier de présentation pour voir les nouvelles positions des diapositives.

Voici l’exemple de code complet en C# et en Visual Basic.


using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Presentation;
using System;
using System.Linq;

CountSlides(args[0]);

// Counting the slides in the presentation.
static int CountSlides(string presentationFile)
{
    // Open the presentation as read-only.
    using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, false))
    {
        // Pass the presentation to the next CountSlides method
        // and return the slide count.
        return CountSlidesFromPresentation(presentationDocument);
    }
}

// Count the slides in the presentation.
static int CountSlidesFromPresentation(PresentationDocument presentationDocument)
{
    int slidesCount = 0;

    // Get the presentation part of document.
    PresentationPart? presentationPart = presentationDocument.PresentationPart;

    // Get the slide count from the SlideParts.
    if (presentationPart is not null)
    {
        slidesCount = presentationPart.SlideParts.Count();
    }

    // Return the slide count to the previous method.
    return slidesCount;
}

// Move a slide to a different position in the slide order in the presentation.
static void MoveSlide(string presentationFile, int from, int to)
{
    using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, true))
    {
        MoveSlideFromPresentation(presentationDocument, from, to);
    }
}
// Move a slide to a different position in the slide order in the presentation.
static void MoveSlideFromPresentation(PresentationDocument presentationDocument, int from, int to)
{
    if (presentationDocument is null)
    {
        throw new ArgumentNullException("presentationDocument");
    }

    // Call the CountSlides method to get the number of slides in the presentation.
    int slidesCount = CountSlidesFromPresentation(presentationDocument);

    // Verify that both from and to positions are within range and different from one another.
    if (from < 0 || from >= slidesCount)
    {
        throw new ArgumentOutOfRangeException("from");
    }

    if (to < 0 || from >= slidesCount || to == from)
    {
        throw new ArgumentOutOfRangeException("to");
    }

    // Get the presentation part from the presentation document.
    PresentationPart? presentationPart = presentationDocument.PresentationPart;

    // The slide count is not zero, so the presentation must contain slides.            
    Presentation? presentation = presentationPart?.Presentation;

    if (presentation is null)
    {
        throw new ArgumentNullException(nameof(presentation));
    }

    SlideIdList? slideIdList = presentation.SlideIdList;

    if (slideIdList is null)
    {
        throw new ArgumentNullException(nameof(slideIdList));
    }

    // Get the slide ID of the source slide.
    SlideId? sourceSlide = slideIdList.ChildElements[from] as SlideId;

    if (sourceSlide is null)
    {
        throw new ArgumentNullException(nameof(sourceSlide));
    }

    SlideId? targetSlide = null;

    // Identify the position of the target slide after which to move the source slide.
    if (to == 0)
    {
        targetSlide = null;
    }
    else if (from < to)
    {
        targetSlide = slideIdList.ChildElements[to] as SlideId;
    }
    else
    {
        targetSlide = slideIdList.ChildElements[to - 1] as SlideId;
    }

    // Remove the source slide from its current position.
    sourceSlide.Remove();

    // Insert the source slide at its new position after the target slide.
    slideIdList.InsertAfter(sourceSlide, targetSlide);

    // Save the modified presentation.
    presentation.Save();
}

Voir aussi