http://code.msdn.microsoft.com/OBANorthwind

This sample demonstrates a simple Office Business Application used by the new Northwind Traders built with Visual Studio 2008 Service Pack 1. It follows the workflow of accepting purchase orders through email all the way to shipping. It shows how to expose LOB data using ADO.NET Data Services as well as interact with it in Outlook, Word, Excel and SharePoint 2007.

Please read the companion article series for step-by-step information on building this sample:

Building an Office Business Application
OBA Part 1 – Exposing Line-of-Business Data
OBA Part 2 – Building an Outlook Client against LOB Data
OBA Part 3 – Storing and Reading Data in Word Documents
OBA Part 4 – Building an Excel Client against LOB Data
OBA Part 5 – Building the SharePoint 2007 Workflow

This sample was built using Visual Studio 2008 Professional Service Pack 1 and it demonstrates:

1. A way to easily expose LOB data using ADO.NET Data Services
2. An Outlook Add-in that displays LOB data in a WPF control
3. How to store and retrieve structured data from Word 2007 documents
4. An Excel document customization that edits LOB data provides data visualization
5. A SharePoint 2007 Document Library Workflow that adds Order info to the database by reading word documents and updates and reports order statuses based on changes in the database using ADO.NET Data Services

Download the latest release here

PLEASE READ THIS
This sample uses the Northwind sample database you can download here. The sample contains a database project that includes change scripts to add EmailAddress to customers and employees tables as well as OrderNumber to the Orders table so please make sure you run those before attempting to run the sample. You may also need to update the connection string located in the Web.config of the NorthwindDataService project.

http://blogs.msdn.com/bethmassi/archive/2009/02/12/oba-part-3-storing-and-reading-data-in-word-documents.aspx

Gerade habe ich eher zufällig entdeckt, dass eine April 2009 Community Technical Preview (CTP) Version des Open XML Format SDK 2.0 erschienen ist. Für mich etwas überraschend, aber deswegen trotzdem schön

Die neue CTP erweitert das Paket um Unterstützung für die Validierung von Open XML Dokumenten.

Viel Spaß damit wünscht
Kostja

Auf openxmldeveloper.org kann man mal wieder ein paar interessante Neuigkeiten lesen:

1. Die PowerTools für OpenXML 1.1 sind erschienen. Die Power Tools sind ein auf Codeplex gehostetes Open Source Projekt mit dem Ziel Open XML Dokumente einfach über Powershell Skripte zu erstellen oder zu bearbeiten. Weitere Details gibt es im Blog von Eric White.
2. Das DAISY Consortium hat in Kooperation mit Microsoft das “DAISY add-in Version 2″ für Microsoft Word veröffentlicht (Pressemitteilung). Damit ist es möglich auf einfache Art und Weise aus Word Dokumenten Multimediainhalte zu erstellen, die den Zugang zu diesen Dokumenten für Sehbehinderte und Blinde ermöglichen. Hier geht’s zum Download. Unter http://www.buttercupreader.net findet sich übrigens ein Silverlight Player für DAISY. Als Project Buttercup wurde dieser von der Neuseeländischen Firma Intergen entwickelt. Weitere Infos gibt es im Blog von Gray Knowlton (Group Product Manager – Microsoft Office System).
3. Ein interessanter Artikel mit Source Code und Beispiel von Bryce Telford ist veröffentlicht. Er zeigt im Detail, wie sich mit Hilfe von XSLT und dem Open XML Format SDK 2.0 (Übrigens immer noch CTP – final dann wohl mit Office 14 ) aus einer .xml Datei ein Open XML Dokument generieren lässt. Hier gibt es den Quellcode.

Viel Spaß damit und bis bald
Kostja

I’ve been playing around with the Document Reflector in the Open XML SDK v2 CTP lately and I have to say, it is fantastic.

You can take a document with fancy formatting, styles, pictures etc and turn it into a C# class that will generate said document.

Of course, the power then comes as we can change the way the document is generated, insert code from line of business systems, generate documents at set times through Windows Workflow or just build documents without requiring Office to be installed. This is the real power of Open XML – not just the bandwidth and storage savings.

http://www.microsoft.com/uk/msdn/screencasts/screencast/253/Office-Open-XML-Document-Inspection.aspx

http://www.microsoft.com/uk/msdn/screencasts/screencast/252/Office-Open-XML-Document-Profiling.aspx

http://www.microsoft.com/uk/msdn/screencasts/screencast/261/Office-Open-XML-Content-Controls-and-Repeating-Data-Part-1-of-3.aspx

http://msdn.microsoft.com/en-us/office/bb738430.aspx

http://msdn.microsoft.com/en-us/office/aa905482.aspx

http://openxmldeveloper.org/articles/OpenXMLDocFromDotNet.aspx

