Brian Jones & Zeyad Rajabi: Office Solutions

Announcing the Release of the December 2009 CTP for the Open XML SDK

2009-12-14T23:09:00Z

I'm really happy to announce the 4^th CTP for the Open XML SDK 2.0 for Microsoft Office! There were four major improvements we made to the SDK:

Full support for the Office 2010 Open XML formats
Office 2010 schema and semantic level validation
General improvements based on a recent Open XML SDK usability study
Open XML SDK tools improvement

Full Support for the Office 2010 Open XML Formats

With the latest CTP you are able to create, edit, and consume Office generated Open XML formats for either Office 2007 or Office 2010. Looking back at the original Open XML SDK architecture diagram I showed you when we first announced the Open XML SDK, we have extended the base level layer to include Office 2010 support:

What does that mean? Well, let me show you some examples.

The Open XML Packaging API component allows you to add/remove parts within an Open XML package. This component functions by providing you strongly typed classes for every part within a package. In Office 2010 we've added new parts to the package in order to support some of our new features. With this CTP you are able to deal with these new parts with classes. For example, Word 2010 added a new part called stylesWithEffects. This part is used to help round trip styles that are based on Word's new text effects feature.

The Open XML Low Level DOM component allows you to create, edit, or consume xml contained in parts contained within an Open XML package. Like the packaging API component, this component functions by providing you with strongly typed classes for every element supported within the xml. For example, imagine we have the following text in a Word document, which uses the new text effects feature glow:

This text is represented in xml and the Open XML SDK as the following:

XML

Open XML SDK Code

using W14 = DocumentFormat.OpenXml.Office2010.Word;

...

Run run2 = new Run();

RunProperties runProperties1 = new RunProperties();

W14.Glow glow1 = new W14.Glow() { GlowRadius = 228600L };

W14.SchemeColor schemeColor1 = new W14.SchemeColor()

{ Val = W14.SchemeColorValues.ExtraSchemeColor5 };

W14.Alpha alpha1 = new W14.Alpha() { Val = 60000 };

W14.SaturationModulation saturationModulation1 =

new W14.SaturationModulation() { Val = 175000 };

schemeColor1.Append(alpha1);

schemeColor1.Append(saturationModulation1);

glow1.Append(schemeColor1);

runProperties1.Append(glow1);

Text text2 = new Text();

text2.Text = "text effects";

...

As you can see from the code snippet above, leveraging the Office 2010 Open XML functionality of the SDK is as simple as including the appropriate set of namespace references.

Office 2010 Schema and Semantic Level Validation

In a previous post I talked about how to find Open XML errors with the Open XML SDK validation functionality. In that post, I talked about finding both schema and semantic (constraints defined in the prose of the documentation that are not represented in schema markup) validation errors. With the latest SDK CTP you are now able to differentiate between errors specific to Office 2007 or Office 2010. The code to validate a file is pretty much the same as the code I showed in the previous post mentioned. The major difference is that we moved the validation functionality to be under its own namespace reference: "using DocumentFormat.OpenXml.Validation". We moved this functionality to its own namespace to improve discoverability of the feature. The OpenXmlValidator class now takes in an enumeration called FileFormatVersions that allows you to specify either Office 2007 or 2010:

The validation functionality also has the ability to automatically deal with extensibility markup, like alternate content blocks, as defined by the Open XML standard.

General Open XML SDK Improvements

We recently conducted a usability study for the Open XML SDK where we asked participants to complete a set of tasks. Based on the results of the study we found that users had issues around the complexity of the Open XML SDK Open methods. In the August 2009 CTP of the SDK, each of the classes WordprocessingDocument, SpreadsheetDocument and PresentationDocument had nine overloaded Open methods. For example, let's look at the WordprocessingDocument class as an example:

public static WordprocessingDocument Open(Package package);
public static WordprocessingDocument Open(Package package, bool autoSave);
public static WordprocessingDocument Open(Stream stream, bool isEditable);
public static WordprocessingDocument Open(string path, bool isEditable);
public static WordprocessingDocument Open(Package package, MCMode mode, bool processMCInWholePackage);
public static WordprocessingDocument Open(Stream stream, bool isEditable, bool autoSave);
public static WordprocessingDocument Open(string path, bool isEditable, bool autoSave);
public static WordprocessingDocument Open(Stream stream, bool isEditable, MCMode mode, bool processMCInWholePackage);
public static WordprocessingDocument Open(string path, bool isEditable, MCMode mode, bool processMCInWholePackage);

Now with the latest CTP, the number of overloaded methods for Open has been reduced to six methods:

public static WordprocessingDocument Open(Package package);
public static WordprocessingDocument Open(Package package, OpenSettings openSettings);
public static WordprocessingDocument Open(Stream stream, bool isEditable);
public static WordprocessingDocument Open(string path, bool isEditable);
public static WordprocessingDocument Open(Stream stream, bool isEditable, OpenSettings openSettings);
public static WordprocessingDocument Open(string path, bool isEditable, OpenSettings openSettings);

Advanced open settings are now part of a new class called OpenSettings. This class allows you to pre-process documents according to markup compatibility, auto save files, or caps the open method to deal with a specific number of characters within a part. Hopefully this change will make it easier to deal with the Open method.

Open XML SDK Tool Improvements

The last major improvement I want to call out is around the free Open XML SDK tool that comes with the SDK. In the August 2009 CTP, the Open XML SDK shipped with three separate tools:

Document Reflector
Open XML Class Explorer
Open XML Diff

Based on feedback we have separated the download of the tools from the SDK dll. In other words, the Open XML SDK download page now has two download links: one for the SDK dll and one for a new consolidated Open XML SDK tool. As of the December 2009 CTP, the Open XML SDK tools are consolidated into one tool. In addition we've added some new functionality to the SDK. Here is a video that shows you an overview of the new tool:

The new tool adds the following functionality:

Documentation for Office 2010 Open XML formats
Validation functionality. This feature allows you to validate Open XML files according to Office 2007 or Office 2010
New reflection feature that combines reflection with the Open XML Diff feature. This new feature allows you to automatically generate SDK code that transforms one document into another document

Let us know what you think of the new tool. I think of the new tool as the Open XML version of Macro Recording.

More Feedback Always Welcome

Please continue to send us your feedback, either on this blog or at our Microsoft Connect site for the Open XML SDK. We look forward to hearing from you.

Zeyad Rajabi

Extending the Reach of Excel Services with the Open XML SDK

2009-12-03T21:08:00Z

Note: Updated post to point to a YouTube video that is shorter than 10 minutes

In Brian's last blog he talked about Open XML and Office Services as a one-two punch to complete many types of solutions. I am going to start writing some posts that showcase these two technologies working together. Excel is a great tool for connecting to multiple types of data sources, like databases or XML files. Unfortunately, Excel has no concept of connecting to other types of Office documents, like Word files. This fact is important because information workers are pumping out more and more Office documents that contain lots of relevant business data. These documents are becoming just as important as data contained within databases. In today's post, I am going to show you how to extend the reach of Excel Services and hosted charts to gather data from within a library of Word documents.

