OpenXML
Back to TOCJust VideosCondensed TOC
IS29500 / Ecma376
- Tutorial: Manipulating Content in a WordprocessingML Document
- Generating Documents from SharePoint with Open XML Content Controls
- Generating Open XML WordprocessingML Documents
- OpenXML Content Types in an XML Document
- How to Extract Comments from Open XML Documents
- The Legacy Hashing Algorithm in Open XML
- Automated Processing of Open XML Documents using PowerShell
- 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
- Removing Comments and Personal Information, and Accepting Revisions in an Open XML Document Stored in SharePoint
- Using LINQ to XML to Retrieve Content Controls in Word 2007
- OpenXmlCodeTester: Validating Code in Open XML Documents
- How to Create a List of All Parts in an Open XML Document
- Bulk Convert DOC to DOCX
- Transforming Open XML Documents using XSLT
- Transforming Open XML Documents to Flat OPC Format
- Transforming Flat OPC Format to Open XML Documents
- The Flat OPC Format
- 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
- Working with In-Memory Open XML Documents
- Modifying Open XML Documents using the SharePoint Object Model
- A More Robust Approach for Handling XName Objects in LINQ to XML
- Writing Succinct Code to move XElement and XAttribute Objects from One LINQ to XML Tree to Another
- Modifying Open XML Documents that are in SharePoint Document Libraries using Web Services
- Move/Insert/Delete Paragraphs in Word Processing Documents using the Open XML SDK
- Seven Key Benefits of Open XML
- Finding Paragraphs by Style Name or Content in an Open XML Word Processing Document
- The Composability Thought Process for LINQ
- Ease of Maintenance of LINQ Code
- Ease of Maintenance of LINQ Code (2)
- Creating a Template Open XML Document in Memory
- Interrelated Markup in Open XML Word Processing Documents
- Generating a Custom Letter using PowerTools for Open XML and PowerShell
- Generalized Approach to Open XML Markup References
- Comparison of altChunk to the DocumentBuilder Class
- PowerTools for Open XML
- Getting Started with PowerTools for Open XML Development
- 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
- Essentials of the Open Packaging Conventions
- 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
- Align Attributes when Formatting XML using LINQ to XML
- Using the SharePoint Foundation 2010 Managed Client Object Model with the Open XML SDK 2.0
- Designing a Content Publishing System
- How to Control Sections when using DocumentBuilder
- Simplifying Open XML WordprocessingML Queries by First Accepting Revisions
- Associating Data with Content Controls
- Writing Entity References using LINQ to XML
- Inserting Content That Contains Images Using altChunk
- Programmatically Limiting Styles in Word
- Working with In-Memory Open XML Documents
- Increasing Performance of Word Automation for large amount of data using Open Xml SDK
- 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
- Building Publishing Systems that Use Word 2010 or Word 2007
- Building Document Generation Systems from Templates with Word 2010 and Word 2007
- Transforming WordprocessingML to Simpler XML for Easier Processing
- Using Nested Content Controls for Data and Content Extraction from Open XML WordprocessingML Documents
- 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
- Open XML Package Editor Power Tool for Visual Studio 2010
- 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
- The Second Iteration of the Template Document
- More Enhancements to the Document Template
- Generating C# code from an XML Tree using Virtual Extension Methods
- A Super-Simple Template System
- Text Templates (T4) and the Code Generation Process
- 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
- Updating Data for an Embedded Chart in an Open XML WordprocessingML Document
- Importing HTML that contains Numbering using altChunk
- 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
- Review of XPath Semantics of LINQ to XML
- 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
- 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
- Exploring Table Markup in Open XML SpreadsheetML
- Open XML Presentation Generation using a Template Presentation
- Introduction to DocumentBuilder 2.0 – Screen-Cast 1 of 3
- Introduction to DocumentBuilder 2.0 – Screen-Cast 2 of 3
- Introduction to DocumentBuilder 2.0 – Screen-Cast 3 of 3
- Query Open XML Spreadsheets in VB.NET using LINQ
- Introducing TextReplacer: A New Class for PowerTools for Open XML
- Exploring Tables-of-Contents in Open XML WordprocessingML Documents
- Exploring Tables-of-Contents in Open XML WordprocessingML Documents (Part 2)
- Exploring Tables-of-Contents in Open XML WordprocessingML Documents (Part 3)
- Remove Speaker Notes from an Open XML Presentation
- Notes about the Microsoft Public License
- Short and Sweet Intro to DocumentBuilder 2.0
- What is the glossary document used for?
- Adding/Updating the TOC in OpenXML WordprocessingML Documents (4th Screen-cast
- Updating the TOC in a WordprocessingML Document using an AutoOpen Macro
- How to Retrieve the Text of a Bookmark from an OpenXML WordprocessingML Document
- Replacing Text of a Bookmark in an OpenXML WordprocessingML Document
- Advanced use of DocumentBuilder 2.0
- Use the Open XML Package Editor together with Word to Research Markup
- Custom XML Parts and Content Controls
- Exploring the Set-OpenXmlString CMDLET in PowerTools for Open XML 2.2
- Getting Started with Open XML Development
- Getting Started with Open XML Development – Part II Tools
- Merge Comments from Multiple OpenXML WordprocessingML Documents into a Single Document
- Split-OpenXmlDocument cmdlet in PowerTools for Open XML
- Exploring the Markup for Bibliographies in OpenXML WordprocessingML
- Screen-Cast: Functional Programming Utility Methods and Classes for Open XML
- Screen-Cast: Sections, Headers, and Footers
- Screen-Cast: Write Simpler SpreadsheetML when Generating Spreadsheets
- Open XML Specific Utility Methods and Classes in PowerTools for Open XML
- Displaying an Open XML WordprocessingML Document in a Web Browser Control in Windows Forms
- 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)
In Open XML, there is a feature whereby you can restrict editing, and allow only users who have a password to modify the file. Note that this isn’t a password that protects the file from viewing or modification. (Article)
Processing Open XML documents using PowerShell is a powerful approach for creating, modifying, and transforming Open XML documents. The PowerTools for Open XML are examples and guidance that show how to do this. They consist of PowerShell cmdlets, and a number of example scripts that demonstrate the use of the cmdlets. Examples include automated word processing document and spreadsheet generation, and preparing documents for distribution external to a company, including removing comments, accepting revisions, applying a uniform theme to them, and applying a watermark to them. (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)
This post presents a custom application page in SharePoint that uses Open XML, the Open XML SDK and LINQ to XML to accept revisions, remove comments, and remove personal information from an Open XML word processing 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)
Microsoft has a bulk conversion utility that can convert multiple DOC files to DOCX files. This blog post presents very basic information on its use. (Article)
Transforming Open XML documents using XSLT is an interesting scenario, but before we can do so, we need to convert the Open XML document into the Flat OPC format. We then perform the XSLT transform, producing a new file in the Flat OPC format, and then convert back to Open XML (OPC) format. This post is one in a series of four posts that present this approach to transforming Open XML documents using XSLT. (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)
Sometimes you want to work with Open XML documents in memory. This blog post presents a bit of code that shows how to work with in-memory documents as a MemoryStream. (Article)
When working with Open XML documents from within SharePoint, you may want to open a specific document, modify it in some way, and then save it, either replacing the original document, or saving to a new location. (Article)
Pre-atomizing XName objects enables you to write more reliable code that performs well. (Article)
This post presents an interesting idiom of LINQ to XML that makes it easy to write short, succinct code when creating one XML tree from another. (Article)
When using the Open XML SDK with SharePoint web services, one of the most basic operations is to get a document from a document library using web services, modify it using the Open XML SDK (and LINQ to XML), and save it back to the document library. This post describes how to do this, and provides a sample in C#. (Article)
Move/Insert/Delete Paragraphs in Word Processing Documents using the Open XML SDK (Article)
Seven Key Benefits of Open XML (Article)
Finding Paragraphs by Style Name or Content in an Open XML Word Processing Document (Article)
This post demonstrates the thought process of developing a somewhat more involved query. (Article)
I believe that it is easier to maintain code that is written in the functional style. For one thing, this is the very reason for many of the characteristics of functional code. No state is maintained, so we don’t have to worry about corrupting any state. If a variable is in scope, then the variable has its value, and it will never have another value. And the idea of composability is all about being able to inject/surround/refactor code without making it brittle. In this post, I’m going to show the process of maintaining and modifying a somewhat more involved query. (Article)
In two previous posts, I developed a somewhat involved query to search through a word processing document for style names and/or paragraph content. This is a query that I’m developing for the PowerTools for Open XML project. In those posts, as I evolved the query, I showed each iteration of it, highlighting the changes I made. This post continues modifying that query. (Article)
Interrelated Markup in Open XML Word Processing Documents (Article)
Lawrence Hodson has written a cool article (with accompanying example PowerShell scripts) published on OpenXmlDeveloper.org that uses PowerTools for Open XML v1.1 to generate a letter. His scenario is interesting – he generates a service level agreement (SLA) report based on information that he retrieves using PowerShell cmdlets. His example includes assembling the document from multiple source documents and making use of content controls that are bound to custom XML. (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)
Combining the technologies of PowerShell and Open XML is a powerful and convenient way to do server-side document processing. The PowerTools for Open XML are sample source code and guidance for developers showing how to build PowerShell cmdlets that can create and modify Open XML documents. Also included are a number of examples of PowerShell scripts that use the cmdlets. (Article)
There are a number of resources and guidelines that PowerTools for Open XML developers need in order to write PowerShell cmdlets for processing Open XML documents. This post presents a few tips for getting started developing PowerTools cmdlets. (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)
Understanding Open Packaging Conventions is key to working with Open XML. Review the structure and learn about the underlying architecture. Compare the different approaches to working with the Open Packaging Conventions and the Open XML Formats. (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)
Sometimes an XML element contains a large number of attributes, and the values of the attributes may be long. When written to the console, such lines wrap, making it hard to read the XML. This post shows how you can use appropriate settings for an XmlWriter so that the attributes are aligned, and each attribute is on a separate line. (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)
Explains an approach for using styles and content controls for implementing an authoring environment for a publishing system. (Article)
When using DocumentBuilder, sometimes you want to control is how sections are copied to the document you are building. Sections carry a fair amount of formatting information, including the layout of the page, and the headers and footers that will be used for the section. (Article)
Simplifying Open XML WordprocessingML Queries by First Accepting Revisions (Article)
You may have the need to associate arbitrary amounts of data with each content control. You may also have the requirement that the document author can create and edit this auxiliary information. Content controls don’t directly have a facility for storing and maintaining such information, but there is a fairly easy approach to solving this problem. (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)
Authoring in Word makes publishing systems very user friendly. After the user authors his or her paper, you can transform Open XML WordprocessingML to the desired output format. Some publishing systems use an approach of limiting the paragraph and character styles that the author can use. This can help in writing a more deterministic transform to the output format. (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)
Sometimes in the process of building a managed add-in, you want to insert a large amount of content into a document – perhaps hundreds of paragraphs or hundreds of rows in a table. Using Word automation can be slow. It was not designed for this scenario. But there is a way to dramatically speed up this process by processing/creating Open XML from within the managed add-in using the Open XML SDK. (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)
Using Word 2010 or Word 2007 as an important part of a content publishing system is a powerful approach. This article contains guidance and direction about how to build a content management system, and transforming Open XML WordprocessingML documents to other document formats. (Article)
Some business scenarios require generation of many documents by using a template document and a data source. This article contains guidance for this scenario and links to MSDN articles and blog posts. (Article)
Transforming WordprocessingML to Simpler XML for Easier Processing (Article)
Data and content extraction is one of the scenarios where content controls are very useful. Data extraction is when you are extracting specific numbers or string values from a document. Content extraction is when you are extracting formatted WordprocessingML tables and paragraphs, and constructing another document from that content. (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)
Open XML Package Editor Power Tool for Visual Studio 2010 (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)
This post presents the second iteration on a template document to be used for a 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)
One integral part of my scheme for building a document generation system is to write some code that generates C# code to create an arbitrary XML tree. I want to transform the markup for the main document part into C# code that will produce that main document part, with the exception that at various points where I find content controls, I want to alter the transformation as appropriate. The first task is to write code that produces C# code that will create any arbitrary XML tree. (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)
Text templates are very cool, and have applicability in the Open XML document generation process. This post details my notes and thoughts on text templates. (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)
Embedding charts in a word-processing document is a good way to put together documents that display graphical data. When you embed a chart in a document, an Open XML SpreadsheetML workbook is stored as an embedded part in the WordprocessingML document. The spreadsheet contains the data behind the chart. When you maintain that data, Word starts Excel, opening that embedded spreadsheet. (Video)
It is possible to import HTML that contains bullets or numbering using atlChunk. Word 2007 or 2010 imports the numbered items and creates the appropriate WordprocessingML markup, as well as necessary numbering styles, to create a word-processing document that looks as close as possible to the original HTML. (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)
In this post, I review the XPath semantics of LINQ to XML, and show some concrete examples of how I use those semantics in the XPath-in-Content-Controls approach to Open XML WordprocessingML document generation. (Article)
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)
Sometimes when researching and examining Open XML WordprocessingML markup, extraneous markup that is not relevant to the issue at hand gets in the way of seeing what is going on. If you are researching markup by creating documents, altering documents, and then comparing the two documents, as detailed in How to Solve Open XML Developer Problems, your research process is made significantly easier by simplifying the markup before comparing. (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)
Tables are a convenient and useful feature of Open XML SpreadsheetML. This post explores table markup, and links to a screen-cast that shows how to create a table programmatically
(Video)
(Video)
Article discusses an approach of creating an Open XML template presentation that you can use to generate multiple presentations from data. (Article,Video)
This post contains the first of three screen-casts that introduces DocumentBuilder 2.0, talks about interrelated markup, and explores how DocumentBuilder solves developer issues with regards to interrelated markup. While this screen-cast is a bit long (20 minutes), it will be important for developers using DocumentBuilder who want to know how DocumentBuilder works. (Video)
This screen-cast builds on the previous screen-cast where I walk through the process of transferring comments from multiple source documents into a destination document. In this screen-cast, I insert images into the comments. This introduces some complexity – the comments part has a relationship to an image part. (Video)
This screen-cast builds on the previous two screen-casts where I walk through the process of transferring comments from multiple source documents into a destination document. In this final screen-cast in the series, I walk through some of the code in DocumentBuilder 2.0 – I explain how the code is data-driven to make it more robust, and discuss the structure of the code and how DocumentBuilder 2.0 works. (Video)
When working with SpreadsheetML, one of the most common needs is to retrieve the data from a worksheet or a table in as easy a fashion as possible. There has been a fair amount written for C# developers to do this, but not nearly as much for VB.NET. (Video)
This code to search-and-replace in an Open XML WordprocessingML document uses LINQ to XML to implement a functional transform. (Video)
Many Open XML developers need to generate documents, and then generate and insert an updated table-of-content for the document. TOC’s in Open XML are not hard, but they require a bit of explanation. This blog post introduces the first of several screen-casts around Open XML WordprocessingML TOCs. (Video)
In this screen-cast, I discuss a bit more about the markup, and then walk through some example code that is part of the PowerTools for Open XML project. The example code 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. (Video)
In this screen-cast, I show how you can use Word Automation to open and save the document, thereby causing all fields to be updated, including the TOC. (Video)
When sending a presentation to customers or others outside of your organization, you often want to remove speaker notes. It is easy enough to use PowerPoint automation to remove the speaker notes, but if you are processing presentations server-side, you probably don’t want to rely on automation to accomplish this task. (Video)
The blog post presents some links around the Microsoft Public License (Ms-PL). PowerTools for Open XML are licensed under the Microsoft Public License. (Article)
This is a short screen-cast that explains what DocumentBuilder 2.0 is all about, in less than seven minutes. (Video)
The glossary part is used for the placeholder text for content controls. In DOTX, it is used for the content for quick parts. This 3 minute video demonstrates these two uses. It also shows a little trick you can do with content controls and the glossary part. (Video)
Shows how to use Word Automation Services to repaginate a document and update the table-of-contents. (Video)
In the screen-cast that I present in this post, I show how you can add a TOC using the Open XML SDK, and then modify the normal.dotx, adding a macro, so that whenever you open a document that contains a TOC, Word repaginates the document and updates the TOC. (Video)
Sometimes developers use bookmarks to delineate text in an OpenXML WordprocessingML document. Then, as part of a larger system, they want to retrieve the text of that bookmark to process in some fashion. (Video)
In a previous screen-cast, I showed how to retrieve the text of an OpenXML WordprocessingML document. In this post and screen-cast, I introduce some code that enables you to replace the text of a bookmark. (Video)
The default approach to working with DocumentBuilder 2.0 enables you to take bits and pieces of multiple documents and assemble them together into a new document. However, there is an interesting scenario that this approach does not handle. You may want to import a document into a cell in a table, into a text box, or into a content control. You can do this with DocumentBuilder 2.0. This video shows how. (Video)
A question was recently posed to me – what is the best way to look at markup and the rendering of the markup simultaneously. This is important, for instance, when you are experimenting with markup and determining the exact markup that you want to generate. (Video)
Using custom XML parts and content controls, we can create smarter documents that provide needed functionality for users. Content controls and custom XML parts enable us to integrate business data with content in a document. In addition, content controls can be used to delineate data or content in a document. (Video)
The Set-OpenXmlString cmdlet enables interesting functionality – you can do a search-and-replace of content without automating Word, and you can search-and-replace in many documents at once. The Set-OpenXmlString can search-and-replace in both WordprocessingML documents and PresentationML documents. (Video)
This is the first in a series of screen-casts that are specifically for a developer starting development with Open XML for the first time. If you are starting out in Open XML development, watch this first. (Video)
In this screen-cast, I introduce the three most important tools that you will want to be familiar with: 1) Open XML Package Editor Power Tool for Visual Studio, 2) Open XML SDK 2.0 Productivity Tool, 3) PowerTools for Open XML. (Video)
Introduces code that shows how to merge comments from multiple WordprocessingML documents into a single document. (Video)
In document processing parlance, shredding a document is the process of dividing a source document according to certain rules, and creating a number of documents from the source document. This is useful, for instance, when you have a huge document, and you want to divide it into multiple documents to hand off to different authors or editors. Then, after all edits have been completed, you can merge the various parts back into a complete document. (Video)
This screen-cast walks through bibliography markup. Bibliographies use custom XML parts, so in addition to showing the field markup for citations and the generated bibliography, the screen-cast discusses the mechanism by which you can determine the purpose of any particular custom XML part. (Video)
In the process of developing the PowerTools for Open XML, over the years, I have developed some needed core functionality and utility methods, particularly for writing LINQ to XML code that queries and transforms Open XML documents. (Video)
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. (Video)
This screen-cast presents a small tip that can make it easier to write code to generate SpreadsheetML. You can avoid the complications of updating the shared string table by using the idea in this tip. (Video)
Screen-cast that introduces a number of OpenXML specific utility methods and classes in PowerTools for Open XML. These classes and methods are in the PtOpenXmlUtil.cs module. (Video)
Screen-cast that shows how to convert a WordprocessingML document to XHtml and then display that XHtml in a Web Browser control in a Windows Forms application. (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)