Comments

	jkemmery said: Excellent primer. Thank you. April 14, 2006 10:33 AM
	planks said: I tried the example, it creates the .docx file and everything but when I tried to open it it displays an error that there are missing elements. When I see the files I notice that nothing is written in them, in the document.xml nor in the relationships file. I also sent the output to be displayed in the console and it is doing it as it should so I think there’s something about file writing permissions, any ideas? May 19, 2006 1:13 PM
	SanjayKumarM said: If you are using Office 2007 Beta2 then you may have to make the following changes to make tha application work 1. Seach for-> http://schemas.microsoft.com/office/word/2005/10/wordml replace with-> http://schemas.openxmlformats.org/wordprocessingml/2006/3/main 2. Seach for-> application/vnd.ms-word.main+xml replace with-> application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml 3. Seach for-> http://schemas.microsoft.com/office/2006/relationships/officeDocument replace with-> http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument May 24, 2006 4:46 AM
	SanjayKumarM said: Hi Planks.      The code was written for Office 2007 Beta1, I have also posted the changes to be made to make it workable for Beta 2.      I have really tested the code it works, May be the version of WinFx or office 12 you are using may mot be the corrent one.     If you want I can email the code to you. Sanjay May 24, 2006 4:49 AM
	radwagner said: Sanjay, I’m pleased to see your example as this is exactly what I’m looking for. However, when I open the document created by the sample in Office 12 Beta 2, I get “Elements and Attributes in restricted namespaces are not allowed”. Location: Part: /word/document.xml Line: 2, Column: 89. Other samples I’ve tried as posted give the same details. Thanks, RW May 30, 2006 10:33 AM
	ivofoi said: I’m having problems with the code above. It does what I need, but when the .docx file is created and I try to open it, Word 2007 returns an error: “The Office Open XML file try.docx cannot be opened because there are problems with the contents.” and “Microsoft Office cannot open this file because some parts are missing or invalid.”. Can anyone help me with this problem? thx April 3, 2007 11:11 AM
	ivofoi said: Forgot to mention – I’m not using any beta version of MS Office, but the final version. April 3, 2007 11:19 AM

https://connect.microsoft.com/content/content.aspx?SiteID=589&ContentID=9924

https://connect.microsoft.com/content/contentlist.aspx?ContentTypeID=1&SiteID=589&wa=wsignin1.0

A group of vendors led by Microsoft and aimed at fostering interoperability between different document formats has unveiled several tools to help people translate among documents created in Open XML and documents that use other file formats.

During a meeting of the Document Interoperability Initiative (DII) in Brussels this week, Microsoft and other industry leaders unveiled three tools to translate documents in Open XML, an industry standard approved by the International Organization for Standardization (ISO) for document formats that Microsoft originally created for its Office productivity suite.

Open XML Document Viewer translates Open XML documents to an HTML (Hypertext Markup Language) Web page, allowing readability of those documents on Web browsers such as Mozilla Firefox. A Community Technology Preview (CTP) of the tool is available on Microsoft’s Codeplex site.

Another new tool unveiled at the meeting is the Open XML/ODF (Open Document Format) Translators Version 2.5, which improves translations between Open XML and ODF through templates and is available now on SourceForge as an add-in for Microsoft Office 2003, 2007 and XP.

Microsoft also has posted video demonstrations of these tools on YouTube. The Open XML Document Viewer video is available here, and the Open XML/ODF Translators demo is available here.

ODF is a document format that was approved by the ISO as a global technology standard before Open XML was. In fact, Microsoft’s decision to create Open XML and then submit it as a standard rather than support ODF was a controversial one, which led the company to create the DII in March as well as undertake other interoperability efforts around the format. The ISO eventually made Open XML an international standard in April after a long, controversial approval process.

DII brings global industry leaders and vendors together to identify, test and develop tools to overcome document-interoperability barriers, according to Microsoft.

Another interoperability tool the DII discussed in Brussels that is available now is the Apache POI Java SDK for Open XML, which allows people to read and write Microsoft Office Excel files using Java, according to information about the tool on the Apache Web site.

Even as Microsoft aims to promote more interoperability between Open XML and other file formats, another country has adopted ODF as a standard file format for its documents. On Wednesday Germany said its government agencies will be able to receive, read, send and edit ODF documents beginning no later than 2010, according to a press statement from the ODF Alliance, a group aimed at promoting the standard’s use.

http://social.msdn.microsoft.com/Forums/en-US/oxmlsdk/threads/

http://blog.maartenballiauw.be/post/2008/01/11/Preview-Word-files-(docx)-in-HTML-using-ASPNET-OpenXML-and-LINQ-to-XML.aspx

http://msdn.microsoft.com/en-us/library/ms771890.aspx

Erika Ehrli
Microsoft Corporation

June 2006

Applies to:
    Microsoft 2007 Office Suites
    Microsoft Office Word 2007

Summary: Walk through the new default file format for Microsoft Office Word 2007. Read detailed descriptions of the file format architecture, key components, and ways in which you can programmatically modify content. (22 printed pages)

Contents

Introduction
Word 2007 Document Packages
Open Packaging Conventions for the Word XML Format
Interpreting Word 2007 Files
Identifying Non-XML Parts in Word 2007 Documents
Separating Content from Documents
Understanding the Data Store
Walkthrough: Creating a Word XML Format File
Conclusion