If you want to jump straight into the code, feel free to download this solution here.

Scenario

As a Program Manager (PM) in Office, one of our tasks is to write specifications for features that we are designing for the product. These specifications exist in different stages depending on how far along we are in the design. For example, a stage 0 specification is essentially just a placeholder document with no content. A stage 5 specification is a document that contains the full design for a feature and is ready to be coded by developers. Along the way we inevitably run into open issues that must be addressed before the feature can be coded properly. In order to help us track open issues within a document we included a custom style called "Issue" as part of our specification template. This style applies a yellowish background color to a paragraph so that the paragraph easily sticks out. Here is a screenshot of what this style looks like:

Whenever a PM encounters an open issue he/she applies this custom style to the content within the specification. Wouldn't it be great if you can generate a dynamic chart that shows the number of open issues for every PM per given specification stage? This chart would represent the relative health of a particular specification library.

Solution

The scenario I listed above talks about interrogating a repository of Word documents and counting the number of open issues within each of the documents. In order to accomplish this scenario we will need to take the following actions:

Create a template Excel spreadsheet that represents the look and feel of the chart we want to display
Add an Excel Services web part to a SharePoint site that displays a chart hosted in our template Excel spreadsheet
For every Word document in a SharePoint library find the following information:
1. Program Manager name assigned to the specification
2. Specification stage
3. The number of open issues within the specification
When all the data has been gathered, inject the data into the appropriate location in the template Excel spreadsheet
Create a web part button that allows users to refresh the chart (the refresh button will perform steps 3 and 4)
1. I am going to skip on showing this part since the link to my solution includes source code that shows you how to do this task

The Template

For the sake of this post and the scenario described above I have created the following template Excel spreadsheet:

This spreadsheet contains only one sheet with a blank chart. The chart will display the number of open issues across all the program managers listed within a SharePoint library broken down by the specification status. The chart is given a specific name so that we can reference it within our Excel Services web part. Add this template document to a SharePoint library.

Creating an Excel Services Web Part in SharePoint

Note: I am going to show you how to create a web part within SharePoint 2010, but you should be able to do the same thing within SharePoint 2007 (since Excel Services is not new to 2010).

On a SharePoint site where you are an admin, click on the menu command with your name and select Personalize this Page option:

At this point you have the ability to change the look of the page. Click on the Add a Web Part link:

In the Categories section select Office Client Applications. In the Web Parts section select Excel Web Access:

Now we need to link our Excel Services web part to our template Excel spreadsheet. Click the link to open the tool pane, which allows you to reference the correct Excel spreadsheet. In the Excel Services web part properties pane add the following information:

Name of the referenced workbook
Name of the chart to be added in the Named Item field

At this point we have an Excel Services web part that shows the chart in our Excel spreadsheet template.

Gathering Data from a Library of Word Documents

The first step in this task is to iterate through all the Word documents in a given specification library. Here is a code snippet to accomplish this task:

SPWeb myWebSite = SPContext.Current.Web;

SPDocumentLibrary specLibrary = myWebSite

.Lists["Sample Spec Library"] as SPDocumentLibrary;

//Read all Word documents in the library

foreach (SPListItem item in specLibrary.Items)

