A Photo Slideshow Presentation Using the Open XML SDK 2.0

By Phillip Wong

1    INTRODUCTION

The recent Open XML Format SDK 2.0 aims to give coders an easier life dealing with the Open XML document format, abstracting away the complexity of the XML, and giving coders a nicer, strongly-typed method of interacting with the innards of Open XML documents. It also gives access to some useful tools which we will be using. You can download the Open XML Format SDK here.

Slide generated by the PhotoParser application

I aimed to take advantage of these features when creating the (admittedly unimaginatively named) PhotoParser application, a small command-line tool for crawling a directory of images (e.g. holiday snaps from a digital camera) in JPEG format, and creating a slick PowerPoint slideshow to display each photo alongside a table of EXIF metadata displaying more information about the photo. In this article I show how using the Open XML Format SDK 2.0 (and its included tools) makes generating and manipulating the content of a PowerPoint document easy. The article focuses on the parts of the application that utilise the Open XML SDK. For the full code, please download the source.

2      CODE SAMPLE STRUCTURE

The complete Visual Studio 2008 solution (inside /PhotoParser-src) is included in this code sample, along with a pre-compiled sample binary (inside /PhotoParser-bin).

The VS2008 solution for the PhotoParser itself comprises of the following classes:

• Program.cs: The command-line application.
• OpenXML/Template.cs: The Document Reflector generated code of our created PowerPoint template.
• OpenXML/PhotoSlideGenerator.cs: The code for creating and changing the content of the template’s slides.
• Exif/ExifMetadata.cs: The code for extracting certain image EXIF metadata from the JPEG photos.

The DocumentFormat.OpenXml.dll assembly is also included with the binary version of the application, along with a directory of some photos you can use to test the application out. A Readme file is included detailing how the command-line application is executed.

3      USING A TEMPLATE

Rather than having to create an entire presentation document from scratch, we will use a PowerPoint document as the basis of our slideshow. This does mean you will need access to PowerPoint or a similar Open XML application in order to create the template.

3.1      Designing in PowerPoint

The first step is to fire up PowerPoint and create the basic template for the slides. For PhotoParser’s template, each slide merely consists of:

• A single image placeholder for the photos (taking up most of the slide’s real-estate);
• A table filled with a bunch of text placeholders (which I named #Exif1# - #Exif12#). These text placeholders will be replaced with extracted EXIF metadata from each photo.

Once you’ve created the template, save it somewhere as a .pptx. My template for PhotoParser is included in the download if you prefer to use that.

The template used for PhotoParser.

3.2      Document Reflector

One of the tools that the Open XML Format SDK v2.0 provides is the Document Reflector, which can be found in the Open XML Format SDK\V2.0\tools\ directory. This tool takes an existing Open XML document and automatically generates the C# code for creating and saving that document. The generated code can either be viewed on screen or exported to a file.

The Document Reflector tool.

If we run it on our template .pptx file, we get code that looks (in part) like the following:

Admittedly, not the prettiest code to look at. However, this generated class provides a CreatePackage(string filePath) method that performs what would be, by far, the most time consuming part of the application to code: creating the presentation document and its structure. This is an incredibly helpful use for Document Reflector, and makes the whole process of Open XML document generation very straight-forward.

For PhotoParser, I exported the document generation code from Document Reflector into its own class file: Template.cs. Apart from changing the namespace (PhotoParser.OpenXML) and the class name (Template), there was no need to touch this code ever again!

Note: You may encounter an “Inconsistent Line Endings” dialog when importing the exported .cs file into Visual Studio. I found that this tends to happen when the generated code contains Base64 encoded data (e.g. images), though it may occur in other cases. Simply say ‘Yes’ to use default CRLF encoding.

4   GENERATING THE CONTENT

At this point we have a template from which we can create PowerPoint documents with our designed “look and feel”, just by using the following code:

This creates a copy of our template presentation and saves it to a specified file path. We then reopen up the file so we can make our modifications. Now we just need to make the new slides for the photos.

4.1      Creating New Slides

We can create these slides by cloning the existing slide within the template presentation and changing the placeholders.

This simply calls the AddNewSlide method, which performs the actual slide creation, and then calls the Save() method on the presentation, which saves all the changes made to the presentation document file.

The AddNewSlide method takes an image location and creates a slide for that image in the given presentation. To do this, we first use the template slide that exists in the template presentation and make a clone of its contents using the FeedData method to create the new slide. As we want all the slides to be using the same design/layout as the template slide, we simply attach the template’s SlideLayout to the new slide as well.

4.2      Changing the Placeholders

Now we just need to swap out the template placeholders with some actual content. To do this, we create a new ImagePart of JPEG type and assign it a new reference id. We can again use FeedData to set the content of the new ImagePart to the filestream of a given image. The brilliant thing is that when this slide is then saved, the Open XML SDK will automatically write out that image into the package structure automatically, no need to write code to copy files around.

After changing the content, we also need to change all the references in the slide’s xml (which, if you recall, is simply a complete copy of the template slide’s xml), to point at our new ImagePart. To do this we can use Microsoft Language Integrated Query (LINQ) to query the slide’s descendant objects for a Blip object, a DocumentFormat.OpenXml.Drawing class which is used to store the embedded image reference. Once we have the Blip object, setting the Embed id reference to that of the ImagePart is straight-forward.

Finally, as the images tend to have different sizes, orientations, aspect ratios etc. it is probably necessary to re-centre the image so that the slide stays looking pretty. We can use LINQ here again to gain access to the various elements of the slide and use their offsets and sizes to calculate the new image position. The following code resizes the image, keeping the aspect ratio of the image intact and determining the new width to use. It then centres the image in the middle of the slide horizontally and between the top of the slide and the bottom table vertically:

The text placeholders within our templates table are even easier to replace, again using LINQ. We simply find a text field with the placeholder’s value and then replace that text with another string.

We use the helper methods defined in the ExifMetadata class to extract the photo information and swap them with the placeholders in the template slides, as follows:

4.3      Sidetrack: Extracting EXIF Data

I had to make a number of helper methods for extracting a small amount of EXIF metadata from a BitmapMetadata object which are contained in ExifMetadata.cs. The BitmapMetadata class itself provides direct access to some EXIF (and non-EXIF) metadata through properties: ApplicationName, Author, CameraManufacturer, CameraModel, Comment, Copyright, DateTaken, Keywords, Location, Rating, Subject, and Title. Obtaining this information is pretty straight-forward, as shown in the GetDateTaken method:

However, for any other EXIF metadata information, it is necessary to use the GetQuery method to retrieve it, and then handle the returned result appropriately. In PhotoParser, I use the following method to query metadata from an image and return it as an object:

Dealing with EXIF data can be troublesome, as it requires knowledge of specific tag numbers identifying each piece of information, knowledge of the construction of the query path (e.g. whether it exists in exif or in subifd subpaths), as well as the creation of several methods for handling the expected result type (e.g. rational). Even more methods are needed if you want to convert from the EXIF stored types to more “useful” units (e.g. APEX to f-stop).

I would highly recommend using an already existing EXIF library to handle all these nuances, and if you really want to do-it-yourself, the specification available at http://www.exif.org is probably the best reference.

An example of a helper method using a query is shown in the following GetDimensions method, which gets the Width (EXIF tag 40962) and Height (EXIF tag 40963) of an image and formats it into a string for display:

4.4      Completing the Slide and Presentation

We’ve now changed all the content of the slide, and all that’s left is to save the changes and place the new slide into the presentations list of slides. Saving any part of a document writes its contents out to file.

Once we’ve done this process for each photo, we need to delete the template slide from the document. This is easy since we know the reference id for this slide from the Document Reflector generated code, and so it can be removed using the following code:

...And we’re all done!

5    BONUS: MAKING AN ALTERNATIVE TEMPLATE 

 

Our alternate template for PhotoParser

I exported this template using Document Reflector to TemplateAlternate.cs, and made the following changes to the code:

·         Program.cs: To make the program use the alternate template.

·         PhotoSlideGenerator: To change the image re-centring code in order to centre the photos to the middle of the slide vertically, and between the right-edges of the table and the slide horizontally.

And that’s it! The app will now create a slideshow using the alternate template.

Slide generated by PhotoParser using the alternate template

6     Conclusion