Introduction

Microsoft Office Word 2007 provides a new default file format called Microsoft Office Word XML Format (Word XML Format). This format is based on the Open Packaging Conventions, also used by the XML Paper Specification (XPS). The binary file format used in Microsoft Office 97 through Microsoft Office 2003 Editions is still available as a save format, but it is no longer the default when saving new documents.

Microsoft introduced XML into Microsoft Office XP in 1999 with SpreadsheetML in Microsoft Office Excel 2002. SpreadsheetML was a good start, but it did not provide full-fidelity. That is, it cannot describe every part of a spreadsheet. The next release of Microsoft Office products introduced WordprocessingML in Microsoft Office Word 2003. WordprocessingML was a huge step forward because it was the first full-fidelity XML file format provided by Microsoft Office. Using Microsoft Office 2003, you can parse WordprocessingML files and manipulate, update, or add data to them. However, a few limitations exist. For example, you must encode binary data (such as images) as text within the XML file itself, which increases file size when working with a document containing many images. Additionally, Word 2003 embeds all custom XML data directly into the WordprocessingML that describes the document. This can make the custom XML difficult to access and manipulate from external processes.

The new file format in Word 2007 solves these issues by dividing the file into document parts, each of which defines a part of the overall contents of the file. When you want to change something in the file, you can simply find the document part you want, such as the header, and edit it without accidentally modifying any of the other XML-based document parts. Similarly, all custom XML data is in its own part. Working with customer XML is now easier. This allows you to generate documents programmatically with less code. In addition to being more robust and making it easier to work with custom XML, the new file format is also much smaller than the binary file format. The new file format takes advantage of ZIP technology by using the Open Packaging Conventions. This article walks through the structure of a Word 2007 document in this new file format.

Word 2007 Document Packages

The file format in Word 2007 consists of a compressed ZIP file, called a package. This package holds all of the content that is contained within the document. Using the package format decreases file size for Office documents because of the ZIP compression. The new format is also more robust to errors in transmission or handling. It allows you to manipulate the file contents using industry-standard ZIP-based tools. An easy way to look inside the new file format is to save a Word 2007 document in the new default format and rename the file with a .zip extension. Double-click the file to open and view its contents.

Note   To understand the composition of a file based on Microsoft Office Open XML Formats (Office XML Formats), you may want to extract its parts. To open the file, it is assumed that you have a ZIP utility, such as WinZip, installed on your computer. To open a Word XML Format file in Word 2007:

1. Create a temporary folder in which to store the file and its parts.
2. Save a Word document (containing text, pictures, and so forth) as a .docx file.
3. Add a .zip extension to the end of the file name.
4. Double-click the file. It will open in the ZIP utility. You can see the document parts that are included in the file.
5. Extract the parts to the folder that you created earlier.
6. Integrated ZIP compression reduces the file size by up to 75 percent. Files are further broken down into a modular file structure that makes data recovery more successful and enhances security. The new format segments files into components that you can manage and repair independently. Files created in the new format also have a distinctive file extension for each application, depending on the file type.

   Table 1. File extensions for Word 2007 file types

   Word 2007 File Types	Extension
   Word 2007 XML Document	.docx
   Word 2007 XML Macro-Enabled Document	.docm
   Word 2007 XML Template	.dotx
   Word 2007 XML Macro-Enabled Template	.dotm

Open Packaging Conventions for the Word XML Format

The Open Packaging Conventions specification defines the structure of Word 2007 documents using the new file format. For more information about open packaging conventions, see the Open Packaging Conventions also used by the XML Paper Specification.

To understand the structure of a Word 2007 document, you must understand the three major components of the new file format:

• Part items. Each part item corresponds to one file in the un-zipped package. For example, if you right-click a Microsoft Office Excel workbook and choose to extract it, you see a workbook.xml file, several sheetn.xml files, and other files. Each of those files is a document part in the package.
• Content Type items. Content type items describe what file types are stored in a document part. For example, image/jpeg denotes a JPEG image. This information enables Microsoft Office, and third-party tools, to determine the contents of any part in the package and to process its contents accurately.
• Relationship items. Relationship items specify how the collection of document parts come together to form a document. This method specifies the connection between a source part and a target resource. Relationships are stored within XML parts in the document package, for example, /_rels/.rels.

The following sections explain how each of these components fit together in an Office XML Formats file.

Word 2007 Document Parts

To facilitate construction, assembly, and reuse of Word 2007 documents by third-party processes and tools, Word divides the contents of the package into several logical parts that each store a specific document part, for example:

• Comments
• Style definitions
• List definitions
• Headers
• Charts
• Diagrams
• The main document body
• Images

Word represents each of these document parts with an individual file within the package. These parts can consist of XML files, such as the document parts that contain the markup for the Word XML Format, as well as attached contents, such as pictures or OLE–embedded files in their native format. All of these are contained within the package. However, it is important to note that, with a few exceptions defined within the Open Packaging Conventions, the actual file directory structure is arbitrary.

