Modification de la page XPS sur les événements | Java

Comprendre l’approche événementielle en programmation

L’approche événementielle en programmation est un paradigme axé sur les événements et leur gestion. Dans ce modèle, le flux du programme est dicté par des événements, qui peuvent inclure des actions de l’utilisateur (telles que des clics de souris ou des pressions sur des touches), des notifications générées par le système ou des messages provenant d’autres applications. Vous trouverez ci-dessous quelques aspects clés de l’approche événementielle :

• Événements : les événements signifient des événements importants au sein d’un programme. Ceux-ci peuvent englober les interactions des utilisateurs, les modifications de données ou les messages provenant de différents composants d’un système. Par exemple, un clic sur un bouton ou le chargement d’un fichier peut déclencher des événements.

• Écouteurs d’événements : pour gérer les événements, les programmeurs emploient des écouteurs d’événements (ou gestionnaires). Il s’agit de fonctions ou de méthodes désignées pour s’exécuter lorsqu’un événement particulier se produit. Par exemple, un écouteur d’événements peut être configuré pour exécuter une fonction lorsqu’un utilisateur clique sur un bouton.

• Exécution asynchrone : le modèle basé sur les événements facilite généralement la programmation asynchrone, permettant aux programmes de maintenir leur réactivité en attendant les événements. Par exemple, une application Web peut continuer à fonctionner pendant qu’elle attend les données d’un serveur.

• Découplage : l’approche basée sur les événements encourage le découplage entre les différentes composantes d’un programme. Ces composants peuvent interagir via des événements sans nécessiter de connaissance des détails d’implémentation de chacun, ce qui donne lieu à un code plus modulaire et plus maintenable.

• Cas d’utilisation courants : la programmation basée sur les événements est couramment utilisée dans les interfaces utilisateur graphiques (GUI), les applications Web et les systèmes qui nécessitent des interactions en temps réel. Les frameworks et bibliothèques tels que Node.js, React et bien d’autres exploitent des modèles basés sur les événements.

• Gestion des états : dans un système piloté par événements, une gestion efficace des états est essentielle, car l’application peut exister dans différents états en fonction des interactions ou des événements de l’utilisateur. Des stratégies de gestion d’état appropriées sont généralement mises en œuvre pour garantir que l’application fonctionne comme prévu.

Dans l’ensemble, l’approche basée sur les événements est une méthode efficace pour gérer les interactions et les flux de travail au sein d’un programme, ce qui la rend particulièrement adaptée aux applications qui exigent de la réactivité et des interactions avec les utilisateurs.

La conversion et les événements du document XPS

Lorsque vous devez modifier une page spécifique d’un document XPS à l’aide de l’API Aspose.Page, vous sélectionnez généralement le document actif (s’il existe plusieurs documents dans le fichier XPS), sélectionnez la page active, puis appliquez les modifications.

Supposons maintenant que vous deviez implémenter des modifications répétitives sur toutes les pages d’un fichier XPS, puis convertir le résultat au format PDF ou image. Des exemples de tels changements peuvent inclure l’ajout d’un filigrane aux pages ou l’insertion d’hyperliens de navigation. La méthode simple pour effectuer de telles modifications consiste à parcourir les documents du package XPS, à parcourir les pages du document actif actuel, puis, enfin, à appliquer vos modifications. Ainsi, le code pour réaliser cette tâche ressemblerait à ceci :

for (int i = 1; i <= document.getDocumentCount(); i++)
{
    document.selectActiveDocument(i);
    for (j = 1; j <= document.getPageCount(); j++)
    {
        document.selectActivePage(j);
        // Your changes ...
    }
}
document.saveAsPdf("file-name.pdf", saveOptions);

Si vous devez également apporter des modifications irrégulières avant d’appliquer les modifications répétitives, cette approche peut entraîner une confusion ou des parcours excessifs dans les documents et les pages. De plus, ces boucles peuvent paraître quelque peu encombrantes. Lorsque vous convertissez un document XPS en PDF ou en image, le processus se déroule page par page. Lorsque la tâche de conversion se prépare à traiter la page suivante, elle déclenche un événement « avant la page ». L’utilisateur peut définir le comportement (gestion des événements) sur de tels événements en étendant la classe BeforePageSavingEventHandler, tirant ainsi parti de certains des avantages évoqués dans la section d’introduction de cet article.

