Eric White's Blog
Open XML, SharePoint, and Office
Open XML SDK
Back to TOCJust VideosCondensed TOC
.NET library for creating, querying, and modifying Open XML documents, spreadsheets, and presentations.
- Tutorial: Manipulating Content in a WordprocessingML Document
- Generating Documents from SharePoint with Open XML Content Controls
- Generating Open XML WordprocessingML Documents
- How to Extract Comments from Open XML Documents
- Open XML SDK and LINQ to XML
- Using the Open XML SDK and LINQ to XML to Remove Comments from an Open XML Wordprocessing Document
- Using the Open XML SDK and LINQ to XML to Remove Personal Information from an Open XML Wordprocessing Document
- Using LINQ to XML to Retrieve Content Controls in Word 2007
- OpenXmlCodeTester: Validating Code in Open XML Documents
- Creating Data-Bound Content Controls using the Open XML SDK and LINQ to XML
- How to Use altChunk for Document Assembly
- Inserting / Deleting / Moving Paragraphs in Open XML Wordprocessing Documents
- Remove Rsid Attributes and Elements before Comparing Open XML Documents
- Using LINQ to Query Excel Tables
- Inner Join of Two Excel Tables
- Joining LINQ to SQL and LINQ to Excel
- A More Robust Approach for Handling XName Objects in LINQ to XML
- Move/Insert/Delete Paragraphs in Word Processing Documents using the Open XML SDK
- Finding Paragraphs by Style Name or Content in an Open XML Word Processing Document
- Interrelated Markup in Open XML Word Processing Documents
- Generalized Approach to Open XML Markup References
- Comparison of altChunk to the DocumentBuilder Class
- Using DocumentBuilder with Content Controls for Document Assembly
- Comparison of Navigating Parts between System.IO.Packaging and the Open XML SDK
- Splitting Runs in Open XML Word Processing Document Paragraphs
- Comparing Two Open XML Documents using the Zip Extension Method
- Transforming Open XML Word-Processing Documents to XHtml
- Transforming Open XML Word-Processing Documents to XHtml (Post #2)
- Transforming Open XML Word-Processing Documents to Html (Post #3)
- Open XML WordprocessingML Style Inheritance (Post #4)
- Comparison of Html/CSS Tables to WordprocessingML Tables (Post #5)
- Assembling Paragraph and Run Properties for Cells in an Open XML WordprocessingML Table
- Accepting Revisions in Open XML Word-Processing Documents
- Implementing ‘Inheritance’ in XML
- Working with Numbering in Open XML WordprocessingML
- Accepting Revisions in Open XML WordprocessingML Documents
- Using the SharePoint Foundation 2010 Managed Client Object Model with the Open XML SDK 2.0
- Simplifying Open XML WordprocessingML Queries by First Accepting Revisions
- Writing Entity References using LINQ to XML
- Inserting Content That Contains Images Using altChunk
- Working with In-Memory Open XML Documents
- Enabling Better Transformations by Simplifying Open XML WordprocessingML Markup
- Retrieving the Default Style Name of an Open XML WordprocessingML Document
- ListItemRetriever: Accurately Retrieving Text of a Open XML WordprocessingML Paragraph
- Working with Numbered Lists in Open XML WordprocessingML
- Transforming WordprocessingML to Simpler XML for Easier Processing
- Validate Open XML Documents using the Open XML SDK 2.0
- Reducing Connaissance (Interconnectedness) and Increasing Robustness using LINQ
- Formats Supported for altChunk
- Modifying an Open XML Document in a SharePoint Document Library
- Testing for Base Styles in Open XML WordprocessingML Documents
- Using Content Controls to give Semantic Meaning to Content in Open XML WordprocessingML Documents
- Transforming Open XML WordprocessingML to XHTML Using the Open XML SDK 2.0
- Using the Open XML SDK from within a Managed Add-In
- Identifying Open XML Word-Processing Documents with Tracked Revisions
- Mastering Text in Open XML WordprocessingML Documents
- Developing with SharePoint 2010 Word Automation Services
- Processing all Content Parts in an Open XML WordprocessingML Document
- Table Markup in Open XML SpreadsheetML
- Creating Open XML WordprocessingML Tables with Vertically Merged Cells
- Generating Open XML WordprocessingML Documents
- Using a WordprocessingML Document as a Template in the Document Generation Process
- More Enhancements to the Document Template
- A Super-Simple Template System
- Video of use of Document Generation Example
- Release of V1 of Simple DOCX Generation System
- Getting Started with Open XML PowerTools Markup Simplifier
- Changing the Schema for this Open XML Document Generation System
- Generating Open XML WordprocessingML Documents using XPath Expressions in Content Controls
- Importing HTML that contains numbering using altChunk
- Updating Data for an Embedded Chart in an Open XML WordprocessingML Document
- Replacing a Picture in a Picture Content Control in an Open XML WordprocessingML Document
- Release of V2 of Doc Gen System: XPath in Content Controls
- Update Data behind an embedded Chart in an Open XML WordprocessingML Document
- How to Solve Open XML Developer Problems
- How to Insert a Page Break between Imported Content
- Iterating through all Content Controls in an Open XML WordprocessingML Document
- How to Create Protected Spreadsheets with Locked and Unlocked Cells
- Change the Schema for Simple Free Doc Generation System
- Open XML Markup Simplifier Application makes it easier to research WordprocessingML
- In-Depth Exploration of WordprocessingML Fields
- In-Depth Exploration of WordprocessingML Fields – Part 2
- Retrieving Fields in Open XML WordprocessingML Documents
- Screen-cast: Exploring Margins in Open XML WordprocessingML Documents
- Exploring Margins in Open XML WordprocessingML Documents
- Using XML DOM to Detect Tracked Revisions in an Open XML WordprocessingML Document
- Using XML DOM to Detect Tracked Revisions in an Open XML WordprocessingML Document
- Search and Replace Text in an Open XML WordprocessingML Document
- Open XML Presentation Generation using a Template Presentation
- Using Open XML WordprocessingML Documents as Data Sources
This tutorial shows how to apply the functional transformational approach and LINQ to XML to manipulate XML documents. The C# and Visual Basic examples query and manipulate information in Office Open XML WordprocessingML documents that are saved by Microsoft Word. (Article)
I’ll present some guidance and sample code for creating a document-generation system that uses SharePoint lists to populate tables in an Open XML word-processing document. (Article)
This is a blog post series on parameterized Open XML WordprocessingML document generation. (Article)
How to Extract Comments from Open XML Documents (Article)
This blog post has some code that uses the Open XML SDK and LINQ to XML to query an Open XML document. It also is an example of code written in the functional style. (Article)
Using the Open XML SDK and LINQ to XML to Remove Comments from an Open XML Wordprocessing Document (Article)
Using the Open XML SDK and LINQ to XML to Remove Personal Information from an Open XML Wordprocessing Document (Article)
Content controls are an effective way to add structure to word processing documents. This post explains how to write a very small LINQ query to retrieve the contents of content controls. (Article)
Validating Code in Open XML Documents. (Article)
Creating Data-Bound Content Controls using the Open XML SDK and LINQ to XML (Article)
Merging multiple word processing documents into a single document is something that many people want to do. An application built for attorneys might assemble selected standard clauses into a contract. An application built for book publishers can assemble chapters of a book into a single document. This post explains the semantics of the altChunk element, and provides some code using the Open XML SDK that shows how to use altChunk. (Article)
If you are making a tool to manipulate paragraphs in Open XML Documents, then this post lists some of the constraints that you must pay attention to. (Article)
A convenient way to explore Open XML markup is to create a small document, modify the document slightly in the Word user interface, save it, and then compare it with the Open XML Diff utility that comes with the Open XML SDK V2. However, Word adds extraneous elements and attributes that enable merging of two documents that have forked. These elements and attributes show up as changed, and obscure the differences that we’re looking for. An easy way to deal with this is to remove these elements and attributes before comparing documents. We can safely do so without changing the content of the document. This post presents a bit of code to do this. (Article)
Excel has a very cool feature where you can declare that a range of cells is a table. It is a feature that allows you to use Excel very much like a database. Because these tables are stored in Open XML documents, we can implement some simple extension methods and some classes so that we can query these tables using LINQ in a manner that is similar to querying a SQL database. This post presents a bit of code to do this. (Article)
I recently posted some code that allows you to use LINQ to query Excel tables. The source for these queries is the Open XML document – you don’t need to involve the Excel application to query the data in these tables. In that post, I presented a few examples of queries of various types. This post shows a join of two tables using the extension methods and classes presented in that post. (Article)
This post explains how to open the Excel spreadsheet, query a database using LINQ to SQL, and project a collection of an anonymous type that contains data from both data sources (Article)
Pre-atomizing XName objects enables you to write more reliable code that performs well. (Article)
Move/Insert/Delete Paragraphs in Word Processing Documents using the Open XML SDK (Article)
Finding Paragraphs by Style Name or Content in an Open XML Word Processing Document (Article)
Interrelated Markup in Open XML Word Processing Documents (Article)
An explanation of the issues around interrelated markup that DocumentBuilder (a class in PowerTools for Open XML) solves. (Article)
This post compares and contrasts two approaches to assemble multiple Open XML word processing documents into a single document (Article)
DocumentBuilder is an example class that’s part of the PowerTools for Open XML project that enables you to assemble new documents from existing documents. DocumentBuilder fixes up interrelated markup when assembling a new document from existing documents. This post shows how to use DocumentBuilder in concert with content controls to control the document assembly. (Article)
Comparison of Navigating Parts between System.IO.Packaging and the Open XML SDK (Article)
Splitting Runs in Open XML Word Processing Document Paragraphs (Article)
Comparing Two Open XML Documents using the Zip Extension Method (Article)
First post in a series on transforming Open XML WordprocessingML markup to XHtml (Article)
Second post in a series on transforming Open XML WordprocessingML markup to XHtml (Article)
Third post in a series on transforming Open XML WordprocessingML markup to XHtml (Article)
Explores and explains style inheritance in Open XML WordprocessingML (Article)
Compares HTML tables that use CSS styling to tables in Open XML WordprocessingML. Explains significant semantic differences. If you are familiar with HTML tables, this is an easy way to learn about WordprocessingML tables. (Article)
When you want to render a paragraph and its runs inside of a cell, you need to assemble the paragraph and run properties from a number of places. This post details how we assemble styling information from table styles, the formatting directly applied to tables, paragraphs, and runs, and the global default paragraph and run properties.
(Article)
(Article)
Revision tracking markup in Open XML word-processing documents is one of the more complex areas of the standard. Accepting tracked revisions makes processing of text in word-processing documents simpler. Learn about the Open XML markup that deals with revision tracking, and how to programmatically accept tracked revisions using the Open XML Format SDK 2.0. (Article)
Some XML vocabularies implement a powerful XML pattern that is analogous to inheritance in programming language type systems. Open XML WordprocessingML has these semantics around styles. When you define a new style, you can base this style on another style, and if the new style doesn’t explicitly define some aspect of the style, the new style ‘inherits’ this aspect from its base style. This post presents some code that uses one approach for implementing inheritance semantics. (Article)
When implementing a conversion of Open XML word processing documents to HTML, one of the interesting issues is accurately converting numbered and bulleted lists. You must pay special attention to them, because they impact the text that the document contains, but that text isn’t directly in the markup. If you are accurately extracting the text of the document, you must process some elements and attributes to assemble the correct text. (Article)
Revision tracking markup in Open XML word-processing documents is one of the more complex areas of the standard. If you first accept tracked revisions, it makes subsequent processing of text in word-processing documents much simpler. As an example, in my current project of transforming Open XML word-processing documents to XHtml, before doing the conversion, I accept tracked revisions in an in-memory WordprocessingDocument object. (Article)
The Microsoft SharePoint Foundation 2010 managed client object model enables you to write applications that are based on the Microsoft .NET Framework that access SharePoint content from clients without installing code on the server that runs SharePoint Foundation 2010. By using these two technologies together you can write client-side applications that work with Open XML documents that are stored in document libraries. (Article)
Simplifying Open XML WordprocessingML Queries by First Accepting Revisions (Article)
As delivered, it is difficult to write entities using LINQ to XML. This post presents a small hack that enables you to serialize XML entities. (Article)
Inserting Content That Contains Images Using altChunk (Article)
Working with Open XML Documents without loading from a file or saving to a file is important when you build applications that work with Microsoft SharePoint Server 2010 or Microsoft ASP.NET Web applications. In addition, some interesting scenarios benefit from creating an in-memory copy of an existing document. Learn how to create and work with in-memory copies of Open XML documents. (Article)
When transforming Open XML markup to another XML vocabulary (such as XHtml), you can sometimes simplify the transform by first transforming the original document to a new, valid WordprocessingML document that contains much simpler markup, and therefore is easier to process. This blog post describes a utility class, MarkupSimplifier, which is part of the PowerTools for Open XML project. (Article)
Whenever you write some Open XML SDK code that processes paragraphs based on style name, you need to retrieve the default style name for a document. (Article)
Accurately Retrieving Text of a Open XML WordprocessingML Paragraph. (This is one in a series of posts on transforming Open XML WordprocessingML to XHtml.) (Article)
Learn about lists in Open XML. Word 2010 documents often contain numbered and bulleted lists. This area of WordprocessingML is justifiably complex. Numbered lists and bulleted lists have many features, each used by a different set of uses. (Article)
Transforming WordprocessingML to Simpler XML for Easier Processing (Article)
Validate Open XML Documents using the Open XML SDK 2.0 (Article)
LINQ makes programs more maintainable. This post explains why. (Article)
This post lists formats supported for imported content by the altChunk importing functionality of Word. (Article)
On a fairly regular basis, I need to write an example that retrieves an Open XML document from a SharePoint document library, modify the document, and save the document back to the document library. The correct approach is to use a CAML query to retrieve the document. This post presents the minimum amount of code to use the SharePoint object model to do this. (Article)
Testing for Base Styles in Open XML WordprocessingML Documents (Article)
Using Content Controls to give Semantic Meaning to Content in Open XML WordprocessingML Documents (Article)
Transforming Open XML WordprocessingML to XHTML Using the Open XML SDK 2.0 (Article)
Using the Open XML SDK from within a Managed Add-In (Article)
Determining whether an Open XML WordprocessingML document contains tracked revisions is important. You can significantly simplify your code to process Open XML WordprocessingML if you know that the document does not contain tracked revisions. This article describes how to determine whether a document contains tracked revisions. (Article)
Understand how to reliably retrieve text from Open XML WordprocessingML documents. (Article)
Learn to use Word Automation Services to do server-side document conversions to and from a variety of document formats. By using the Open XML SDK, you can accomplish tasks that are difficult such as updating the table of contents or repaginating documents. (Article)
This post shows how to search for all content controls in a document, regardless of whether those content controls are in the main document part, in the headers/footers, or in endnotes/footnotes. This example uses LINQ to XML. (Article)
This post presents a summary of the Open XML SpreadsheetML markup that you use to define or query a table. (Article)
Create tables with vertically-merged cells in Open XML WordprocessingML documents. (Article)
Introduces this blog post series on generating WordprocessingML documents, outlines the goals of the series, and describes various approaches that I may take as I develop some document generation examples. (Article)
This post examines the approaches for building a template document for the document generation process. A template document is a DOCX document that contains content controls that will control the document generation process. (Article)
Discusses enhancements that enable the template designer to write infrastructure code for the document generation process. Also discusses how the document generation process will work. (Article)
This post details my super-simple template system, which will be more than adequate for building this first version of a doc gen system. (Article)
First version of this document generation system that is driven by C# code that you write in content controls in a Word document. As an intro, he has recorded a small screen-cast that shows the doc gen system in action. (Article,Video)
This is a preliminary version of a simple DOCX generation system, which you can download, unzip, and try. This article lists two screen casts, first 90 second screen-cast shows how to run the doc gen system after you download and unzip the zip file.The second 2 1/2 minute video shows using the document generation system at scale. It shows generating 3000 documents in under a minute. (Article,Video)
In PowerTools, in the HtmlConverter project, there is a class called MarkupSimplifier, which can remove proofing errors. In addition, it can simplify WordprocessingML markup in a variety of ways, including removal of comments, content controls, and etc.
Here is a small screen-cast that shows the use of MarkupSimplifier. This screen-cast uses Open XML Package Editor Power Tool for Visual Studio 2010. (Article,Video)
Here is a small screen-cast that shows the use of MarkupSimplifier. This screen-cast uses Open XML Package Editor Power Tool for Visual Studio 2010. (Article,Video)
In the following screen cast shows the process of adjusting the XML data that drives the document generation system, as well as adjusting the template document to use that data. (Article,Video)
Introduces the approach of configuring the document generation process by entering XPath expressions in content controls in a template document. (Article)
Importing HTML that contains numbering using altChunk (Article)
This blog post shows how to update Data in an embedded chart in an Open XML WordprocessingML Document. (Article)
You may have a picture content control where you want to replace the picture with a different picture. This post shows the Open XML SDK V2 code that is necessary to find a picture content control with an alias of “MyPicture”. It then finds the ImagePart, and then replaces the contents of the image part with a different image. (Article)
In this post, I release V2 of this simple document generation example. I provide a 2-minute screen-cast that shows the document generation process, generating 3000 documents in less than 30 seconds. (Article,Video)
11 minute video that walks through the process of embedding a chart in a word-processing document, and then programmatically updating that data so that the chart reflects the new data. (Article,Video)
This screen-cast shows the general approach that I use to solve Open XML developer problems. The general gist of the approach is that I create two documents, one without the feature of interest, and one with. I then use the Open XML SDK productivity tool to compare the two and find out the differences. I then use the Open XML Package Editor Power Tool for Visual Studio 2010 to examine the markup, and I use the PDF form of the ECMA 376 Second Edition Part 1 to research the markup. (Video)
Describes how to Insert a Page Break between Imported Content. (Article)
Sometimes you want to iterate over all content controls in a WordprocessingML document. You may want to search for a content control with a specific tag, or you may want to process all content controls of a specific type. This blog post shows how to iterate over all content controls. (Article)
7-minute video that shows markup related to protected sheets with locked and unlocked cells. (Article,Video)
Three minute screen-cast that demonstrates changing the schema for simple document generation system that you configure by placing XPath expressions in content controls. (Article,Video)
This article describes WinForms Application that makes it easier to research OpenXML markup, by creating documents, altering documents, and then comparing the two documents. The MarkupSimplifier class (which is part of the PowerTools for Open XML project) can help, but as downloaded from CodePlex it is simply a class. (Article,Video)
First video in a two-part series that explains how field markup works. (Article,Video)
See how to use a MarkupSimplifier utility program to make field markup more understandable. In walk through two cases where fields can be embedded in other fields. (Article,Video)
The markup for fields in WordprocessingML documents is fairly involved. This post presents some code to accurately parse field markup. (Article)
This blog has recorded short screen-cast that explores some approaches to setting margins in a word-processing document. It shows setting margins for cells, paragraphs, and sections. (Article,Video)
Article has a short screen-cast that shows the markup for various ways of setting margins – for cells, paragraphs, and sections. In addition, the video shows general approach for researching Open XML markup. (Article,Video)
Using XML DOM to Detect Tracked Revisions in an Open XML WordprocessingML Document (Article,Video)
Many developers do not have option of using LINQ to process XML. This post presents a code which uses XML DOM API to detect tracked revisions (Article)
Search and Replace Text in an Open XML WordprocessingML Document (Article,Video)
Article discusses an approach of creating an Open XML template presentation that you can use to generate multiple presentations from data. (Article,Video)
You can use Microsoft Office 2010 or the 2007 Microsoft Office system as part of a comprehensive collaboration system. You can send preformatted documents to your customers and extract data and content from those documents after they are returned. This article contains guidance and links to other resources to help you get started. (Article)
I have an application which generates output documents in MS Word and PDF format. PDF is generated from MS Word by using the Word 2007 Document.ExportAsFixedFormat method.
The generated PDF doesn’t display the images which were placed in the Content Controls of the Word document.
The word document generates perfectly with all the images and contents.
Is there a way to fix this issue or is it possible to remove the content controls from the word document without removing the image inside it ?
thanks,
Yes it certainly is possible. Best way to see the markup differences – use word to remove the content control and use the open xml sdk productivity tool to compare before and after removal.
-Eric
Is there a way to programmaticaly change the relationship target in the file “settings.xml.rels” which resides inside the word folder in a docx file? It points to our old server and causes problems when opening these documents. (takes very long)
Thanks,
Frank
Sure, you can go into the document, programmatically find all external relationships, and then delete and re-add each erroneous one. For a deep-dive into the Open Packaging Conventions (including discussion of external relationships), see:
http://openxmldeveloper.org/blog/b/openxmldeveloper/archive/2012/05/10/screen-cast-overview-of-the-open-packaging-conventions.aspx
http://openxmldeveloper.org/blog/b/openxmldeveloper/archive/2012/05/15/screen-cast-overview-of-the-open-packaging-conventions-part-2.aspx
This would be a great blog post. I’ve added it to my list. I have a few that must be finished first, but this would be a really useful example.
-Eric
Thanks for your quick response. i’m defenitly going to look into that.
I tried a quick test program, but it says it can’t find the relationship? Am i missing something?
Frank
class Program
{
static void Main(string[] args)
{
string fileName = @"E:\admin\Test.docx";
using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(fileName, true))
{
MainDocumentPart mainPart = wordDoc.MainDocumentPart;
ExternalRelationship relationship = mainPart.GetExternalRelationship("rId1");
Console.WriteLine(relationship.Uri.ToString());
}
Console.Read();
}
}
}
/* the actual xml in the file word/_rels/settings.xml.rels
*/
sorry, here is the xml:
Relationship TargetMode=”External” Target=”file:///\\T610-SBS-SRV\Public\Sjablonen\Word2007\Begeleidend%20schrijven.dotx”
Type=”http://schemas.openxmlformats.org/officeDocument/2006/relationships/attachedTemplate” Id=”rId1″