The relationships of the files within the package, not the file structure, are what determine file validity. You can rearrange and rename the parts of a Word file inside its ZIP container, provided that you update the relationships properly so that the document parts continue to relate to one another as designed. If the relationships are accurate, the file opens without error. The initial file structure in a file in Word 2007 is simply the default structure created by Word to enable you to determine the file composition easily. Provided that you keep the relationships current, you can change this file structure.

For example, in Word 2007, the container file represents a document. Within the container file, there are parts that, when aggregated, compose the document. For example, a Word 2007 file could contain (but is not limited to) the following folders and files:

• [Content_Types].xml. Describes the content type for each part that appears in the file.
• _rels folder. Stores the relationship part for any given part.
• .rels file. Describes the relationships that begin the document structure. Called a relationship part.
• datastore folder. Contains custom XML data parts within the document. A custom XML data part is an XML file from which you can bind nodes to content controls in the document.
• item1.xml file. Contains some of the data that appears in the document. Example of a custom XML data part.
• docProps folder. Contains the application’s properties parts.
• App.xml file. Contains application-specific properties.
• Core.xml file. Contains common file properties for all files based on the Open Packaging Conventions document format.

Figure 1 shows the file structure of a sample Word 2007 document.

Figure 1. Hierarchical file structure of a typical Word 2007 document

You can replace entire document parts in order to change the content, properties, or formatting of Word 2007 documents.

Word 2007 Content Types

As mentioned previously, each document part has a specific content type. The content type of a part describes the contents of that file type. In the case of the XML parts that contain the markup defined by the Word XML Format, the content type can help you determine its composition.

A typical content type begins with the word application and is followed by the vendor name. In the content type, the word vendor is abbreviated to vnd. All content types that are specific to Word begin with application/vnd.ms-word. If a content type is an XML file, then the URI ends with +xml. Other non-XML content types, such as images, do not have this addition. Some typical content types are:

• application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xmlContent type for a document part that describes endnotes within a Word document. The +xml indicates that it is an XML file.
• application/vnd.openxmlformats-package.core-properties+xmlContent type for a part that describes the core document properties. The +xml indicates that it is an XML file.
• image/pngContent type for an image. The +xml portion is not present—this indicates that this content type is not an XML file.

You can use all of these content types when manipulating the contents of a Word 2007 file programmatically. The Microsoft Windows Software Development Kit (SDK) for Beta 2 of Windows Vista and WinFX Runtime Components includes the System.IO.Packaging namespace, which allows you to add document parts, retrieve and update contents, or create relationships programmatically. For example, using the Microsoft WinFX System.IO.Packaging class, you can create a document part with the PackagePart.CreatePart method. The CreatePart method takes two string parameters; one for the URI of the new part and one for the content type of the part, as follows:

Copy Code

PackagePart packageNewPart = package.CreatePart(uriResourceTarget,
"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml");

This code example creates a document part using the URI stored in the uriResourceTarget variable with a content type used for styles.

For more information about PackageParts, see the PackagePart Class reference documentation in the Microsoft Windows SDK.

Locating Content Types

This section contains a list of the most frequently encountered content types. Word 2007 describes each content type by a file or part, inside the package. The [Content_Types].xml file, at the root of the package, lists every part in the file and its ContentType object. For example, you might see something like this:

Copy Code

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
   <Override PartName="/word/footnotes.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml"/>
   <Default Extension="png" ContentType="image/png"/>
   <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
   <Default Extension="xml" ContentType="application/xml"/>
   <Override PartName="/word/document.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
   <Override PartName="/word/numbering.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>
   <Override PartName="/word/styles.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
   <Override PartName="/word/endnotes.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml"/>
   <Override PartName="/docProps/app.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
   <Override PartName="/word/settings.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>
   <Override PartName="/word/footer2.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>
   <Override PartName="/docProps/custom.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.custom-properties+xml"/>
   <Override PartName="/word/footer1.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>
   <Override PartName="/word/theme/theme1.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.theme+xml"/>
   <Override PartName=
   "/word/fontTable.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/>
   <Override PartName=
   "/word/webSettings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"/>
   <Override PartName="/word/header1.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"/>
   <Override PartName="/docProps/core.xml" ContentType=
   "application/vnd.openxmlformats-package.core-properties+xml"/>
</Types>

You can rename and rearrange all of these parts within the directory structure. The parts are listed here in their default locations with their default names to make it as easy as possible to understand what they are.

Inside the Word directory, off the root of the package, is the majority of the information describing the document. In this directory, you may find parts that represent a number of available content types.

Mapping Document Parts with Content Types

Every XML file in the file format is a document part. If you look inside the newly-formatted file of most Word files, within the directory structure you see files, or document parts, like /word/fontTable.xml and word/styles.xml. These files contain clear names that indicate their purpose (for example, font table and style parts). However, you can also change their names. Therefore, inside the [ContentTypes].xml file is a <Types> element that maps each content part with its respective content type. A [ContentTypes].xml file might consist of something like this:

