XPS page event-based modifications | .NET

What is the event-based approach in programming?

The event-based approach in programming is a paradigm that revolves around the concept of events and event handling. In this model, the flow of the program is determined by events, which can be user actions (like mouse clicks or key presses), system-generated notifications, or messages from other applications. Here are some key aspects of the event-based approach:

• Events: Events represent significant occurrences in a program. These can include user interactions, changes in data, or messages from other parts of a system. For example, a button click or a file being loaded can trigger events.

• Event Listeners: To respond to events, programmers use event listeners (or handlers). These are functions or methods that are defined to execute when a specific event occurs. For instance, an event listener can be set up to execute a function when a user clicks a button.

• Asynchronous Execution: The event-based model often supports asynchronous programming, allowing programs to remain responsive while waiting for events to occur. For example, a web application can continue to operate while waiting for data from a server.

• Decoupling: The event-based approach promotes decoupling between different parts of a program. Components can communicate through events without needing to know the details of each other’s implementation, making the code more modular and easier to maintain.

• Common Use Cases: Event-driven programming is widely used in graphical user interfaces (GUIs), web applications, and systems that require real-time interactions. Frameworks and libraries like Node.js, React, and many others utilize event-driven patterns.

• State Management: In an event-driven system, managing the state can be crucial since the application can be in different states depending on user interactions or events. Proper state management strategies are often employed to ensure the application behaves as expected.

Overall, the event-based approach is a powerful way to manage interactions and workflows within a program, making it particularly effective for applications that require responsiveness and user interaction.

Events that occur during the XPS document conversion

When you need to make changes to a specific page of an XPS document using the Aspose.Page API, you typically select the active document (if there are multiple documents in the XPS file), select the active page, and then make the changes themselves.

Now, suppose you need to make repeating changes to all pages in an XPS file and then convert the result to PDF or an image format. Some examples of such changes include placing a watermark over the pages or adding navigation hyperlinks. The direct way to make such changes involves traversing through the documents in the XPS package, traversing through the pages in the current active document, and then, finally, applying your changes. Therefore, the code to accomplish this task would look as follows:

for (int i = 1; i <= document.DocumentCount; i++)
{
    document.SelectActiveDocument(i);
    for (j = 1; j <= document.PageCount; j++)
    {
        document.SelectActivePage(j);
        // Your changes ...
    }
}
document.SaveAsPdf("file-name.pdf", saveOptions);

If you also need to make some irregular changes before the repeating ones, this approach may lead to some confusion or excessive traversals through documents and pages, let alone these loops may seem a little cumbersome.

When you convert an XPS document to PDF or an image, the process occurs page by page. When the conversion job is ready to process the next page, it triggers a “before-page” event. The user can define the handling of such events by extending the BeforePageSavingEventHandler class, thereby taking advantage of some benefits outlined in the introductory section of this article.

Adding navigation hyperlinks example

Here, we will provide an example related to the case of navigation hyperlinks. And to make the task a little more complicated, we will convert only a subset of all pages to PDF, as specified by the PdfSaveOptions.PageNumbers property.

The event handler class

Below is the extension of the BeforePageSavingEventHandler class:

/// <summary>
/// The class to handle the before-page event while converting an XPS document.
/// </summary>
public class NavigationInjector : BeforePageSavingEventHandler
{
    // The font in which navigation hyperlinks and page numbers will be displayed.
    private readonly XpsFont _font;
    // The page numbers to convert.
    private readonly SortedList<int, int> _pageNumbers;

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

