About Open XML

Wiki: OpenXMLDeveloper Wiki

Anonymous — Wed, 19 Jun 2013 17:04:00 GMT

Wiki Page: OpenXmlDeveloper Wiki

Eric White — Wed, 12 Jun 2013 17:16:00 GMT

The Open XML Developer Wiki provides a variety of content that introduces Open XML and helps you get started.

[[About Open XML]]
[[Benefits of Open XML]]
[[Open XML Developer Scenarios]]
[[Comparison of Open XML to ODF]]
[[About Open Packaging Conventions]]
[[About WordprocessingML]]
[[About SpreadsheetML]]
[[About PresentationML]]

Open XML Tools and Specialized Programming Interfaces

Resource Center: [[PowerTools for Open XML]]
Resource Center: [[DocumentBuilder]]
Resource Center: [[PresentationBuilder]]
Resource Center: [[Open XML and JavaScript]]
Resource Center: [[Open XML SDK for JavaScript]]

Screen-cast Series

[[Introduction to Open XML]]
[[Recursive Pure Functional Transforms of XML]]

Open XML Content List

[[Open XML content by keyword]]
[[Open XML content by author]]

Wiki Page: Overview of the Open XML SDK for JavaScript API

Eric White — Wed, 12 Jun 2013 14:24:00 GMT

There are essentially three ‘classes’ in the API. Of course, JavaScript does not have classes as such, but there are three types of objects in the API that can be described as classes:

Return to the Table of ContentsOpenXmlPackage – this class abstracts a package, whether it be a WordprocessingML document, a SpreadsheetML document, or a PresentationML document. This class contains the list of parts, and does some housekeeping associated with the [Content_Types].xml file in the package. This class also contains some methods for maintaining the list of relationships from the package to the main parts, i.e. the main document part, the workbook part, or the presentation part. It also contains the functionality to open a package, and to serialize the package to base64 or to Flat OPC.
OpenXmlPart – this class abstracts the parts in a package. It contains the URI of the part, the content type of the part, and the part type (whether it is binary or XML). It also contains some methods for maintaining the list of relationships from this part to other parts.
OpenXmlRelationship – this class contains the information about a relationship, whether it be from the package to a part, or from a part to another part. It contains the relationship ID, the relationship type, whether the relationship is internal or external, and the target of the relationship. There is no functionality associated with OpenXmlRelationship objects - all functionality to add or delete relationships is in the OpenXmlPackage and OpenXmlPart objects. This type is used only for return values of the various functions that retrieve relationships from the package and parts.

Opening a Word Document, a Spreadsheet, or a Presentation

To open an Open XML file, you pass either a binary document that is encoded in base64 ASCII, or you pass a Flat OPC document as a string. For instance, to open a DOCX that is encoded with base64 ASCII, the code would look as follows:

// Open a document that is stored as a base64 string.  var doc = new openXml.OpenXmlPackage(document_base64);

Opening a document that is stored as XML in the Flat OPC form is exactly the same:

// Open a document that is stored as XML in the Flat OPC format.  var doc = new openXml.OpenXmlPackage(document_flatOpc);

There are several ways to get your hands on an base64 encoded DOCX, XLSX, or PPTX:

You can enable the end-user to click on a small flash control (that looks like a button), which loads the file from the file system and passes the base64 encoded ASCII to your JavaScript code.
You can manually convert a binary document to base64 encoded ASCII, and then transform the long string into code to initialize a JavaScript variable. This is a convenient way to store a template document or spreadsheet, which you will then modify programmatically and then enable the end-user to save locally.
You can request the document from the web server using an httpRequest. The ajax method of jQuery is a convenient way to do this.
When using Node.js, you can simply open the DOCX, XLSX, or PPTX. Node.js doesn’t have or need the same restrictions as JavaScript code that is running in the browser.
When writing an Office Client App for Word 2013, or when writing a SharePoint 2013 App, you can retrieve documents from document libraries.
Windows 8 ‘Store’ applications have their own means for finding and opening documents. I’ll cover these techniques when I write the Windows 8 blog-posts and screen-casts.

Once you have opened the document, you typically will ‘dot’ into one of the convenience functions that retrieve the main part of the package. For example, if you have opened a WordprocessingML document, you ‘dot’ into the mainDocumentPart function:

var doc = new openXml.OpenXmlPackage(openXmlDocument);  var mainPart = doc.mainDocumentPart();

After you have navigated to the part that you want to query or modify, you then call the getXDocument method, which retrieves the XDocument object (from LINQ to XML for JavaScript). You can either query the document or you can modify the document. The following code shows opening a document, creating a new paragraph element, finding the w:body part, finding the last paragraph in the w:body part, and then inserting the new paragraph element after the last paragraph.

// Open the document, which is stored as a base64 string.  var doc = new openXml.OpenXmlPackage(openedFileData);    // Create a paragraph.  var p = new XElement(W.p,      new XElement(W.r,          new XElement(W.t, "Hello Open XML World")));    // Append the paragraph to the document.  var body = doc.mainDocumentPart().getXDocument().root.element(W.body);  var lastPara = body.elements(W.p).lastOrDefault();  if (lastPara !== null) {      lastPara.addAfterSelf(p);  }