Copy Code

<Override PartName="/word/styles.xml" ContentType=
   "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
<Override PartName=
   "/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>

This indicates that the /word/styles.xml document part has a content type of /vnd.openxmlformats-package.core-properties+xml. The /docProps/core.xml document part has a content type of application/vnd.openxmlformats-package.core-properties+xml.

Relationships Between Document Parts

Relationships are one of the most important parts of the package because they record the connections between document parts. You can rename and move parts within the package’s directory structure, but the relationships must remain intact to keep the file valid.

A relationship is a logical connection between two parts within the file package. For example, the root document part has a relationship of type http://schemas.openxmlformats.org/package/2006/relationships/header to a part with the content type application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml. This indicates the relationship between the parts is that the target part is a header for the originating part. Furthermore, the content type indicates that the contents are a Word 2007 header. This header part could then have its own relationships. For example, if the header contained a JPEG image, the header might have a relationship of type http://schemas.openxmlformats.org/officeDocument/2006/relationships/image to a part with the content type image/jpeg.

Within the package, relationships are always located inside a directory titled _rels. To find the relationships originating from any part, look for the _rels folder that is a sibling of that part. If the part has relationships, the _rels folder contains a file that has your original part name with a .rels extension appended to it. For example, suppose you want to see if a relationship exists for the officeDocument part, which has a content type of http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument. By default, this part has a URI of /word/document.xml, so you would open the directory /word/_rels in the package and look for a file called document.xml.rels.

Every relationship has a source and a target. The source is the part after which the relationship is named. For example, all relationships inside document.xml.rels have document.xml as their source. Each .rels file contains a <relationships> element, inside which you find a <relationship> element for each target relationship containing the target relationship’s id, it’s target part, and the target part’s content type. A typical <relationships> element inside a document.xml.rels file might look like this:

Copy Code

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
   <Relationship Id="rId3" Type=
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target=
   "docProps/app.xml"/>
   <Relationship Id="rId2" Type=
   "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target=
   "docProps/core.xml"/>
   <Relationship Id="rId1" Type=
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target=
   "word/document.xml"/>
   <Relationship Id="rId4" Type=
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties" Target=
   "docProps/custom.xml"/>
</Relationships>

Notice that each relationship element first specifies the relationship id, then the content type of the target, and finally the target document part.

Interpreting Word 2007 Files

This section walks you through the main set of document parts in a Word 2007 file that uses the new file format. It also outlines the relationships between these parts as presented using the default directory structure.

Understanding Root–Level Relationships

The first part of any file that uses the Word XML Format is a virtual document part, or the package itself, called the start part. From this start part, there are relationships to several top-level parts, which describe the contents of the document:

Table 2. Root-level parts, relationships, and content types

These four default parts contain the primary document properties, as well as a reference to the root part for the document, that is, the main document body content.

Understanding Document–Level Relationships

From the main document part, there is a set of relationships to the document parts referred to by the main document, as shown in Table 3.

Note that most relationships below are prefixed with the following:

Copy Code

http://schemas.openxmlformats.org/officeDocument/2006/relationships/

Table 3. Document-level parts, relationships, and content types

This list of parts is not complete. For example, it does not include shared parts such as OLE objects, Microsoft ActiveX controls, and digital signatures. However, it does provide insight into the typical Word XML Format structure in Word 2007.

Identifying the Package URI and Content Type Names

As described previously, programmatically, you can use a URI to refer to all of the relationships and almost all of the document parts. There are two types of URIs: one for document parts and another for relationships.

In the new Word XML Format, relationship URIs usually begin with the following:

Copy Code

http://schemas.openxmlformats.org/officeDocument/2006/relationships/

For example, note the relationship-type used for application-level properties:

Copy Code

http://schemas.openxmlformats.org/officeDocument/2006/relationships/
/extended-properties

This URI includes the word officeDocument because the Open XML File Formats convention dictates these relationships.

The exceptions are relationship-types that begin with a base of http://schemas.openxmlformats.org/package/2006/relationships/. Notice that this base uses the word package instead of officeDocument, indicating that it conforms to the XPS Open Packaging Convention. One such relationship-type that uses this prefix in its URI is the following:

Copy Code

http://schemas.openxmlformats.org/package/2006/relationships/
metadata/core-properties

This URI describes properties specific to the file. Relationship URIs are predefined. You cannot change them.

URIs for document parts point to the document part inside the package. For example, the default URI for the document part containing the main information about the document is /word/document.xml. This indicates that the main document information is contained in a file called document.xml inside a folder called word off the root of the package. You can rename and move document parts inside the package, thereby changing the URI for the document part. It is very important to update the relationships when renaming or relocating document parts inside the package.

Identifying Non-XML Parts in Word 2007 Documents