{

byte[] byteArray = item.File.OpenBinary();

using (MemoryStream mem = new MemoryStream())

{

mem.Write(byteArray, 0, (int)byteArray.Length);

//Read the Word document into the Open XML SDK

using (WordprocessingDocument myDoc =

WordprocessingDocument.Open(mem, true))

{

//Do something

}

Now that we have access to the Word documents we need to count the number of paragraphs that have the style "Issue" applied. I have already written a post on how to accomplish this task. Check out retrieving Word content based on styles. I am going to reuse the same methods I talked about in that previous post for this scenario. I will reuse the method called GetParagraphListByStyle, which returns a list of paragraphs given a main document part and a specific style name.

Gathering the PM associated with the specification and the spec status is a matter of retrieving content within a specific content control. In my solution I am going to store the PM name, the number of open issues in the specification and the status of the specification within a hash table. Here is the code snippet I used to store the information:

Hashtable specTable = new Hashtable();

//Read all Word documents in the library

foreach (SPListItem item in specLibrary.Items)

{

string pmName = "";

int numOpenIssues = 0;

int status = 0;

...

//Read the Word document into the Open XML SDK

using (WordprocessingDocument myDoc =

WordprocessingDocument.Open(mem, true))

{

MainDocumentPart mainPart = myDoc.MainDocumentPart;

//Find out the program manager name associated with the spec

Word.DataBinding binding = mainPart.Document

.Descendants<Word.DataBinding>()

.Where(d => d.XPath.Value.Contains("PM2"))

.First();

pmName = binding.Ancestors<Word.SdtCell>().First().InnerText;

//Get all paragraphs in the spec that have a style

//applied on the paragraphs called "Issue"

IEnumerable<Word.Paragraph> paraIssueList =

GetParagraphListByStyle(mainPart, "Issue");

numOpenIssues = paraIssueList.Count();

//Find out the spec status (either 0, 1, 2, 3, 4, or 5)

IEnumerable<Word.Paragraph> paraSpecStatusList =

GetParagraphListByStyle(mainPart, "SpecStatus");

foreach (Word.Paragraph p in paraSpecStatusList)

{

string specStatus = p.InnerText;

if (specStatus.Contains("0"))

status = 0;

else if (specStatus.Contains("1"))

status = 1;

else if (specStatus.Contains("2"))

status = 2;

else if (specStatus.Contains("3"))

status = 3;

else if (specStatus.Contains("4"))

status = 4;

else if (specStatus.Contains("5"))

status = 5;

}

//Once we find all the data lets add it to a hashtable

//We will use this data to build up our chart

if (specTable.Contains(pmName))

{

int[] specStatusValues = (int[])specTable[pmName];

specStatusValues[status] += numOpenIssues;

}

else

{

int[] specStatusValues = { 0, 0, 0, 0, 0, 0 };

specStatusValues[status] += numOpenIssues;

specTable.Add(pmName, specStatusValues);

}

Notice that the specification status can be one of six values, from Stage 0 to Stage 5.

Adding Data to my Spreadsheet

At this point we have all the data from our document library. All that is left is to insert this data into our Excel spreadsheet. This part of the solution is analogous to my previous post on document assembly for SpreadsheetML. We are simply going to create new rows and cells in our spreadsheet for every piece of data within our hash table. Notice that we are adding two types of cells: value based cells and text based cells. These two types of cells are stored differently in Excel. Here is the code snippet used to accomplish this task:

void AddDataToExcel(Hashtable specTable)

{

SPWeb myWebsite = SPContext.Current.Web;

SPDocumentLibrary templateLibrary = myWebsite

.Lists["Excel Template"] as SPDocumentLibrary;

SPFile template = myWebsite

.GetFile(@"http://wordteamserver/excelservices/Excel%20Template/template.xlsx");

template.CopyTo(outputFileName, true);

SPFile output = myWebsite.GetFile(template);

byte[] byteArray = output.OpenBinary();

//Open the output workbook so we can add data to it

using (MemoryStream mem = new MemoryStream())

{

mem.Write(byteArray, 0, (int)byteArray.Length);

using (SpreadsheetDocument myWorkbook =

SpreadsheetDocument.Open(mem, true))

{

//Get the first sheet in the workbook

WorkbookPart workbookPart = myWorkbook.WorkbookPart;

WorksheetPart worksheetPart =

GetWorkSheetPart(workbookPart, "Sheet1");

//Sheet data contains all the data in the rows/cells

SpreadSheet.SheetData sheetData =

worksheetPart.Worksheet.GetFirstChild<SpreadSheet.SheetData>();

//Go through our spec hashtable so we can add the data to workbook

IDictionaryEnumerator enumerator = specTable.GetEnumerator();

while (enumerator.MoveNext())

{

string pmName = (string)enumerator.Key;

int[] specStatusValues = (int[])enumerator.Value;

//create a new row for each program manager

SpreadSheet.Row r = new SpreadSheet.Row();

//Add a cell to the row with the program manager name

//note that the name is a string

SpreadSheet.Cell firstCell = new SpreadSheet.Cell();

firstCell.DataType = SpreadSheet.CellValues.InlineString;

SpreadSheet.InlineString inlineString =

new SpreadSheet.InlineString();

SpreadSheet.Text t = new SpreadSheet.Text();

t.Text = pmName;

inlineString.Append(t);

firstCell.Append(inlineString);

r.Append(firstCell);

//Let's add values to the other cells

//specifically we will add the number of open issues

//across the different spec status values

for (int i = 0; i < 6; i++)

{

SpreadSheet.Cell sheetCell = new SpreadSheet.Cell();

SpreadSheet.CellValue v = new SpreadSheet.CellValue();

string textValue = specStatusValues[i].ToString();

v.Text = textValue;

sheetCell.Append(v);

r.Append(sheetCell);

}

sheetData.Append(r);

}

worksheetPart.Worksheet.Save();

//Once we have added all the values we need to update the

//chart ranges

FixChartData(worksheetPart, specTable);

}

//Add output file to library

SPFolder fldr = myWebsite.Folders["Excel Template"];

fldr.Files.Add(outputFileName, mem, true);

}

The GetWorkSheetPart method is the same method I wrote about in my previous post on how to copy a worksheet within a workbook.

Fix Chart Data

The last step in the solution is to fix the chart data. Again this code snippet is taken directly from my previous post on document assembly for SpreadsheetML. In any case, here is the code snippet used to accomplish this task:

//Fix the range of the chart data

void FixChartData(WorksheetPart worksheetPart, Hashtable specTable)

{

int totalCount = specTable.Count + 1;

ChartPart chartPart = worksheetPart.GetPartsOfType<DrawingsPart>()

.First().ChartParts.First();

foreach (Charts.Formula formula in chartPart.ChartSpace

.Descendants<Charts.Formula>())

{

//Range needs to be updated such that we reference the number of rows

if (formula.Text.Contains("$2"))

{

string s = formula.Text.Split('$')[1];

formula.Text += ":$" + s + "$" + totalCount;

}

chartPart.ChartSpace.Save();

}

End Result

Running this code I will end up with a chart that represents the number of open issues across a library of Word documents. Clicking Update Chart will ensure the chart reflects the data contained within the library.

I am excited about this solution because it shows how you can extend the reach of our services to accomplish other types of solutions. In this case, having Excel reflect data contained within Word documents.

Zeyad Rajabi

Open XML SDK + Word Automation Services Presentation at PDC

2009-11-23T18:38:00Z

I just got back from PDC and am excited to share with you guys the presentation, deck, and code samples I showed at my session. I also want to thank everyone who attended my session. Here is my recorded session:

You can find my session deck here: http://ecn.channel9.msdn.com/o9/pdc09/ppt/PR09.pptx

You can find all my code samples for the demos I showed here: http://zeyadrajabi.members.winisp.net/sourcecode/PDC%20Open%20XML%20demos.zip

In Brian's last post, he gave a good overview of using the Open XML SDK and Office Services together. In the next couple of months I am going to start blogging more about scenarios and solutions that leverage both the SDK and Office Services to create rich Office document solutions.

Note: I am still waiting for my two sessions at SPC to get published. As soon as they do, I will share them out with you guys.

Zeyad Rajabi

Open XML SDK Sessions at the Professional Developers Conference (PDC)

2009-11-10T23:53:00Z

I'm pretty excited, next week I'll be at PDC in Los Angeles giving another presentation on the Open XML SDK. I'll be at the conference from Nov 17-19, so if you're at PDC do come by and say hi. Here's the description and time of the session I'll be presenting:

Session Title

Time & Date

Session Code

Description

Document Assembly and Manipulation on Microsoft SharePoint Server 2010 Using Word Automation Services and Open XML

11/19/2009 11:30AM

@ 408B

PR09

Come learn about the Open XML SDK, which provides a set of .NET APIs to help developers create and manipulate documents in the Open XML Formats, and the Microsoft Office services available in SharePoint Server 2010. Hear how Word Automation Services and Excel Services can be used to build solutions for server environments without the need of the Office clients. Come and check out all the demos and free source code.

Let me know if there are specific demos you would like to see. Besides the presentation, you will be able to find me at the Office client booth during the week of PDC and at the "Ask the Experts" event. I'm looking forward to hearing feedback from you guys at the conference.

Zeyad Rajabi

Open XML and Office Services

2009-11-03T20:16:00Z

If you didn't see the news up on the Word team blog announcing Word Automation Services, and you have any interest in server side conversion of .docx files into .pdf or .xps, you should definitely go take a look: http://blogs.msdn.com/microsoft_office_word/archive/2009/10/26/introducing-word-automation-services.aspx

Capturing Business Processes in Office

I see a lot of different types of solutions people build to make their workgroups run more accurately and efficiently. Many of the solutions are created in order to codify one or more pieces of a business process, and as you can imagine, Office plays a huge role in these processes. For example, there may be people using Outlook for communication; Excel for analysis; Word for documentation; and just about any process ends in PowerPoint where you present the results of the work.

As we see the shift from a focus on an individual's productivity to a focus on the entire workgroup's productivity, it also means the way in which people program against our applications changes. This is why you see a lot more SharePoint development in addition to traditional Office development (I briefly mentioned this over the summer). It's also why the Open XML formats and the Open XML SDK were such important investments for us… they help the Office applications continue to play an important role in these workgroup level scenarios.

Printing and Re-Calcing on the Server

For example, one request we've heard from folks working with the Open XML formats on the server is that they want access to some core client functionality, like printing/layout in Word, or calculations in Excel. A couple weeks ago at the SharePoint conference we announced the next version of Excel Services, as well as a new service called Word Automation Services. These two services are great resources for people doing server side document assembly/manipulation with Open XML. The Open XML formats are great for consuming or generating content for dynamic document assembly scenarios, but often there is also the need to recalc the model, refresh the charts, or print the document, and you don't want to necessarily call back to the client to do this.

Server Side Document Assembly Example

A quick example to help explain this is a process I've seen a number of times, where banks were trying to do bulk generation of loan applications (thousands a day). There are end users involved in creating the template for the loan application, as well as building out the financial models for how the terms of the loan are determined, but the generation of the individual applications was a bulk server-side process based an incoming list of applicants. The combination of Open XML and content controls makes it pretty easy to create .docx files on the server, but in this scenario the banks wanted to send out either PDFs or hard copies, which meant you needed to include the Word client in the process (and it was obviously the big bottle neck).

With the new services announced at the SharePoint conference though, you get the perfect mix of software + services to solve the scenario. The end users can continue to work in the applications they are familiar with (Word & Excel) to build out the template and financial model, and the bulk generation can all happen on the server in an automated process:

Here's a quick step by step explanation of the process:

Client-side: Loan Template author generates the template for the loan application, and uses content controls to specify where the data should go. He saves it up to SharePoint so others can collaborate with him.
Client-side: Folks from the Legal department are able to work with in the document at the same time as the Template author because of the new co-authoring functionality in Word 2010.
Client-side: A financial analyst builds up a model for determining whether an applicant should be considered and what the terms of the loan should be. This model is saved up to SharePoint as an .xlsx
Server-side: As new applicants request an application, a server side process takes their data, and uses the Open XML SDK to inject it into xlsx. (Example 1; Example 2)
Server-side: The financial model (.xlsx) is then sent off to Excel Services to perform calculations and pull out the results
Server-side: The process takes the results of the calculation, and injects them into the Word template, using the content controls to determine what data should go where, producing a .docx file. (Example 1; Example 2)
Server-side: The .docx file is passed off to Word services where a .pdf file is generated, which can either then be sent on to a high volume printer, or e-mailed directly to the applicant.
Client-side: Any of the users can make updates to the documents (assuming this is allowed as part of the workflow), and those changes will automatically make their way into the bulk generation process.

So, you can see this is a pretty basic but also extremely power scenario, and if you've been reading Zeyad's examples over the past year or so you know how easy this can be with the Open XML SDK. I've been excited about these technologies for a few years now, and it's great that we can finally start talking publicly about them. Zeyad had a couple great demos at the SharePoint conference that really helped show the value of these services in combination with the Open XML formats. We'll post a video of the presentation as soon as it comes available, and will also have separate blog posts that drill into each one over the coming months.

-Brian

Migrating your custom solutions to Office 14

2009-10-23T00:11:54Z

For those folks who have custom Office solutions within their enterprise, one area that you often need to focus on during the upgrade cycle is testing out those custom solutions to make sure they'll run in the latest version. With Office 14, we're going to provide a great set of tools to make it even easier for folks tasked with deployment. Michael Kiselman provided a great overview today up on Gray Knowlton's blog: http://blogs.technet.com/gray_knowlton/archive/2009/10/22/announcing-the-office-2010-application-compatibility-program.aspx

We always focus heavily on testing application compatibility from version to version, and in most cases applications will continue to run just like they did in the older version. From time to time though there are cases where a custom application may need to be updated. The tools Michael describes help with both the discovery and migration processes.

-Brian

Open XML SDK Demos Shown at the SharePoint Conference (SPC)

2009-10-22T04:45:00Z

First off, I want to thank everyone who attended my two sessions at SPC on developing solutions on top of the Open XML SDK. The sessions were recorded, so as soon as they are published to the web I will send you guys some links. In the meantime, I want to share with you guys some really cool demos and source code I presented at the sessions.

Here is a link to all the demos that I showed, plus a bunch more: http://zeyadrajabi.members.winisp.net/sourcecode/Open XML demos.zip

This zip file includes demos I have already blogged about plus a few new solutions around using the Open XML SDK with Office Services. Expect to see future blog posts for the demos that haven't been blogged about yet.

Zeyad Rajabi

Open XML SDK Sessions at the SharePoint Conference (SPC)

2009-10-09T23:51:00Z

We're just a couple of weeks away before the start of the SharePoint Conference (SPC) being held in Las Vegas. I want to give you guys a heads up that I will be at the conference from Oct 19-22. I'm pretty excited because I will be giving two different presentations on the Open XML SDK at the conference. Here's the description and times of the two sessions I'll be doing:

Session Title

Time & Date

Session Code

Description

SharePoint 2010 Based Document Assembly and Manipulation using Word Automation Services and Open XML

10/20/2009 10:30 AM

@ Mandalay Bay H

SPC349

The Open XML Formats are the new default file formats for Word, Excel and PowerPoint (docx, xlsx, pptx). With the Open XML SDK, which provides a set of .NET APIs that allows developers to create and manipulate documents in the Open XML Formats, and the Office services available on SharePoint 2010 (Word Automation Services, which performs high-performance bulk document conversions, and Excel Services, which provides server-side support for spreadsheet calculation), developers can now build solutions for server environments without the need of the Office clients. With just a few lines of code you will be able to create rich solutions, like document assembly. Come and check out all the demos and free source code.

Deep Dive Open XML and the Open XML SDK

10/20/2009 1:15 PM

@ Mandalay Bay J

SPC402

This session will introduce you to Open XML and the tools you use to develop Office document solutions. Using Open XML you have the power to create and edit documents on the server without needing to resort to COM based Office automation. You will get a basic understanding of how to use Open XML for authoring documents, spreadsheets and presentations. You will learn how to leverage the Open XML SDK and other various tools to make your development life easier. After this session is complete you will know everything you need to get going with building document automation processes. Come and check out all the demos and free source code.

Let me know if there are specific demos you guys would like to see and I'll try to work on getting them included. After my presentations, I will make available all my demos and source code on this blog. Besides the presentations, you will be able to find me at the Office client booth during the week of SPC and at the "Ask the Experts" event on Wednesday October 21. If you're at SPC do come by and say hello. I always look forward to hearing feedback from you guys at these conferences.

Zeyad Rajabi

Finding Open XML Errors with Open XML SDK Validation

2009-09-25T00:36:00Z

In a previous post, I gave you an overview of the functionality added to the Open XML SDK 2.0 August 2009 CTP. Today, I want to deep dive into the schema and semantic level validation support within the SDK. Specifically, I am going to show you guys the Open XML SDK code needed to actually validate your Open XML files.

If you've played around with manipulating Open XML files there is a good chance at one point in time your resulting document was considered invalid or corrupt by the applications. You've probably even seen one of these dialogs:

What do you do when you get into this state? A lot of the time the application error dialogs don't really help you debug the issue. Well, that's where the Open XML SDK can help you out. With just a few lines of code you can identify key pieces of information that tell you what the error is and where to find it within the package. Validation with the Open XML SDK 2.0 is accomplished via the OpenXmlValidator class. This class allows you to enumerate all the errors within a file, where each error is represented via the ValidationErrorInfo class. The ValidationErrorInfo class stores the following information:

User friendly description of the error
An XPath to the exact location of the error
The part where this error exists
Other elements or parts that are related to this error

Here is a code snippet you can reuse to validate Word documents:

try

{

OpenXmlValidator validator = new OpenXmlValidator();

int count = 0;

foreach (ValidationErrorInfo error in validator.Validate(WordprocessingDocument.Open("InvalidFile.docx", true)))

{

count++;

Console.WriteLine("Error " + count);

Console.WriteLine("Description: " + error.Description);

Console.WriteLine("Path: " + error.Path.XPath);

Console.WriteLine("Part: " + error.Part.Uri);

Console.WriteLine("-------------------------------------------");

}

Console.ReadKey();

}

catch (Exception ex)

{

Console.WriteLine(ex.Message);

}

The same code can be used to validate Excel and PowerPoint documents. All you need to do is change the Open method to be one of the following:

foreach (ValidationErrorInfo error in validator.Validate(PresentationDocument.Open("InvalidFile.pptx", true)))

foreach (ValidationErrorInfo error in validator.Validate(SpreadsheetDocument.Open("InvalidFile.xlsx", true)))

Pretty simple stuff! If you want to jump straight into the code, feel free to download this solution here.

Let's walk through an example of validating and fixing an example corrupt Word document. Given this corrupt document, the Open XML SDK detects the following errors:

Let's look at each of these errors.

Error 1

Description: The attribute 'http://schemas.openxmlformats.org/wordprocessingml/2006/main:rsidR' has invalid value '006B4C'. The actual length according to datatype 'hexBinary' is not equal to the specified length. The expected length is 4.
Path: /w:document[1]/w:body[1]/w:p[1]
Part: /word/document.xml

Let's take a look at the xml within the main document part:

The error indicates that the length of the value for rsidR is not correct. We can fix this issue by changing the value to 00006B4C.

Error 2

Description: Element 'DocumentFormat.OpenXml.Wordprocessing.Footnote' referenced by 'footnoteReference@id' does not exist in part '/word/footnotes.xml'. The reference value is '3'.
Path: /w:document[1]/w:body[1]/w:p[6]/w:r[2]/w:footnoteReference[1]
Part: /word/document.xml

Let's take a look at the xml within the main document part:

Let's take a look at the xml within the footnotes part:

The error indicates that there is a reference to a footnote using the value "3", but no such value exists in the footnotes part. Let's go ahead and change the footnoteReference to have a value of "2".

Error 3

Description: Attribute 'id' should have unique value. Its current value '1' duplicates with others.
Path: /w:endnotes[1]/w:endnote[4]
Part: /word/endnotes.xml

Let's take a look at the xml within the endnotes part:

The error indicates that that more than one endnote specify the same id value. Let's go ahead and change the values to be unique.

End Result

After making these fixes we should be able to open the fixed document with no issues as shown below:

Try out the validation functionality and let us know what you think.

Zeyad Rajabi

Open XML SDK Code Snippets

2009-09-17T22:44:00Z

In my previous post, I announced the release of the Open XML SDK August 2009 CTP. Today, I want to announce the release of the Open XML SDK code snippets. This package of code snippets provides over fifty reusable code samples, in both C# and VB.NET, which accomplish many common tasks involving Excel, PowerPoint, or Word documents. Looking back at the architecture diagram for the Open XML SDK 2.0, these code snippets are part of the high level helper functions:

Erika Ehrli provided a quick summary on all the code snippets in the following post.

Using the Open XML SDK Code Snippets

Let's walk through a quick example of using the Open XML SDK code snippets. In this example, we are given a spreadsheet with a table of data and are asked to read and change a particular cell value. Here is a screenshot of the spreadsheet:

Let's say we are asked to read the value of C4 and then change the value from "Austin" to "Houston".

Here is how you would accomplish this scenario using the Open XML SDK code snippets and the Open XML SDK 2.0:

Create a solution in Visual Studio 2008
Add references to the Open XML SDK 2.0 (DocumentFormat.OpenXml.dll) and WindowsBase.dll
Enable the code snippets for your solution by following these steps
To read a cell value, add a new method to your solution based on the Open XML SDK code snippets. In particular, add the "Excel: Get cell value given row and column" code snippet, which retrieves a cell value given its row and column numbers, or a row number and column name
Use the following code to read and display the value for C4:

string c4Value = XLGetCellValueRowCol("output.xlsx", "Sheet1", "C", 4); Console.WriteLine("The value for C4 is: " + c4Value);
To change a cell value, add a new method to your solution based on the "Excel: Insert string into cell" code snippet, which given a document name, a worksheet name, a cell name, and a value, inserts text into the specified cell
Use the following code to change the value of C4 to "Houston"

XLInsertStringIntoCell("output.xlsx", "Sheet1", "C4", "Houston");

At the end of step #7 we end up with the following Excel spreadsheet:

Pretty easy with the code snippets! If you are interested in the full solution you can find it here.

Zeyad Rajabi

Announcing the Release of the August 2009 CTP for the Open XML SDK

2009-08-27T19:21:00Z

I'm really happy to announce the release of the 3^rd CTP for the Open XML SDK 2.0 for Microsoft Office! So what did we do in this CTP? Well, there were three main improvements we made to the SDK:

Add semantic level validation support
Add markup compatibility/extensibility support
General improvements based on your feedback

Semantic Level Validation Support

Let's go back to the Open XML SDK architecture diagram I showed you when we first announced the Open XML SDK:

As mentioned in a previous post, the April 2009 CTP of the Open XML SDK added schema level validation support for Office 2007 Open XML files. In the August 2009 CTP, one of the big things we added is semantic level validation support for Office 2007 Open XML files:

Semantic level validation goes beyond restrictions or rules defined by schemas. Semantic level validation allows developers to validate files against restrictions defined within the prose of the Open XML documentation. These are restrictions, which cannot be expressed in an XSD language.

Let's look at a semantic level restriction example. Specifically, let's look at the element endnote (Section 17.11.2 of Part 1 in the ISO/IEC-29500 specification). In the standard, it states that the id attribute of endnote, "specifies a unique ID which shall be used to match the contents of a footnote or endnote to the associated footnote/endnote reference mark … If more than one footnote shares the same ID, then this document shall be considered non-conformant. If more than one endnote shares the same ID, then this document shall be considered non-conformant." As you can see, having more than one endnote with the same id value will result in a non-conformant document. This non-conformant document may not be interpreted properly by a consuming application, like Word.

The Open XML SDK can now help you find these types of problems and will report the error to you by giving you the following information:

User friendly description of the error
- In this case, imagine seeing the following error "Attribute 'id' should have unique value. Its current value '1' duplicates with others."
An Xpath to the exact location of the error
- In this case, imagine seeing the following path "/w:endnotes[1]/w:endnote[4]," which indicates that the problem exists in the fourth endnote element
The part where this error exists
- In this case, imagine seeing the following part information "DocumentFormat.OpenXml.Packaging.EndnotesPart"

We hope that you can use this type of information to more easily find and fix problems. I will devote at least one blog post in the future to go into details on the validation functionality.

Markup Compatibility/Extensibility Support

As defined by the ISO/IEC-29500 specification, there are several ways to extend markup within the Open XML formats. Some of the extension mechanisms, like ignorable content and alternate content blocks, may result in differences within the XML tree structure of a document. Here is an example of markup that contains an alternate content block:

<w:document mc:Ignorable="w14 wp14">

<w:body>

<w:p w:rsidR="00FA0A01" w:rsidRDefault="00AF5A8F">

<w:r>

<w:rPr/>

<mc:AlternateContent>

<mc:Choice Requires="wps">

<w:drawing>…… </w:drawing>

</mc:Choice>

<mc:Fallback>

<w:pict>

<v:roundrect id="Rounded Rectangle 1" o:spid="_x0000_s1026" style="position:absolute… " arcsize="10923f" o:gfxdata="…" fillcolor="#4f81bd" strokecolor="#385d8a" strokeweight="2pt">

<v:textbox style="mso-rotate-with-shape:t"/>

</v:roundrect>

</w:pict>

</mc:Fallback>

</mc:AlternateContent>

</w:r>

</w:p>

<w:sectPr w:rsidR="00FA0A01">…… </w:sectPr>

</w:body>

</w:document>

In the example above, the expected child of the run element differs depending on the chosen alternate content choice. The fallback choice is what one would expect from a document created in Office 2007, while the choice requiring the wps namespace is from a document created in Office 2010. Imagine you are a solution developer working with Open XML who has deployed a solution that works perfectly on top of Office 2007 Open XML files. How would your solution work with files coming in from Office 2010? Specifically, would your solution work with documents that contain these types of extension mechanisms?

As part of the August 2009 CTP we have added functionality that allows developers to abstract away some of the difficulty intrinsic with markup compatibility and extensibility. This feature allows you to preprocess the content of Open XML files based on specific Office versions. Using the example above, if we use the August CTP to open the document based on Office 2007 we will only see the following XML markup:

<w:document>

<w:body>

<w:p w:rsidR="00FA0A01" w:rsidRDefault="00AF5A8F">

<w:r>

<w:rPr/>

<w:pict>

<v:roundrect id="Rounded Rectangle 1" o:spid="_x0000_s1026" style="position:absolute… " arcsize="10923f" o:gfxdata="…" fillcolor="#4f81bd" strokecolor="#385d8a" strokeweight="2pt">

<v:textbox style="mso-rotate-with-shape:t"/>

</v:roundrect>

</w:pict>

</w:r>

</w:p>

<w:sectPr w:rsidR="00FA0A01">…… </w:sectPr>

</w:body>

</w:document>

If your solution expected a pict element as a child of a run element, then your solution would work perfectly with this file. In other words, using this feature, solutions won't break when future versions of Office introduce new markup into the format.

General Improvements

First off we want to thank everyone for their feedback and suggestions! Based on your feedback we made the following big changes to the SDK:

AutoSave: By default, previous CTPs of the SDK forced you to perform a manual save for changes made to specific parts within the package. We have now introduced the concept of AutoSave, where changes would automatically be saved into the package, without the need to call Save() methods. For those not interested in this functionality, there is a way to turn off this feature
Base Classes for CustomXml objects and Sdt objects: The SDK currently has multiple classes to represent CustomXml and Sdt objects based on the different types of elements specified in the standard. The August 2009 CTP has introduced one base class for each of these objects in order to make it easier for you to develop solutions. In other words, your solution can now just work on the following two abstract classes: CustomXmlElement for CustomXml objects and SdtElement for Sdt objects
Simple types for Boolean type attributes: The standard specifies the concept of a simple type called ST_OnOff, which allows for values like "On", "Off", "True", "False", "0", and "1." We have updated the SDK to allow you to directly get/set such attributes using standard C# Boolean values. For example, you can now set attribute values to false or true. Without this enhancement you were forced to compare values using the enum BooleanValues

What's Next?

Our next task for the SDK is to add Office 2010 Office Open XML support. Expect to see another CTP in the next several months released with this functionality. Our goal is to be done with the Open XML SDK 2.0 around the same time as Office 2010 ships (date not public yet).

More Feedback Always Welcome

Please continue to send us your feedback, either on this blog or at our Microsoft Connect site for the Open XML SDK https://connect.microsoft.com/site/sitehome.aspx?SiteID=589. We look forward to hearing from you.

Zeyad Rajabi

Native Code Open Packaging Convention APIs

2009-08-19T23:27:00Z

In my introduction post on the Open XML SDK I mentioned that the SDK is built on top of System.IO.Packaging. System.IO.Packaging is a set of APIs that are part of .NET 3.0, which allow developers to create and manipulate documents based on the Open Package Convention (OPC). Given that Open XML Formats are based on OPC, the SDK uses System.IO.Packaging APIs to open, edit, create, and save Open XML packages.

Some of you have left comments on this blog and on the Open XML SDK forum asking about native code APIs to manipulate Open XML files. I have some good news for you guys. Included in Windows 7 will be all new native code Win32 Packaging APIs. For more information on this new API, check out the OPC team blog. In particular check out the post comparing the managed version of the API with the native code version.

Zeyad Rajabi

Adding Repeating Data to PowerPoint

2009-08-14T03:58:00Z

In a previous post, I showed you how to create a product catalog in a Word document using the Open XML SDK. I also showed you how to make PowerPoint a reporting application based on data within a database. Today, I am going to show you how to create a product catalog in a PowerPoint deck using the Open XML SDK. One of the key things I am going to show you in this post is how to create repeating data within a table on a slide.

If you want to jump straight into the code, feel free to download this solution here.

Scenario

Imagine a scenario where I'm a developer working for a fictional company called Adventure Works. In my company, we use a database to store our entire product inventory. The sales and marketing teams have asked me to build a report generation tool that is able to take the list of products and create a viewable presentation. In other words, these teams want to use a PowerPoint deck to showcase all our company's products.

Solution

Before I get into the details of my solution I want to state that I am using the freely available Adventure Works database built for SQL Server 2008.

The scenario I listed above talks about reading product data and creating a report in the form of a presentation. The products in the database are organized into categories, like clothing or bikes, and subcategories, like mountain bikes or road bikes. To make viewing the resulting presentation easier I want to make sure my slides are also organized and separated based on categories. To accomplish this task, the first thing I need to do is create a presentation template that I can use for my solution. In this case, my presentation template will contain three slides:

Title slide – This slide represents the title of the presentation deck
Template category section slide – This slide represents the divider that will separate different sections of my deck based on categories
Template product table slide – This slide represents the table I will extend based on the products in my database

My presentation template will look like the following:

Given this template, here is one way to automatically generate a PowerPoint deck based off data from a database:

Open up the template presentation via the Open XML SDK and access its main presentation part
From the presentation part, access the two template slides (category section slide and product table slide)
Connect to the Adventure Works database and query for the list of products sorted by category
Go through every product returned in the query
For every new category encountered, clone the template category section slide and change the placeholder text to be the actual category name
Clone the template product table slide at the start of every new section or if the product table becomes too large and needs to be extended to the next slide
For every product, add an image part to the slide and feed the image part with data from the database
For every product, add a new row to the appropriate cloned table slide. These rows will contain five cells, where the first cell will contain a background image of the product, and the other four cells will contain text
Delete the two template slides
Save and close the presentation

The Code

I should note that this solution will reuse a bit of functionality and methods from my previous post on creating a presentation report based on data. Specifically, I am going to reuse the following methods:

SlidePart CloneSlidePart(PresentationPart presentationPart, SlidePart slideTemplate)
1. This method will be used to actually clone slide parts
void SwapPlaceholderText(SlidePart slidePart, string placeholder, string value)
1. This method will be used to swap placeholder text for a new value
void DeleteTemplateSlide(PresentationPart presentationPart, SlidePart slideTemplate)
1. This method will be used to delete the template slides. I extended this method to have an additional parameter in order to specify the relationship id of the part to be deleted. It seems that my previous post actually hardcoded the value in the method

In addition to the three above methods, I will also reuse functionality from my previous post on pushing data from a database into a Word document. Specifically, I am going to reuse the following method:

void CalculateImageEmus(Bitmap bitmap, out int widthInEmu, out int heightInEmu)
1. This method will be used to calculate image widths and heights in EMUs. The image height will be used to calculate the row height

Reusing these methods will actually make coding this solution a lot easier!

The first couple of steps require us to open the presentation template and access the two template slide parts. Here is the code snippet used to accomplish this task:

using (PresentationDocument myPres = PresentationDocument.Open("output.pptx", true))

{

PresentationPart presPart = myPres.PresentationPart;

SlidePart sectionSlidePart = (SlidePart)presPart.GetPartById("rId3");

SlidePart tableSlidePart = (SlidePart)presPart.GetPartById("rId4");

...

}

The next step is to query the database to retrieve a list of products sorted by category. Here is the code snippet used to accomplish this task:

AdventureWorksDataContext db = new AdventureWorksDataContext();

var productQuery =

from p in db.Products

join PM in db.ProductModels on p.ProductModelID equals PM.ProductModelID

join PSC in db.ProductSubcategories on p.ProductSubcategoryID equals PSC.ProductSubcategoryID

join PC in db.ProductCategories on PSC.ProductCategoryID equals PC.ProductCategoryID

orderby PC.Name, PSC.Name

select p;

Now we should be able to go through the list of products. As described in the solution section, for every product we encounter in our query we may need to add a new category slide or a new product table slide. We will add a new category slide if we encounter a new category (remember we are sorting our products based on category). Here is the code snippet used to accomplish this task:

string section = "";

foreach (var product in productQuery)

{

string category = product.ProductSubcategory.ProductCategory.Name;

string subcategory = product.ProductSubcategory.Name;

string model = product.ProductModel.Name;

string productName = product.Name;

decimal price = Math.Round(product.ListPrice, 2);

if (section != category)

{

SlidePart newSectionPart = CloneSlidePart(presPart, sectionSlidePart);

SwapPlaceholderText(newSectionPart, "Section Title", category);

section = category;

overflow = true;

}

...

}

We will add a new product table slide whenever we encounter the first product within a category or if adding a new row to the current slide's table would cause the table to be too high and off of the visible slide. Here is the code snippet used to accomplish this task:

bool overflow = false;

int totalHeight = 0;

SlidePart current = null;

foreach (var product in productQuery)

{

...

if (overflow)

{

SlidePart newTablePart = CloneSlidePart(presPart, tableSlidePart);

SwapPlaceholderText(newTablePart, "Section", category);

current = newTablePart;

overflow = false;

totalHeight = 0;

}

...

}

Notice that I am using the Boolean value of overflow to indicate whether or not a table has too much content in it already. The next step is to add an image for every product we encounter. In addition, we need to calculate the height of the image so that we can keep track of how much content is in the current table. The height of the image will be used for the height of the added row. If the height becomes too large then we will need to make sure that overflow is set to true. Here is the code snippet used to accomplish this task:

string imageRel = "imageRelId";

int imageRelId = 1;

...

ImagePart imagePart = current.AddImagePart(ImagePartType.Gif, imageRel + imageRelId);

imagePart.FeedData(new

MemoryStream(product.ProductProductPhotos.First().ProductPhoto.LargePhoto.ToArray()));

// We need to know the proper dimensions of the image in Emus

Bitmap bitmap = new Bitmap(new MemoryStream(product.ProductProductPhotos.First().ProductPhoto.LargePhoto.ToArray()));

CalculateImageEmus(bitmap, out widthInEmu, out heightInEmu);

totalHeight += heightInEmu;

if (totalHeight > 4000000)

overflow = true;

The next step is to add a new table row that contains five cells. The first cell is going to include the product image as a background image in the cell and the other four cells will contain text. Here is the code snippet used to create the new row:

A.Table tbl = current.Slide.Descendants<A.Table>().First();

A.TableRow tr = new A.TableRow();

tr.Height = heightInEmu;

tr.Append(CreateDrawingCell(imageRel + imageRelId));

tr.Append(CreateTextCell(category));

tr.Append(CreateTextCell(subcategory));

tr.Append(CreateTextCell(model));

tr.Append(CreateTextCell(price.ToString()));

tbl.Append(tr);

imageRelId++;

Note that variable "A" refers to

using A = DocumentFormat.OpenXml.Drawing;

I created two methods to create these two types of table cells. Here is the code snippet used to create a text cell:

static A.TableCell CreateTextCell(string text)

{

A.TableCell tc = new A.TableCell(

new A.TextBody(

new A.BodyProperties(),

new A.Paragraph(

new A.Run(

new A.Text(text)))),

new A.TableCellProperties());

return tc;

}

Here is the code snippet used to create an image cell:

static A.TableCell CreateDrawingCell(string relId)

{

A.TableCell tc = new A.TableCell(

new A.TextBody(

new A.BodyProperties(),

new A.Paragraph()),

new A.TableCellProperties(

new A.BlipFill(

new A.Blip() { Embed = relId },

new A.Stretch(

new A.FillRectangle()))));

return tc;

}

Almost done! The last step is to delete the two template slides. Here is the code snippet used to accomplish this task:

DeleteTemplateSlide(presPart, sectionSlidePart, "rId3");

DeleteTemplateSlide(presPart, tableSlidePart, "rId4");

End Result

Running this code I end up with a presentation that has over one hundred slides.

Here is another view of the output:

Pretty cool stuff. The best part about this solution is that a designer can easily change the look of the template and still have this solution work as expected. For example, here is the output after the template design has been changed (same code running):

I should also note that all the screenshots above were taken with Office 2010. In other words, this solution works in Office 2007 and Office 2010.

Zeyad Rajabi

Office Extensibility Blog Now Offered in Russian

2009-08-10T22:06:00Z

I wanted to pass along some really exciting news. Brian Jones' blog is now available in Russian! Check it out here: http://blogs.msdn.com/brian_jones_ru/. Our plan is to continue localizing this blog into Russian so that we can share all the Office 2010 extensibility goodness to more people. Let us know if you want to see other Office blogs get localized to Russian as well.

Zeyad Rajabi

The Open XML SDK and Fluent UI Extensibility

2009-08-03T19:05:00Z

Fluent UI, or the Ribbon, was introduced as part of Office 2007 as a replacement of the previous system of toolbars and menus. The Fluent UI technology, like the Open XML formats, is based on xml, which allows for a much richer extensibility story for developers. In Erika Ehril's blog post she described several tools and resources related to Fluent UI extensibility. I wanted to take this opportunity to extend her post by showing you how the Open XML SDK can be used to extend or actually control custom UI within documents.

As is the case with other features in Open XML files, the Open XML SDK 2.0 for Microsoft Office supports Fluent UI through strongly typed access to the custom UI xml part as well strongly typed access to the underlying xml contained within the custom UI xml part. In other words, you can easily add, remove or modify custom UI for a particular document or set of documents using the SDK. In today's post, I am going to show you how to add custom UI to a set of documents within a directory.

If you want to jump straight into the code, feel free to download this solution here.

Scenario

Imagine a scenario where I would like to programmatically add custom UI to a set of documents based on custom UI within a specific template. These documents can exist within a directory or a SharePoint library. In this scenario, my template is going to contain the same custom UI as designed by Frank Rice in his Office developer resources ribbon UI addin blog post. For the sake of this example, let's say I am starting with the following Word document as my template:

This custom UI provides a tab called Office Developer Resources, which contains commands that take you to specific web sites. The code behind these commands is actually contained within macros within the file. In order to add this custom UI to other documents we need to copy over the custom UI as well as the macros that power those commands.

The Solution

To add custom UI to a set of documents we can take the following actions:

Go through all files within a specific directory
If a file is a macro-free document then convert the document to a macro-enabled document
Open the template file using the Open XML SDK
Grab the ribbon extensibility part (contains the custom UI)
Grab the VBA project part (contains the macros)
Open the converted file (or the original file if it was a macro-enabled file) and import both the ribbon and macro parts
- The file can only contain one instance of each part so be sure to remove preexisting ribbon and macro parts from the file

Note that the steps outlined above are just one method to accomplish this scenario. Another more practical use of this solution is to go through a list of files contained within a SharePoint library instead of a directory on disk.

The Code

The first step as outlined in the solution section above requires us to go through a directory of files. Here is the code snippet to accomplish this task:

string newFileName = null;

string[] files = Directory.GetFiles(@"D:\Open XML SDK demos\Word\DeployCustomUI\DeployCustomUI\bin\Debug\Files");

foreach (string filename in files)

{

if (filename.EndsWith(".docx"))

{

newFileName = ChangeDocumentType(filename);

}

else if (filename.EndsWith(".docm"))

newFileName = filename;

ImportCustomUI(templateFile, newFileName);

}

If a file in the directory turns out to be a macro-free file we need to change the document type to be a macro-enabled file. Here is the code snippet used to accomplish this task:

static string ChangeDocumentType(string filename)

{

using (WordprocessingDocument myDoc = WordprocessingDocument.Open(filename, true))

{

myDoc.ChangeDocumentType(WordprocessingDocumentType.MacroEnabledDocument);

}

string newFileName = Path.GetDirectoryName(filename) + @"\" + Path.GetFileNameWithoutExtension(filename) + "(was docx).docm";

File.Move(filename, newFileName);

File.Delete(filename);

return newFileName;

}

Notice how the Open XML SDK provides functionality to switch document types. At this point we are ready to import our custom UI from our template into our files within the directory. Below is the code snippet necessary to grab the custom UI and vba project parts from the template document:

static void ImportCustomUI(string templateFile, string outputFile)

{

using (WordprocessingDocument myDoc = WordprocessingDocument.Open(templateFile, true))

{

MainDocumentPart mainPart = myDoc.MainDocumentPart;

RibbonExtensibilityPart customRibbonPart =

myDoc.GetPartsOfType<RibbonExtensibilityPart>().First();

ExtendedPart vbaPart = null;

foreach (IdPartPair partPair in mainPart.Parts)

{

if (partPair.OpenXmlPart.RelationshipType == "http://schemas.microsoft.com/office/2006/relationships/vbaProject")

{

vbaPart = (ExtendedPart)partPair.OpenXmlPart;

break;

}

AddCustomUIParts(outputFile, customRibbonPart, vbaPart);

}

Now that we have the two parts from our template file we are ready to import them into our output file. Below is the code snippet necessary to accomplish this task:

static void AddCustomUIParts(string filename, RibbonExtensibilityPart customRibbonPart, ExtendedPart vbaPart)

{

using (WordprocessingDocument myDoc = WordprocessingDocument.Open(filename, true))

{

MainDocumentPart mainPart = myDoc.MainDocumentPart;

if (myDoc.GetPartsCountOfType<RibbonExtensibilityPart>() > 0)

myDoc.DeletePart(myDoc.GetPartsOfType<RibbonExtensibilityPart>().First());

myDoc.AddPart<RibbonExtensibilityPart>(customRibbonPart);

ExtendedPart extendedPart = null;

foreach (IdPartPair partPair in mainPart.Parts)

{

if (partPair.OpenXmlPart.RelationshipType ==

"http://schemas.microsoft.com/office/2006/relationships/vbaProject")

{

extendedPart = (ExtendedPart)partPair.OpenXmlPart;

break;

}

if (extendedPart != null)

mainPart.DeletePart(extendedPart);

if (vbaPart != null)

mainPart.AddPart<ExtendedPart>(vbaPart);

}

Notice in the code above that I am removing any previous custom UI or vba part within the output document. Instead of deleting these parts I could have chosen to do some kind of merge, although that approach would have been more difficult.

End Result

Running this code I should end up with a directory full of macro-enabled files that all have custom UI enabled. Here is a screenshot of one of my documents, which has the imported custom UI:

Zeyad Rajabi