When you modify the XDocument object that you retrieve using the getXDocument method, your changes will be automatically included when you serialize the document to either a DOCX in base64 encoded ASCII, or when you serialize to XML in the Flat OPC format.

Once you have opened a document, spreadsheet, or presentation, you can also modify the package in the typical ways you need to do with Open XML – you can add or delete relationships, and add or delete parts.

When you have made all desired modifications to the package, you can then serialize to XML in the Flat OPC form:

var flatOpcString = doc.saveToFlatOpc();

You can also, of course, serialize to a binary DOCX, XLSX, or PPTX in base64 encoded ASCII:

var b64string = doc.saveToBase64();

There are several ways to save the Flat OPC or the base64 encoded DOCX, XLSX, or PPTX:

You can enable the end-user to click on a small flash control (that looks like a button), which opens up a File Save-As dialog. The user can navigate to their desired location and save the DOCX or Flat OPC to their local storage.
You can use httpRequest to send the document back to your web server.
If using Node.Js, you can simply write code to save to the file system.
When writing a Word 2013 App, you can replace the selection or the entire document with the newly serialized Flat OPC.
When writing an Office Client or SharePoint App, you can serialize to a document library.

Wiki Page: Open XML SDK for JavaScript

Eric White — Wed, 12 Jun 2013 14:18:00 GMT

The Open XML SDK for JavaScript is a light-weight JavaScript API that enables you to create, modify, or query Open XML documents. It is useful in the following scenarios:

Client-side Open XML applications that run in the browser
Server-side applications using Node.js
Windows 8 “Windows Store” applications
Apps for Office Client 2013
Apps for SharePoint 2013