All embedded parts in a Word 2007 document are in their native, default Word XML Format. Therefore, if you add a picture to a document, you can rename the document with a .zip extension, and open it as you would any ZIP file. Within the package, you can locate the picture and open it as well. If the picture is in a .png format, you can see and open a .png file directly from the package.

Similarly, if you embed a Microsoft Office Visio document inside a Word 2007 document, you can locate the file as a .bin file inside the package.

This creates many possibilities for developers with files stored on a server. Consider the scenario where a company has hundreds of documents on a server that all contain the same corporate logo image. If the corporate logo changes, you can implement a simple script to replace the old logo with the new logo for every document.

The default location for images in a package is the /word/media directory and the default location for embedded objects in a package is /word/embeddings.

Figure 2 shows the directory structure for a document that contains images and embedded objects.

Figure 2. Hierarchical file structure of a Word 2007 document containing images and embedded objects

Separating Content from Documents

The document part that maps to the content type specified by the following URI:

Copy Code

application/vnd.openxmlformats-officedocument.wordprocessingml.main+xml

defines most of the document structure. In macro-enabled files, the part that maps to application/vnd.ms-word.template.macroEnabledTemplate.main+xml defines most of the document structure. In the previous code example from the [Content-Types].xml file, this content type maps to the document.xml part in the /word/document.xml folder.

This part contains XML that is similar to a subset of WordprocessingML used in Word 2003. There are elements for paragraphs, properties, and fonts that describe the basic structure of the document. Individual parts describe all the components of the document, such as headers, footers, lists, and endnotes. By default, most of these parts are siblings of the following content type file:

Copy Code

application/vnd.openxmlformats-officedocument.wordprocessingml.main+xml

If you look at the previous code example, from the [Content-Types].xml file, you see many of these parts listed.

This separation of content from formatting makes working on elements of a document programmatically a much easier task than in previous versions. Using the WinFX System.IO.Packaging class, you can modify the file with a few lines of code and perform tasks such as:

• Replacing an old corporate logo used in hundreds of documents on a server with a new logo. Simply locate the image, delete it, and replace it with the new image.
• Updating all the footers in documents on a server with an updated company name.
• Changing the style of all the text in documents on a server to reflect a new corporate font.

There are, of course, many more possibilities. With this content separation, locating the part to edit is much easier than it is with the WordprocessingML used in Word 2003. In a WordprocessingML file, the entire document is described in one giant XML file. Parsing the file to make the change can be difficult. It also can be risky, because if a mistake is made, the entire document may become corrupt. In contrast, if one part of a Word 2007 document is corrupt, the rest of the document should open without error.

Understanding the Data Store

Similar to many other types of data in the Word XML Format, custom XML data is stored separately from the rest of the document. Each item is stored as a separate part within the package, and by default, this data appears in a folder called customXml located off the root of the package. If you attach an XML file to a document programmatically by adding a new part to the document’s CustomXMLParts collection, then by default that XML data is stored in a file called /customXml/item1.xml. If you add a custom XML data from another file, then, by default, it is stored in a file called /customXml/item2.xml.

By using XMLMapping and XPath expressions, you can map specific elements of an XML part to a content control. This means that to modify or change custom XML programmatically, you do not need to parse through a large WordprocessingML file, as you did in Word 2003. Instead, you find the part holding the custom XML that you want and modify only that part of the file.

To add custom data to your document, you need to create a custom XML file and add it to the ZIP package. You also need to create the corresponding relationship from the main document part to your custom XML part.

In the Word XML Format in Word 2007, each custom part persists in its own XML part within the document container. The custom part contains the file name and its relationship information. The XML part is stored off the root of the document container in a folder called customXml.

Figure 3 shows the directory structure for a document that contains custom XML data.

Figure 3. Hierarchical file structure of a Word 2007 document containing custom XML data

Isolating custom XML data inside a document package allows you to read and update custom data without modifying or working with other document parts.

The relationship file, stored inside a _rels folder, describes all the relationships from one XML part to all other XML parts within a Word XML Format document. There are two relationship types for custom XML parts.

The relationship type for the XML is:

Copy Code

http://schemas.openxmlformats.org/officedocument/2006/relationships/customXmlData

The relationship type for the XML properties is:

Copy Code

http://schemas.openxmlformats.org/officedocument/2006/relationships/customXmlProps

An ID is stored with each relationship, allowing you to identify it uniquely within the data store.

The actual custom XML part is stored in its own file alongside the _rels folder. Each custom XML part has a file name of item##.xml and its own properties, named itemProps##.xml. In both file names, ## is the number (1, 2, 3. . .) of the custom XML part in the data store. The file format for the item##.xml custom XML part looks like the following.

Copy Code

<o:dataStoreItem>
   <o:dataStoreItem o:itemID="MSXID for the custom XML part"/>
   <o:xmlSchemaRef o:relID="relationship ID to a schema"/>
</o: dataStoreItem>

Walkthrough: Creating a Word XML Format File

Document.xml is the only required part in the Word XML Format. For information about how to create a minimal document with only this required part, see the section Creating the Document.