Exemple d’ajout d’hyperliens de navigation

Dans cette section, nous présenterons un exemple impliquant des hyperliens de navigation. Et pour rendre la tâche un peu plus compliquée, nous allons convertir uniquement un sous-ensemble de toutes les pages en PDF, tel que défini par la méthode PdfSaveOptions.setPageNumbers().

La classe du gestionnaire d’événements

Ci-dessous se trouve l’extension de la classe BeforePageSavingEventHandler :

/**
 * The class to handle the before-page event while converting an XPS document.
 */
public static class NavigationInjector extends BeforePageSavingEventHandler
{
    private final XpsFont _font;
    private List<Integer> _pageNumbers;

    public NavigationInjector(XpsFont font, int[] pageNumbers)
    {
        _font = font;
        if (pageNumbers == null || pageNumbers.length == 0)
            return;

        // Turn the page number array into a sorted collection of unique values.
        SortedMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
        for (int pn : pageNumbers)
            map.put(pn, 0);
        _pageNumbers = new ArrayList<Integer>(map.keySet());
    }

    /**
     * The action itself to be triggered on a before-page event.
     * @param args The even arguments.
     */
    @Override
    public void handle(BeforeSavingEventArgs<PageAPI> args)
    {
        PageAPI api = args.getElementAPI();

        XpsGlyphs glyphs;
        // For all pages in the output PDF except the first one...
        if (args.getOutputPageNumber() > 1)
        {
          // ...insert a hyperlink to the first page...
            glyphs = api.createGlyphs(_font, 15f, 5f, api.getHeight() - 10f, "[First]");
            glyphs.setFill(api.createSolidColorBrush(Color.BLUE));
            glyphs.setHyperlinkTarget(new XpsPageLinkTarget(_pageNumbers == null ? 1 : _pageNumbers.get(0)));
            api.add(glyphs);

            // ...and to the previous page.
            glyphs = api.createGlyphs(_font, 15f, 60f, api.getHeight() - 10f, "[Prev]");
            glyphs.setFill(api.createSolidColorBrush(Color.BLUE));
            glyphs.setHyperlinkTarget(new XpsPageLinkTarget(
                _pageNumbers == null ? args.getAbsolutePageNumber() - 1 : _pageNumbers.get(args.getOutputPageNumber() - 2)));
            api.add(glyphs);
        }

        // For all pages in the output PDF except the last one...
        if ((_pageNumbers != null && args.getOutputPageNumber() < _pageNumbers.size()) ||
            (_pageNumbers == null && args.getOutputPageNumber() < api.getTotalPageCount()))
        {
          // ...insert a hyperlink to the next page...
            glyphs = api.createGlyphs(_font, 15f, 110f, api.getHeight() - 10f, "[Next]");
            glyphs.setFill(api.createSolidColorBrush(Color.BLUE));
            glyphs.setHyperlinkTarget(new XpsPageLinkTarget(
                _pageNumbers == null ? args.getAbsolutePageNumber() + 1 : _pageNumbers.get(args.getOutputPageNumber())));
            api.add(glyphs);

            // ...and to the last page.
            glyphs = api.createGlyphs(_font, 15f, 160f, api.getHeight() - 10f, "[Last]");
            glyphs.setFill(api.createSolidColorBrush(Color.BLUE));
            glyphs.setHyperlinkTarget(new XpsPageLinkTarget(
                _pageNumbers == null ? api.getTotalPageCount() : _pageNumbers.get(_pageNumbers.size() - 1)));
            api.add(glyphs);
        }

        // Insert a page number in the bottom-right corner.
        glyphs = api.createGlyphs(_font, 15f, api.getWidth() - 20f, api.getHeight() - 10f, Integer.toString(args.getOutputPageNumber()));
        glyphs.setFill(api.createSolidColorBrush(Color.BLACK));
        api.add(glyphs);

        // Add an outline entry to display the links to the converted pages in the navigation pane of a PDF viewer.
        api.addOutlineEntry(MessageFormat.format("Page {0}", args.getOutputPageNumber()), 1, args.getAbsolutePageNumber());
    }
}