        // Turn the page number array into a sorted collection of unique values.
        _pageNumbers = new SortedList<int, int>();
        foreach (int pn in pageNumbers)
            _pageNumbers[pn] = 0;
    }

    public override void Handle(BeforeSavingEventArgs<PageAPI> args)
    {
        PageAPI api = args.ElementAPI;

        XpsGlyphs glyphs;
        // For all pages in the output PDF except the first one...
        if (args.OutputPageNumber > 1)
        {
            // ...insert a hyperlink to the first page...
            glyphs = api.CreateGlyphs(_font, 15f, 5f, api.Height - 10f, "[First]");
            glyphs.Fill = api.CreateSolidColorBrush(Color.Blue);
            glyphs.HyperlinkTarget = new XpsPageLinkTarget(_pageNumbers == null ? 1 : _pageNumbers.Keys[0]);
            api.Add(glyphs);

            // ...and to the previous page.
            glyphs = api.CreateGlyphs(_font, 15f, 60f, api.Height - 10f, "[Prev]");
            glyphs.Fill = api.CreateSolidColorBrush(Color.Blue);
            glyphs.HyperlinkTarget = new XpsPageLinkTarget(
                _pageNumbers == null ? args.AbsolutePageNumber - 1 : _pageNumbers.Keys[args.OutputPageNumber - 2]);
            api.Add(glyphs);
        }

        // For all pages in the output PDF except the last one...
        if ((_pageNumbers != null && args.OutputPageNumber < _pageNumbers.Count) ||
            (_pageNumbers == null && args.OutputPageNumber < api.TotalPageCount))
        {
            // ...insert a hyperlink to the next page...
            glyphs = api.CreateGlyphs(_font, 15f, 110f, api.Height - 10f, "[Next]");
            glyphs.Fill = api.CreateSolidColorBrush(Color.Blue);
            glyphs.HyperlinkTarget = new XpsPageLinkTarget(
                _pageNumbers == null ? args.AbsolutePageNumber + 1 : _pageNumbers.Keys[args.OutputPageNumber]);
            api.Add(glyphs);

            // ...and to the last page.
            glyphs = api.CreateGlyphs(_font, 15f, 160f, api.Height - 10f, "[Last]");
            glyphs.Fill = api.CreateSolidColorBrush(Color.Blue);
            glyphs.HyperlinkTarget = new XpsPageLinkTarget(
                _pageNumbers == null ? api.TotalPageCount : _pageNumbers.Keys[_pageNumbers.Keys.Count - 1]);
            api.Add(glyphs);
        }

        // Insert a page number in the bottom-right corner.
        glyphs = api.CreateGlyphs(_font, 15f, api.Width - 20f, api.Height - 10f, args.OutputPageNumber.ToString());
        glyphs.Fill = 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(string.Format("Page {0}", args.OutputPageNumber), 1, args.AbsolutePageNumber);
    }
}

The handler class should be aware of the pages we want to save as PDF in order to create the correct hyperlink targets. Therefore, the constructor should take the options’ array property as an argument. If the array of page numbers is specified, we create a sorted collection of them, avoiding duplicates at the same time. (By the way, this solution is not entirely accurate. Can you figure out what might cause inconsistency in the output?) We will also need an XpsFont object containing the font data for the hyperlink text.

The overridden Handle() method is where it all happens. The method’s argument is an object that contains the modification API for the current page, the document number within the XPS package, the absolute page number across all documents, the relative page number within the current document (which is equal to the previous number in case of only one document in the package), and the output page number (which is equal to the absolute page number when we convert the entire package).

The logic of the following two if blocks is quite straightforward. It is based on the analysis of the OutputPageNumber event argument to omit some of the links where appropriate: the [First] and [Prev] links will be added to all output pages except the first one, while the [Next] and [Last] links will appear on all pages except the last one. The logic is also tailored for both cases, whether page numbers are specified or not.

After the if blocks, there is code for adding a page number in the bottom-right corner of the page.

The last line adds the page’s outline entry, the item that will be displayed in the navigation pane of a PDF viewer (if supported).

The conversion code

Now that the “before-page” event handler is defined, we can write the code that converts the document:

// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_WorkingWithPages();
// Open an XPS document
using (XpsDocument doc = new XpsDocument(dataDir + "Sample3.xps"))
// Create a font
using (Stream fontStream = File.OpenRead(dataDir + "arialbd.ttf"))
{
    // Create options for conversion to PDF
    PdfSaveOptions options = new PdfSaveOptions();
    // Set the filter for the pages that need conversion
    options.PageNumbers = new int[] { 2, 6, 7, 13 };
    // Add the event handler that will execute right before the conversion of each page
    options.BeforePageSavingEventHandlers.Add(new NavigationInjector(doc.CreateFont(fontStream), options.PageNumbers));
    // Save resultant XPS document
    doc.SaveAsPdf(dataDir + "ModifyPageOnConversion_out.pdf", options);
}

We open an XPS file and then instantiate a stream object with the font data file. Next, we create an instance of the PdfSaveOptions class and specify the numbers of pages we need to convert. The next line is where the “before-page” event handler becomes “connected” to the conversion job via the BeforePageSavingEventHandlers collection option.

All that’s left to do is run the conversion to PDF using the document’s SaveAsPdf() method.

Conclusion

In this article, we explored the key points of the event-based approach in programming, examined the direct method for modifying pages of an XPS document, and learned a more advanced and sophisticated technique for making repeating changes to all output pages during the conversion process, using the insertion of navigation hyperlinks as an example.

For the complete examples, explore our Example project.