To illustrate how document parts, content type items, and relationship items work together, this section walks through the process of building a more elaborate Word XML Format document in Word 2007. This walk through helps illustrate how to access and alter document contents using the Word XML Format.

To create a Word 2007 document that contains content type and relationship items, you need to create a root folder that contains a specific folder and file structure, as shown in Figure 4.

Figure 4. Folder and file structure for a Word 2007 document

After you create all folders and files, the next section walks your through adding the required XML code to each document part.

Creating the Document Properties

First, you need to create two XML files for the document properties:

1. Create a folder and name it root.
2. Create a folder inside the folder root and name it docProps.
3. Open Notepad or any other XML editor.
4. Copy and paste the following code into a new file and save it as app.xml inside the docProps folder:
   Copy Code

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <Properties xmlns=
      "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
      xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">
        <Template>Normal.dotm</Template>
        <TotalTime>1</TotalTime>
        <Pages>1</Pages>
        <Words>3</Words>
        <Characters>23</Characters>
        <Application>Microsoft Office Word</Application>
        <DocSecurity>0</DocSecurity>
        <Lines>1</Lines>
        <Paragraphs>1</Paragraphs>
        <ScaleCrop>false</ScaleCrop>
        <Company>MS</Company>
        <LinksUpToDate>false</LinksUpToDate>
        <CharactersWithSpaces>25</CharactersWithSpaces>
        <SharedDoc>false</SharedDoc>
        <HyperlinksChanged>false</HyperlinksChanged>
        <AppVersion>12.0000</AppVersion>
   </Properties>

5. Open Notepad or any other XML editor.
6. Copy and paste the following code into a new file and save it as core.xml inside the docProps folder:
   Copy Code

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <cp:coreProperties xmlns:cp=
      "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
      xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/"
      xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi=
      "http://www.w3.org/2001/XMLSchema-instance">
      <dc:title></dc:title>
      <dc:subject></dc:subject>
      <dc:creator>Your name</dc:creator>
      <cp:keywords></cp:keywords>
      <dc:description></dc:description>
      <cp:lastModifiedBy>Your name</cp:lastModifiedBy>
      <cp:revision>2</cp:revision>
      <dcterms:created xsi:type="dcterms:W3CDTF">2006-05-03T01:13:00Z</dcterms:created>
      <dcterms:modified xsi:type="dcterms:W3CDTF">2006-05-03T01:14:00Z</dcterms:modified>
   </cp:coreProperties>

Creating the Document

Next, you need to create an XML file for the document part. This is the only required part in the new Word XML Format.

1. Create a folder and name it root.
2. Create a folder inside the root folder and name it word.
3. Open Notepad or any other XML editor.
4. Copy and paste the following code into a new file and save it as document.xml inside the word folder:
   Copy Code

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <w:document xmlns:ve="http://schemas.openxmlformats.org/markup-compatibility/2006"
      xmlns:o="urn:schemas-microsoft-com:office:office"
      xmlns:o12="http://schemas.microsoft.com/office/2004/7/core"
       xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
      xmlns:m="http://schemas.microsoft.com/office/omml/2004/12/core"
      xmlns:v="urn:schemas-microsoft-com:vml"
      xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/3/wordprocessingDrawing"
      xmlns:w10="urn:schemas-microsoft-com:office:word"
      xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/3/main">
      <w:body>
        <w:p>
          <w:r w:rsidR="002847EC">
           <w:t>Word 2007 rocks my world!</w:t>
          </w:r>
        </w:p>
      </w:body>
   </w:document>

Creating a Relationship

Next, you need to create a relationship to this part. This relationship is documented in the root _rels folder, which means that the relationship is off the root (or start part) of the package. To create the relationship:

1. Create a folder inside the folder root and name it _rels.
2. Open Notepad or any other XML editor.
3. Copy and paste the following code into a new file and save it as .rels inside the _rels folder:
   Copy Code

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
     <Relationship Id="rId3" Type=
      "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"
      Target="docProps/app.xml"/>
      <Relationship Id="rId2" Type=
      "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"
      Target="docProps/core.xml"/>
      <Relationship Id="rId1" Type=
      "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
      Target="word/document.xml"/>
   </Relationships>

4. Notice that this XML creates a relationship of type officeDocument with ID rId1 to the document.xml file in the folder named word.

Defining the Content Type

Next, you need to define the content type of this file.

1. Note that the structure of a content type definition file looks like the following:
   Copy Code

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
      <Default Extension="rels" ContentType=
      "application/vnd.openxmlformats-package.relationships+xml"/>
      <Default Extension="xml" ContentType="application/xml"/>
      <Override PartName="/word/document.xml" ContentType=
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
      <Override PartName="/word/styles.xml" ContentType=
      "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
      <Override PartName="/docProps/app.xml" ContentType=
      "application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
      <Override PartName="/word/settings.xml" ContentType=
      "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>
      <Override PartName="/word/theme/theme1.xml" ContentType=
      "application/vnd.openxmlformats-officedocument.theme+xml"/>
      <Override PartName="/word/fontTable.xml" ContentType=
      "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/>
      <Override PartName="/word/webSettings.xml" ContentType=
      "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"/>
      <Override PartName="/docProps/core.xml" ContentType=
      "application/vnd.openxmlformats-package.core-properties+xml"/>
   </Types>