La classe de gestionnaire doit connaître les pages que nous avons l’intention d’enregistrer au format PDF afin d’établir les cibles de liens hypertexte correctes. Par conséquent, le constructeur doit prendre la propriété de tableau des options getPageNumbers() comme argument. Si le tableau des numéros de page est fourni, nous créons une collection triée de ceux-ci, excluant en même temps les doublons. De plus, la classe a besoin d’un objet « XpsFont » qui contient les données de police pour le texte du lien hypertexte.

La méthode handle() remplacée est l’endroit où tout se passe. L’argument de la méthode est un objet qui contient l’API de modification pour la page actuelle, le numéro du document dans le package XPS, le numéro de page absolu dans tous les documents, le numéro de page relatif dans le document actuel (qui est égal au numéro précédent s’il n’y a qu’un seul document dans le package), et le numéro de page de sortie (qui est égal au numéro de page absolu lorsque nous convertissons l’ensemble du package).

La logique des deux blocs « if » suivants est assez simple. Il analyse l’argument de l’événement getOutputPageNumber() pour omettre certains liens le cas échéant : les liens [First] et [Prev] ne seront pas ajoutés à la première page, tandis que les [Next] et ` Les liens [Dernier] n’apparaîtront pas sur la dernière page. La logique est également conçue pour s’adapter aux deux scénarios, que les numéros de page soient spécifiés ou non.

Après les blocs « if », il y a du code qui ajoute un numéro de page dans le coin inférieur droit de la page.

La dernière ligne ajoute l’entrée de plan de la page, qui est l’élément qui sera affiché dans le volet de navigation d’une visionneuse PDF (si pris en charge).

Code de conversion

Maintenant que le gestionnaire d’événements “page avant” est défini, nous pouvons écrire le code pour la conversion du document :

// For complete examples and data files, please go to https://github.com/aspose-page/Aspose.Page-for-Java
// The path to the documents directory.
String dataDir = Utils.getDataDir();
String fontDir = dataDir + "necessary_fonts/";
// Open an XPS Document
final XpsDocument doc = new XpsDocument(dataDir + "Sample3.xps");
try {
  // Create a font
  final InputStream fontStream = new FileInputStream(fontDir + "arialbd.ttf");
  try {
    // Create options for conversion to PDF
    PdfSaveOptions options = new PdfSaveOptions();
    // Set the filter for the pages that need conversion
    options.setPageNumbers(new int[] { 2, 6, 7, 13 });
    // Add the event handler that will execute right before the conversion of each page
    options.getBeforePageSavingEventHandlers().add(new NavigationInjector(doc.createFont(fontStream), options.getPageNumbers()));
    // Save resultant XPS document
    doc.saveAsPdf(dataDir + "ModifyPageOnConversion_out.pdf", options);
  } finally {
    if (fontStream != null)
      fontStream.close();
  }
} finally {
  if (doc != null)
    doc.close();
}

Nous ouvrons un fichier XPS puis créons un objet flux avec le fichier de données de police. Ensuite, nous instancions la classe PdfSaveOptions et spécifions les numéros de page que nous devons convertir. La ligne suivante “connecte” le gestionnaire d’événements “before-page” au travail de conversion via la collection getBeforePageSavingEventHandlers().

Il ne reste plus qu’à exécuter la conversion en PDF en utilisant la méthode saveAsPdf() du document.

Conclusion

Dans cet article, nous avons couvert les aspects fondamentaux de l’approche basée sur les événements en programmation, examiné la méthode directe de modification des pages d’un document XPS et exploré une technique plus avancée pour apporter des modifications répétitives à toutes les pages de sortie pendant le processus de conversion. , en prenant comme exemple l’insertion d’hyperliens de navigation.

Pour les exemples complets, explorez notre Exemple de projet.