You must be familiar with the Open Packaging Conventions (OPC) in order to use the Open XML SDK for JavaScript. If you need a refresher on OPC, you can watch the screen-casts on OPC (#7 and #8 in the screen-cast series Introduction to Open XML). You may also be interested in reading the MSDN article Essentials of the Open Packaging Conventions.

Wiki Page: The use of LINQ to XML for JavaScript

Eric White — Wed, 12 Jun 2013 14:17:00 GMT

The Open XML SDK for JavaScript uses LINQ to XML for JavaScript, which is an open source project on CodePlex that enables the use of many of the convenient patterns and idioms of LINQ to XML for the .NET Framework.

Return to the Table of ContentsRead more about the API and idioms in the LINQ to XML for JavaScript Overview. The overview contains a listing of the types, methods and properties of LINQ to XML for JavaScript.

You can find forums, discussions of issues, and the source code at Linq to XML for JavaScript on CodePlex.

LINQ to XML for JavaScript, in turn, has a dependency on the LINQ for JavaScript project, also on CodePlex.

One of the most powerful patterns that we find with LINQ to XML for JavaScript is that of Recursive Pure Functional Transformations (RPFT). Here is a screen-cast series on writing Recursive Pure Functional Transformations.

You also need to be familiar with the pre-initialized Open XML Element and Attribute Names.

Wiki Page: Scenarios of the Open XML SDK for JavaScript

Eric White — Tue, 11 Jun 2013 15:21:00 GMT

Client-Side Open XML Applications that Run In-Browser

Return to the Table of ContentsYou can build client-side Open XML applications that run in the browser. This enables you to provide Open XML functionality to your users without requiring them to install an executable such as a .NET application. You might create an application to:

Collect input from the user and build a custom Word document such as a legal document, a sales proposal, or a management report. Of course, one of the cool things about these types of JavaScript applications is that they are super-easy to demonstrate. You can find a number of Open XML SDK for JavaScript applications hosted here at OpenXmlDeveloper.org. This Open XML SDK for JavaScript document generation example shows one approach to building this variety of application.
Collect selection criteria and build a custom Spreadsheet that enables you to provide interesting functionality that they can run locally using Excel.
Build a PowerPoint Presentation dynamically so that sales folks have a presentation tailored exactly to their current sales prospects.
Enable the user to upload a Spreadsheet that contains data that they want to submit to the server.
Enable the user to submit a Word document for validation. You might enable them to check that it meets corporate policy with regards to recommended phrasing or disallowed words.

One interesting scenario is that there are a fair number of developer tools that we can build using the Open XML SDK for JavaScript. Some ideas are:

Generate a number of random documents for testing purposes. These documents can contain optionally contain a large number of Open XML features, such as tables, headers, footers, comments, content controls, and etc.
Query an Open XML document to see metrics on it, and to see the features that it uses. You can know whether it contains comments, foot notes, or RTL text. I anticipate that this utility will query and report on a few dozen features.
Simplify a document, removing features such as RSID attributes, comments, content controls, and MC markup.

Plans are that over time, we’ll be writing and hosting these applications here on OpenXmlDeveloper.org.

Currently, it is fairly easy to build a web-application with Open XML functionality using server-side technologies, such as the Open XML SDK from within an ASP.NET application. However, if you can’t use the Open XML SDK and the .NET Framework, life becomes more difficult. Supplying Open XML functionality in the browser has several advantages.

First, this approach will work regardless of the server-side technology that you are using. It doesn’t matter whether you are using Java, PHP, or Ruby (or of course C# / .NET). If you can serve up JavaScript, you can serve up Open XML functionality.
Second, you can deliver this functionality without requiring your users to upload documents to your server. This frees up server resources, and in some situations, enables interesting scenarios where clients do not want to expose confidential information in their documents. You can assure them that their document will not leave their browser.
You can deliver this functionality to a wide variety of platforms, including some tablets, Macs, Linux / Unix, and phones.

The Open XML SDK for JavaScript has been tested with IE 9, IE 10, Chrome 27.0, and FireFox 20.0.1. As time allows, we will test against earlier versions of browsers. To a certain extent, the Open XML SDK for JavaScript relies on modern JavaScript engines such as Chakra and Chrome V8.

Node.Js Server Applications

If you need to build server-side Open XML functionality, you can use Node.Js to implement the functionality, and then use interop to call Node.Js from Java, C++, or other server-side technologies.

It may be possible that the ability of Node.Js to take advantage of multiple cores may enable high-performance Open XML functionality. This is a research project for the future.

One key use for Node.Js is testing your Open XML code. After writing a few thousand lines of Open XML code in JavaScript, you will want to run that code over your library of test documents. You can structure your tests so that they are isolated from whether they run in the browser or run using Node, and then build a test harness to exercise your code with hundreds or thousands of test documents.

Touch-Enabled Windows-8 ‘Windows Store’ Applications

There is a lot of fun to be had with this scenario. Combining touch, HTML5, CSS3, and Open XML presents interesting opportunities for writing collaboration and document manipulation applications.

Apps for Office Clients

When you are writing a JavaScript app for Word, you have the capability of retrieving the Open XML markup for any range of the document, modify it as appropriate, and then set the contents of the range. Having the Open XML SDK for JavaScript enables a lot of interesting applications.

While it is possible to extend Office using VBA or VSTO in Windows 7 and Windows 8, with Windows RT, JavaScript is the only extensibility approach for the Office clients, so accessing Open XML using JavaScript becomes even more important.

Apps for SharePoint 2013

One of the easiest ways to extend SharePoint is to write JavaScript code. It sidesteps all the issues associated with installing code on the server. In some cases, it is difficult to install code on the server. In others, it is completely prohibited. So having the capability of writing Open XML applications in JavaScript makes it super-easy to add Open XML functionality to SharePoint.

Wiki Page: The Use of Flash and the Open XML SDK for JavaScript

Eric White — Tue, 11 Jun 2013 15:11:00 GMT

For some time, the ability to load files from the local file system into local JavaScript variables, and to save files from local JavaScript variables to the local file system has been deemed to be a security risk. However, with the development of more and more powerful Web applications that use a log of client-side JavaScript, the need to do this has increased. At the same time, security experts have decided, to a large extent, that if we place certain limitations on loading and save files from/to the local file system, it is not a security risk. The limitations are:

Return to the Table of ContentsThe only capability of JavaScript / HTML5 is to put up a user interface control and enable the end-user to click on it. Without a specific user action, JavaScript can’t load or save a file.
When the user loads a file, the only information that the user retrieves is the data in the file, and the name of the file (but not the path or location of the file).
When the user saves a file, your JavaScript program can suggest a default filename, however, the JavaScript code can’t access the actual details of where the end-user saved the file.

This is the direction being taken by the W3C committees. The FileReader interface enables opening files, and the FileWriter API enables saving to the local file system. However, these are works in progress. Support is spotty.

In the mean-time, there is a work-around. From Flash 10 onwards, it has been possible in ActionScript to read and write to the local file system (with the same limitations as listed above). Further, there is interop between ActionScript and JavaScript so that it is easy to pass data both directions. This means that it is possible to write a small Flash module that does the actual loading and saving of files, and then use those Flash modules from JavaScript.

You can find out more about this approach in the screen-cast Working with Open XML Documents using JavaScript.

There will be more deep-dive blog posts and screen-casts into this subject in the future here at OpenXmlDeveloper.org.

Wiki Page: Open XML Element and Attribute Names

Eric White — Tue, 11 Jun 2013 15:10:00 GMT

There are hundreds of tag names in Open XML, in a wide variety of namespaces. One effective approach is to initialize many of these names and namespaces, so that instead of using strings, we can use properties of objects.

Return to the Table of ContentsEvery XName object in LINQ to XML for JavaScript is ‘atomized’, which means that if you initialize two variables to the same qualified tag name, they will both be references to the same object. A key performance advantage is that if we want to compare a tag name of an element to a given qualified tag name, then instead of doing string comparisons, which might tend to be slow, we can simply compare object identities.

The blog post, Atomized XName and XNamespace Objects, while about LINQ to XML for the .NET Framework, not JavaScript, gives an explanation of what atomization is. The blog post LINQ to XML for JavaScript - Gaining Performance through Atomization discusses this from the JavaScript point of view.

If you look in openxml.js, you will see a number of initialized objects. They all follow the following pattern:

openXml.wNs = new XNamespace("http://schemas.openxmlformats.org/wordprocessingml/2006/main");  var wNs = openXml.wNs;  openXml.W = {      abstractNum: new XName(wNs, "abstractNum"),      abstractNumId: new XName(wNs, "abstractNumId"),      accent1: new XName(wNs, "accent1"),      accent2: new XName(wNs, "accent2"),      accent3: new XName(wNs, "accent3"),      accent4: new XName(wNs, "accent4"),      accent5: new XName(wNs, "accent5"),      accent6: new XName(wNs, "accent6"),      activeRecord: new XName(wNs, "activeRecord"),      ....  };

The use of these objects is as follows:

// Open a blank document that is stored as a base64 string.  var doc = new openXml.OpenXmlPackage(blankDocument_base64);    // Create a paragraph.  var p = new XElement(W.p,      new XElement(W.r,          new XElement(W.t, "Hello Open XML World")));    // Replace the first paragraph in the document with the new paragraph.  doc.mainDocumentPart()      .getXDocument()      .descendants(W.p)      .firstOrDefault()      .replaceWith(p);

When writing the code to pre-atomize the XName and XNamespace objects, I elected to not to attempt to have all tag names for the entire Open XML standard. Instead, I opted for the most commonly used tag names. While I do not expect you to regularly encounter the need for XName objects other than the ones that I have initialized in openxml.js, if you do need a non-initialized XName object, you can initialize it in place. You use the new operator with the XName object:

var newName = new XName(wNs, "newName");

Wiki Page: Accessing Parts using Convenience Functions

Eric White — Tue, 11 Jun 2013 14:43:00 GMT

The normal way to navigate from the package to the main document part, or to navigate from one part to another part is through relationships. From one point of view, there are two varieties of relationships – implicit relationships and explicit relationships:

Return to the Table of ContentsImplicit relationships – these relationships are used in Open XML when there is only one target part of a given relationship type. While the relationship has a relationship ID, you will not find a reference to this relationship ID in the markup for the source part. Instead, if you want to get that related part, you look for a relationship with a given relationship type. If it exists, then you can open the related part. An example of this type of relationship is the relationship in WordprocessingML from the main document part to the comments part. A document may or may not have comments, so it may or may not have a comments part. To navigate to the comments part, you look for a relationship with the relationship type of "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments".
Explicit relationships – these relationships are used in Open XML when there may be more than one target part of a given relationship type. You will always find markup in the source part that contains the relationship ID. If you want to retrieve the related parts, you typically find the markup in the source part that contains the reference to the related part. You get the relationship ID from the markup, and then look up the relationship by its relationship ID. An example of this type of relationship is the relationship in WordprocessingML from the main document part to a header part. There may be multiple header parts, so to navigate to the header part, you first find the markup for the section properties in the main document part. You then find the markup for the relationship to the header part and retrieve the relationship ID. You then retrieve the relationship with the given ID, and can retrieve the related part from the relationship that you found.

Note that most of the commonly used relationship types and content types are pre-defined in openxml.js. The code that defines these relationship and content types looks like this (sorry for the small font, but it looks better when it does not wrap):

// *********** relationship types ***********  openXml.relationshipTypes = {      alternativeFormatImport: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk",      calculationChain: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain",      cellMetadata: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sheetMetadata",      chart: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",      chartColorStyle: "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle",      ...      worksheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",      worksheetComments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",      worksheetSortMap: "http://schemas.microsoft.com/office/2006/relationships/wsSortMap",      xmlSignature: "http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/signature",  };        // ********************* content types ***********************  openXml.contentTypes = {      calculationChain: "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml",      cellMetadata: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml",      chart: "application/vnd.openxmlformats-officedocument.drawingml.chart+xml",      chartColorStyle: "application/vnd.ms-office.chartcolorstyle+xml",      chartDrawing: "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml",      ...      worksheetComments: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",      worksheetSortMap: "application/vnd.ms-excel.wsSortMap+xml",      xmlSignature: "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml",  };

For many of the explicit relationships, there are convenience functions that make it easier to retrieve the related part. To demonstrate the use of the convenience functions, first let us take a look at how to retrieve a part when not using the convenience functions.

You can find the main document part like this:

// Open a blank document that is stored as a base64 string.  var doc = new openXml.OpenXmlPackage(blankDocument_base64);    // Get the main document part.  var mainPart = doc.getPartByRelationshipType(openXml.relationshipTypes.mainDocument);

When using the convenience function, the code looks like this:

// Open a document that is stored as a base64 string.  var doc = new openXml.OpenXmlPackage(document_base64);    // Get the main document part.  var mainPart = doc.mainDocumentPart();

This pattern should look familiar – it is the same pattern as followed by the Open XML SDK for the .NET Framework.

The difference in coding is more pronounced when finding the comments part:

// Open a document that is stored as a base64 string.  var doc = new openXml.OpenXmlPackage(document_base64);    // Get the main document part.  var mainPart = doc.mainDocumentPart().wordprocessingCommentsPart();

If we examine the wordprocessingCommentsPart function, we see that it is defined like this:

openXml.OpenXmlPart.prototype.wordprocessingCommentsPart = function () {      return this.getPartByRelationshipType(          openXml.relationshipTypes.wordprocessingComments);  };

You can see that these convenience methods are pretty simple. However, these navigation operations are pretty comment. We often need to write code to navigate from the package to the main document part, or navigate from the main document part to the comments part or styles part, so these convenience methods make it quite a bit easier.

You may find that you need to perform some navigation where the convenience functions have not yet been written. When you encounter this situation, you can either write a convenience function locally that follows the same pattern, or you can simply use the getPartByRelationshipType or getPartsByRelationshipType methods.

Wiki Page: Open XML and JavaScript

Eric White — Tue, 11 Jun 2013 14:38:00 GMT

This page contains a summary of all content about using Open XML from JavaScript.

Link	Summary
Screen-cast: Working with Open XML using JavaScript	This screen-cast shows a small proof-of-concept example that uses JavaScript to open, modify, and save an Open XML document. The screen-cast introduces some small Flash modules that enable uploading a file from the local file system into JavaScript data, and saving an Open XML document from JavaScript to the local file system.
LINQ to XML for JavaScript	Introduces LINQ to XML for JavaScript (Ltxml.js), which enables you to write much more expressive XML manipulation code, in the style of LINQ to XML for .NET
Gaining Performance through Atomization	Introduces XNamespace and XName atomization, and describes the implementation of atomization in Ltxml.js.

[[Open XML SDK for JavaScript]]

Wiki Page: Overview of the Open XML SDK for JavaScript

Eric White — Tue, 11 Jun 2013 13:14:00 GMT

[[Scenarios of the Open XML SDK for JavaScript]]

[[Overview of the Open XML SDK for JavaScript API]]

[[The use of LINQ to XML for JavaScript]]

[[Open XML Element and Attribute Names]]

[[Accessing Parts using Convenience Functions]]

[[The Use of Flash and the Open XML SDK for JavaScript]]

Wiki Page: Introduction to the Open XML SDK for JavaScript

Eric White — Mon, 10 Jun 2013 05:32:00 GMT

The Open XML SDK for JavaScript is a light-weight JavaScript API that enables you to create, modify, or query Open XML documents.

It is useful in the following scenarios:

Client-side Open XML applications that run in the browser
Server-side applications using Node.js
Windows 8 “Windows Store” applications
Apps for Office Client 2013
Apps for SharePoint 2013

Wiki Page: PresentationBuilder

Eric White — Wed, 08 May 2013 17:43:00 GMT

PresentationBuilder is a part of the PowerTools for Open XML project that enables developers to shred and combine Open XML presentations in a variety of ways.

This page contains a summary of all content about PresentationBuilder.

Link	Summary
Download PresentationBuilder from CodePlex.com	Download PresentationBuilder.zip, which you can find in the Downloads tab in the project on CodePlex. The latest version is at the bottom of the page. PresentationBuilder is also in the PowerTools Core zip file.
Quick Introduction to PresentationBuilder	Watch this first. Explains what PresentationBuilder is all about, and presents a short demo.
All About PresentationBuilder Part 1	Discusses the problem that PresentationBuilder solves. Shows how to build the sample. Explains the arguments to the constructors in detail. Also discusses the auxiliary files that PresentationBuilder.cs needs: PtUtil.cs, PtOpenXmlUtil.cs, and PtOpenXmlDocument.cs.
All about PresentationBuilder Part 2	Shows how slides are copied, along with the correct layout, master, and theme parts. Discusses how those parts are related to each other.
All About PresentationBuilder, Part 3	Shows how PresentationBuilder covers the various parts and relationships other than slides, master slides, layouts and themes.

Wiki Page: Introduction to SpreadsheetML

Eric White — Tue, 07 May 2013 05:47:00 GMT

This page contains links to a set of introductory screen-casts on Open XML SpreadsheetML.

If you have not already done so, you may want to view the screen-casts that provide an overview of Open XML and Open Packaging Conventions:

[[Introduction to Open XML]]

SpreadsheetML
1.	Cells and Styles	Shows how to represent cell values and format those values using styles.
2.	Formulas	Shows the details of cell formulas, evaluation and the calculation chain.
3.	Pivot Tables	Shows the organization of the pivot table parts and how to make some changes to it.
4.	Pivot Table Layout	Shows details about how to change the layout of pivot tables.
5.	Charts	Shows details about how charts are stored in a SpreadsheetML document.
6.	Exploring Table Markup in Open XML SpreadsheetML	Discusses Tables in a spreadsheet.

Wiki Page: DocumentBuilder

Eric White — Tue, 07 May 2013 05:28:00 GMT

DocumentBuilder is a part of the PowerTools for Open XML project that enables developers to shred and combine Open XML documents in a variety of ways. DocumentBuilder 2.0, released on June 20, 2011, is a significant upgrade that increases robustness - it handles a variety of cases that the first version could not handle, including images and diagrams in headers, footers, and comments. It also handles external references correctly.

Update Oct 25, 2011 - Release of DcumentBuilder 2.2 - includes bug fix for numbered items. Version number change syncs with PowerTools for Open XML 2.2. All of the screen-casts that refer to DocumentBuilder 2.0 are relevant to DocumentBuilder 2.2.

This page contains a summary of all content about DocumentBuilder 2.2. Over the next two months, I will be writing a number of blog posts and articles about DocumentBuilder 2.0. This page will be the main place where developers can go to learn about DocumentBuilder 2.2.

Link	Summary
Download DocumentBuilder 2.2 from CodePlex.com	Download DocumentBuilder-2-2.zip, which you can find in the Downloads tab in the project on CodePlex.
Seven minute screen-cast that introduces DocumentBuilder 2.0.	Watch this first.
New Version of DocumentBuilder Available in PowerTools	Introduces DocumentBuilder 2.0
Introduction to DocumentBuilder 2.0 - Screen-Cast 1 of 3	Demonstrates downloading and running DocumentBuilder 2.0. Walks through one scenario around interrelated markup, and shows how DocumentBuilder 2.0 solves the issues around interrelated markup associated with that scenario.
Introduction to DocumentBuilder 2.0 - Screen-Cast 2 of 3	Builds on the previous screen-cast - in this screen-cast, I paste an image into a comment, walk through the markup, and show how DocumentBuilder deals with this situation of interrelated markup.
Introduction to DocumentBuilder 2.0 - Screen-Cast 3 of 3	In this screen-cast, I walk through the code, show how a major portion of DocumentBuilder 2.0 is data-driven, which makes it more robust. In addition, I explain some of the finer points about how DocumentBuilder 2.0 works.
Advanced DocumentBuilder - import a document into a cell in a table, into a text box, or into a content control.	In this screen-cast, I show a new way to develop using DocumentBuilder 2.0. You can use DocumentBuilder 2.0 to import a WordprocessingML document into any location that can contain block-level content (cells, text boxes, content controls).
Fine-grained control when importing content using DocumentBuilder.	Here, I show how you can import little bits of content from one document into a very specific place in another document. The specific scenario that I work through is to import the contents of a cell in a table in one document into a cell in a table in another document.

Wiki Page: Introduction to WordprocessingML

Eric White — Mon, 06 May 2013 14:46:00 GMT

This page contains links to a set of introductory screen-casts on Open XML WordprocessingML.

If you have not already done so, you may want to view the screen-casts that provide an overview of Open XML and Open Packaging Conventions:

[[Introduction to Open XML]]

WordprocessingML
1.	Paragraphs, Runs, and Text	Provides a basic introduction to WordprocessingML.
2.	Styles and Sections	Introduces styles and sections. It demonstrates the nature of inheritance in styles, and shows a couple of key points about section markup.
3.	Annotations	Introduces annotations, including comments, bookmarks, proofing errors, range permissions, and revision tracking. It contains some key points about best practices for dealing with each of these.
4.	Images	Discusses images in WordprocessingML. It shows how you can resize an image in either the horizontal or vertical direction. It also shows how you can control the space taken up by the image.
5.	Tables Part 1	Discusses tables in WordprocessingML. It examines the structure of tables, and notes how WordprocessingML tables differ from HTML tables.
6.	Tables Part 2	Continues the discussion of tables in WordprocessingML. It examines table rendering in detail. In particular, it discusses the w:tblLook and w:cnfStyle elements, and how they are related.
7.	Sections, Headers, and Footers	When generating documents, you sometimes will want to create documents with multiple sections, so that you can control page layout separately for each section. In addition, you sometimes will want to create headers and footers for each section.
8.	Margins	Explains the markup for various ways of setting margins - for cells, paragraphs, and sections.
9.	Vertical Spacing Part 1	When generating word-processing documents, you sometimes want to control vertical spacing very explicitly. You may want to control how much space there is between lines in a paragraph, and how much space there is between paragraphs. This screen-cast shows how to control spacing between lines in a paragraph.
10.	Vertical Spacing Part 2	This screen-cast shows how to control spacing between paragraphs.
11.	Tables-of-Contents Part 1	TOC's in Open XML are not hard, but they require a bit of explanation. This screen-cast discussed the element in the settings part, and showed Word's behavior when that field is set.
12.	Tables-of-Contents Part 2	Discuss a bit more about the markup, and then walks through some example code that is part of the PowerTools for Open XML project. Shows how to insert a TOC at a desired point in a document, and then set the element. Then, when the user next opens that document, Word will present them with the option to repaginate and update the TOC.
13.	Fields and Hyperlinks Part 1	WordprocessingML fields are an important construct of Open XML markup. Hyperlinks, the TOC, dates, computed values, page references, and much more are represented by fields.
14.	Fields and Hyperlinks Part 2	Explains how to use a MarkupSimplifier utility program to make field markup more understandable. Walks through two cases where fields can be embedded in other fields.
15.	Starting Chapters on Odd Pages in WordprocessingML	Shows how to set up section breaks so that each section starts on an odd-numbered page.

Wiki Page: Recursive Pure Functional Transforms of XML

Eric White — Mon, 29 Apr 2013 14:52:00 GMT

This page contains links to all of the screen-casts in the screen-cast series on Recursive Pure Functional Transforms.

Many developers may already be familiar with certain aspects of functional programming. If you are one of those developers, feel free to skip those screen-casts that cover material that you already know, and continue watching at the point in this screen-cast series where you are not familiar with the content. This screen-cast series is oriented towards a typical object-oriented developer who has not had exposure to functional programming. The goal is to go from OO all the way through to writing recursive pure functional transformations, so it is necessary to cover such topics as lambda expressions, closures, and extension methods.

Also, two of the screen-casts in this series cover the semantics of XML in depth. If you are an XML expert, you can skip the screen-casts on XML. However, if you are not absolutely clear on namespaces, syntax for namespaces, default namespace semantics, data-centric vs. document-centric XML, mixed content, and the XML infoset, you may want to view the screen-casts on XML.

	Link	Summary
1.	[[Introduction to Recursive Pure Functional Transforms]]	This screen-cast introduces the series, and demos some concrete examples of recursive pure functional transforms. Watch this first.
2.	Primary Usage Scenarios (Part 1)	This screen-cast discusses the primary scenarios for Recursive Pure Functional Transformations. It demonstrates some rudimentary transforms, and shows a few of the 'transformation operators' that you will use in a pure functional transformation.
3.	Primary Usage Scenarios (Part 2)	This screen-cast continues with demonstrating some rudimentary transforms, and shows more of the 'transformation operators' that you will use in a pure functional transformation.
4.	Lambda Expressions	This screen-cast covers lambda expressions, which are a necessary language feature to know in order to write recursive pure functional transformations.
5.	Closures	This screen-cast covers closures, which is another necessary language feature to know in order to write recursive pure functional transformations.
6.	Laziness and Eagerness	This screen-cast covers the idea of laziness, and its opposite, eagerness. It is necessary for you to understand these concepts in order to write transformations that perform well.
7.	Extension Methods	This screen-cast covers extension methods. Extension methods enable us to write queries in a more natural fashion.
8.	Functional Purity	This screen-cast covers functional purity. Functional purity is a must in order to write reliable, robust, debuggable, readable, and understandable functional transformations.
9.	XML - Part One of Two	This screen-cast and the next screen-cast discuss the semantics of XML in detail. In order to discuss recursive pure functional transformations, it is necessary to understand the semantics of XML in depth. This screen-cast and the next one cover XML to the depths necessary to understand the markup in Open XML documents, and to understand writing recursive pure functional transformations of XML.
10.	XML - Part Two of Two	This screen-cast discusses document-centric vs. data-centric XML, covers all XML nodes, and then covers the XML infoset.
11.	LINQ to XML Functional Construction	This screen-cast covers some of the more interesting and important semantics of the XElement constructor, including the ability to pass nested collections, and the ability to pass null as an argument, either directly to the constructor or as an item in a collection.
12.	LINQ to XML Namespaces and Names	This screen-cast covers the details around controlling namespaces and names in LINQ to XML. In addition to explaining the mechanics of using the XNamespace and XName classes, it also covers controlling of serialization, and the differences between the .NET implementation of LINQ to XML and the JavaScript implementation of LINQ to XML (Ltxml.js).
13.	LINQ to XML Axis Methods	This screen-cast covers some interesting semantics around axis methods in LINQ to XML. It covers important performance implications, including the performance issues around querying in reverse document order. It also covers the interesting idioms around extension methods. We'll be making use of those idioms in recursive pure functional transforms of XML.
14.	The Identity Transform	This screen-cast introduces Recursive Pure Functional Transformations (RPFT) of XML, and then discusses the Identity Transform. We must know how to transform an XML tree into an identical XML tree using RPFT before we can start to morph and transform the tree in interesting ways.
15.	Replacing Elements	This screen-cast discusses 'replacing' an element from the source XML tree with a new element in the newly cloned XML tree. To demonstrate this scenario, we write a simple transform of Open XML WordprocessingML into HTML using just a few lines of code.
16.	Removing Elements	This screen-cast discusses 'removing' an element from the source XML tree when cloning the XML tree. To demonstrate this scenario, I write code that removes proofing errors and comments from a WordprocessingML document. This screen-cast shows taking advantage of the semantics of LINQ to XML where you can pass null as content to the XElement constructor. Null is simply ignored when passed as content. By transforming an element from the source tree to null, it is effectively removed from the newly cloned XML tree.
17.	Transforming Attributes	This screen-cast discusses transforming attributes in an XML tree. To demonstrate this scenario, I write code that removes the RSID attributes from a WordprocessingML document.
18.	Why Do Transform Methods Return Object?	This screen-cast discusses why transform methods return object instead of XElement, XNode, or XObject. To demonstrate why, I write code that transforms a single content control into three paragraphs.
19.	Complex Transforms of XML Elements	This screen-cast discusses an idiom / pattern that is useful when writing more complex transforms of an XML element. To demonstrate the idiom, I write code that conditionally sets the paragraph and character style for specific content in a document.
20.	Writing a Custom Axis Method	Sometimes the easiest way to accomplish a particular task is to write an axis method that returns just the elements in an Open XML document that you are interested in. Sometimes you want to write the axis method in a lazy fashion so that it performs as well as possible on large documents. You also may need to use some form or another of recursion as the easiest way to write your axis method. However, recursion and laziness are at odds. You can't write a method that uses 'yield return' in some places (to implement laziness) and uses 'return' in other places to implement recursion. This screen-cast shows how to get around this limitation in the C# language.

Wiki Page: Introduction to Open XML

Eric White — Wed, 03 Apr 2013 13:53:00 GMT

This page contains links to a set of introductory screen-casts on Open XML. It contains screen-casts on Open XML in general.

After watching the screen-casts in this series, dive deeper by viewing the screen-casts in the following series:

[[Introduction to WordprocessingML]]

[[Introduction to SpreadsheetML]]

Open XML at a high level
1.	Getting Started with Open XML Development	The first in a series of screen-casts for developers getting started in development with Open XML for the first time. In this video, I look at the Open XML standard from a high level. I discuss the resources that helped me get started, and point you to places to find additional resources.
2.	Tools	In this screen-cast, I introduce the three most important tools that you will want to be familiar with: Open XML Package Editor Power Tool for Visual Studio Open XML SDK 2.0 Productivity Tool PowerTools for Open XML
3.	WordprocessingML Scenarios	In this screen-cast I discuss the three most common scenarios around WordprocessingML: Document generation Data and content extraction Document transformation
4.	SpreadsheetML and PresentationML Scenarios	In this screen-cast I discuss the two most common scenarios around SpreadsheetML, which are a) Spreadsheet generation, and b) data extraction. In addition, I discuss the most common scenario for PresentationML, which is presentation generation.
5.	Developer Techniques Part 1	In this screen-cast I discuss some of the most powerful techniques and approaches for implementing Open XML applications.
6.	Developer Techniques Part 2	In this screen-cast I continue discussing some of the most powerful techniques and approaches for implementing Open XML applications.
7.	Overview of the Open Packaging Conventions Part 1	In this screen-cast, I introduce Open Packaging Conventions (OPC) and cover some of the basic information that you need to know.
8.	Overview of the Open Packaging Conventions Part 2	This screen-cast builds on the previous screen-cast, covering relationship types, relationship ids, internal/external relationships, explicit/implicit relationships, and more. These two videos on the Open Packaging Conventions cover what you need to know to do Open XML development.
9.	Directly Manipulating Open XML Documents	You can use basic tools such as Windows Explorer and XML editors to examine and modify Open XML documents. Even if you use such power tools as the Open XML Package Editor Power Tool for Visual Studio 2010, you should know how the basic mechanisms of Open XML documents work. To demonstrate how to use basic tools to examine and modify documents, this screen-cast explores the structure of embedded spreadsheets in word-processing documents.