2. Open Notepad or any other XML editor.
3. Copy and paste the above code into a new file and save it as [Content_Types].xml inside the root folder.
   

   Note   This reserved file name is used by the Open Packaging Conventions to define the content types of all files in the package.

Creating the Package

Finally, you can put these files into a ZIP package to create a valid Word 2007 document:

1. Using any ZIP utility, save all the content of the simpledocument folder into a ZIP archive, including the following subfolders: the docProps folder, the word folder, and the _rels folder. Also include [Content_Types].xml.
   

   IMPORTANT   Do not simply add the complete simpledocument folder to a ZIP file or you get an internal error while opening the file in Word 2007. You need to specifically add all the subfolders of the simpledocument folder to the ZIP archive.

2. Save the archive as simpledocument.docx.

Now, you can open this file in Word 2007 and see the contents of the package:

Figure 5. Simpledocument.docx in Word 2007

Conclusion

When compared to the binary file format used in previous versions of Word, the new Word XML Format in Word 2007 offers many strong benefits. The compression offered by the ZIP container results in much smaller file sizes. The files are also much more robust—if a portion of the file becomes corrupt, the compartmentalization of the different document elements allows the file to open, even if one part is damaged.

It is also easier to change, add, or delete data in a Word 2007 file programmatically or manually. The file is easily accessible using the Microsoft WinFX System.IO.Packaging class. You can modify documents on a server with only a few lines of code. You can readily access and manipulate custom XML data from its own separate parts. You can even use events to trigger the change of XML data. For example, you can map a content control to an XML element containing a stock quote and then retrieve the most recent quote programmatically each time the document opens, thereby ensuring that the user always sees the current price.

The possibilities and ease with which you can program against the new Word XML Format are impressive and mark a significant advancement in Microsoft Office.

Additional Resources

To keep current with the latest on Word 2007 and the new file format, see the following resources:

• Introducing the Microsoft Office (2007) Open XML File Formats
• What’s New for Developers in Word 2007
• Office Open XML Document Interchange Specification
• Microsoft Windows Software Development Kit (SDK) for Beta 2 of Windows Vista and WinFX Runtime Components
• Open Packaging Conventions
• Setting Word Document Properties the Office 2007 Way
• Video: Office 12 – Word to PDF File Translation
• Video: Open XML File Formats
• OpenXMLDeveloper.org
• Video: Brian Jones – New Office File Formats Announced
• Blog: Brian Jones: Office XML Formats

Acknowledgments

Thanks to Frank Rice, Mark Iverson, and Tristan Davis for their contributions to this article.

http://blogs.msdn.com/ericwhite/pages/PowerTools.aspx

Processing Open XML documents using PowerShell on a server is a powerful and compelling approach to creation and modification of Open XML documents.

PowerTools for Open XML are sample source code and guidance for developers showing how to build PowerShell cmdlets to create and modify Office Open XML documents, and scripts to demonstrate the use of the cmdlets.

To download the PowerTools for Open XML: www.CodePlex.com/PowerTools

To install and use the PowerTools for Open XML:

• You need to have any edition (including Express Edition) of Visual Studio 2008 installed.  Download the Express Edition.
• You need to have PowerShell installed.  Download.
• PowerTools is built on the Open XML SDK.  Download.

More Resources 

Screen-cast that shows how to download, build, and use the PowerTools.

PowerTools for Open XML Technical Overview (For C# developers who want to enhance or modify the PowerTools cmdlets).

Example Scripts for the PowerTools

http://www.codeplex.com/PowerTools

http://notes2self.net/archive/2008/04/17/open-xml-format-sdk-april-ctp.aspx

 Download here. Class Diagram. What’s new? Roadmap.

http://notes2self.net/archive/2008/10/29/openxml-and-odf-in-windows-7-wordpad.aspx

I said I’d post screenshots of the OpenXML and ODF support in Windows 7 Wordpad. It turns out that this isn’t in build 6801 (the ISO files on “the goods” hdd but is in build 6930.

Here’s the File/Open and File/Save Dialogues …

(click the pictures for full size image)

and here’s the listed file types

and finally, here’s the ODF specification from Oasis’ site open in Wordpad

http://notes2self.net/archive/2008/10/28/windows-7-wordpad-supports-openxml-and-odf.aspx

http://www.codeplex.com/OpenXMLWriter

http://www.ecma-international.org/publications/standards/Ecma-376.htm

This Standard defines Office Open XML’s vocabularies and document representation and packaging. It also specifies requirements for consumers and producers of Office Open XML.

An Office Open XML overview is available on the Ecma website.

Copy these file(s), free of charge:

ECMA-376 2nd edition is technically aligned with ISO/IEC 29500.