Wiki Page: Introduction to Recursive Pure Functional Transforms

Eric White — Fri, 18 Jan 2013 16:01:00 GMT

This screen-cast introduces this series, and sets the stage for learning about how to write recursive pure functional transforms.

Return to the Table of Contents of this screen-cast series.

(Please visit the site to view this video)

Wiki Page: PowerTools for Open XML

bobm — Tue, 31 Jan 2012 15:59:00 GMT

PowerTools for Open XML consists of example code and guidance for implementing various types of functionality using the Open XML document format. At one level, PowerTools for Open XML consists of PowerShell cmdlets that enable you to process Open XML documents in interesting ways. At a deeper level, PowerTools provides C# source code that shows how to implement some interesting functionality using Open XML.

This page is the central repository for all PowerTools for Open XML content. Subscribe to the OpenXMLDeveloper RSS feed, follow OpenXmlDev, and EricWhiteDev on twitter, and subscribe to http://ericwhite.com/blog/feed/ to stay current with PowerTools progress.

PowerTools for Open XML was first released in June, 2008. Some of the content listed below applies to version 1.0 or 1.0 of PowerTools for Open XML. That content is still relevant to PowerTools for Open XML 2.0, so you may find it interesting to review that material. Our goal is to update all of those blog posts and screen-casts, so that all material is specifically relevant to PowerTools for Open XML 2.2 (and beyond). As those old blog posts are rewritten, we will post that content here on OpenXMLDeveloper.org, and will update the links below appropriately.

PowerTools for Open XML 2.2

Link	Summary
Announcing the release of PowerTools for Open XML 2.2	Highlights the key enhancements of PowerTools for Open XML version 2.2.
PowerTools.CodePlex.com	Download the PowerTools for Open XML 2.2.1 source code from CodePlex. The new version includes a spreadsheet pivot table example.
Screen-cast: Building, installing, and running PowerTools for Open XML 2.2	Short screen-cast that shows how to build and install PowerTools 2.2. Shows running a cmdlet to verify that the installation worked properly.
[[PowerTools for Open XML 2.0 Cmdlets]]	List of PowerTools for Open XML 2.2 cmdlets, with a short description of each one. Several of the cmdlets now have screen-casts recorded for them, so this is a good place to find out more about all of the cmdlets.
PowerTools 2.2 Code Design and Organization	Shows technical overview of the new code for PowerTools 2.2 cmdlets and core code.
Screen-Cast: Functional Programming Utility Methods and Classes for Open XML	Screen-cast that walks through the functions and classes in PtUtil.cs, which contains utility functionality that make it easier to work with Open XML using LINQ to XML.
Screen-Cast Creating Excel Pivot Tables	Screen-cast shows how to use the PowerTools methods to create pivot tables for Excel.
Screen-Cast Open XML Code to Create Pivot Tables	Screen-cast shows the Open XML code and elements needed to create a pivot table from scratch for Excel.

DocumentBuilder 2.0

DocumentBuilder 2.0 is a very important part of PowerTools for Open XML, and has its own resource center:

DocumentBuilder Resource Center

PowerTools for Open XML 1.1

Link	Summary
Announcing the Release of PowerTools for Open XML V1.1	An introduction to PowerTools for Open XML 1.1.
Move/Insert/Delete Paragraphs in Word Processing Documents using the Open XML SDK	Provides a detailed explanation of DocumentBuilder 1.1.
Accepting Revisions in Open XML WordprocessingML Documents	Discusses the RevisionAccepter class.

PowerTools for Open XML 1.0

Link	Summary
Automated Processing of Open XML Documents using PowerShell	An introduction to PowerTools for Open XML 1.0.