OpenXML Developer : .NET (C#, VB, J#, C++/CLI)

ECMA-376 and ODF1.1 Implementer notes for Office 2007 SP2 released

jenw — Wed, 11 Feb 2009 19:23:00 GMT

You may have seen that the implementer notes for Office 2007 SP2 for ECMA-376 and ODF1.1 are now available.

ECMA-376 Implementer Notes for Office 2007 SP2

On the ECMA-376 Implementer Notes Site you will find detailed information about Office’s support for the ECMA-376 specification. These notes will help ECMA-376 implementers interoperate with Office by explaining, among other things, Office’s support for optional features, range restrictions for attribute values, and how Office’s functionality maps to Open XML constructs.

ODF 1.1 Implementer Notes for Office 2007 SP2

On the Open Document Format (ODF) implementer notes site you will find detailed information about Office’s support for each section of the OASIS ODF 1.1 specification. These notes will help promote interoperability by providing details that others can use as reference points for their own applications. For example, they include information about which attributes and elements are supported, as well as details about how Office functionality maps to specific constructs in the ODF specification. For a higher-level overview of Microsoft’s general approach to ODF implementation, see Guiding Principles for Office’s ODF Implementation.

Open XML SDK V2 CTP available

ecullins — Tue, 16 Sep 2008 19:27:00 GMT

Open XML SDK V2. The first CTP of V2 of the Open XML SDK is now available for download.

This release includes a high-level DOM (document object model) for Open XML development, as well as several tools to streamline Open XML development:

The OpenXmlDiff utility identifies differences in the markup in two Open XML documents.
The Open XML Class Explorer helps you determine which strongly typed class to use for a specific task, and includes the text of the relevant section of the ECMA-376 spec for each class.
The Open XML Document Reflector takes a target document as input, and with a few clicks it shows you the C# code needed to generate that document (or a section of it) with the Open XML SDK.

See Eric White's blog post for more details.

Open XML Power Tools released

dmahugh — Thu, 12 Jun 2008 14:49:00 GMT

The Open XML Power Tools, an open source project on Codeplex to create PowerShell cmdlets for automating Open XML document management tasks, has been released on Codeplex at http://www.codeplex.com/PowerTools. Non-developers can use these cmdlets to build PowerShell scripts that automate processes such as adding a digital signature or watermark to documents, removing metadata, or updating Custom XML parts. The first release includes these cmdlets:

Accept-OpenXmlChange
Add-OpenXmlContent
Add-OpenXmlDigitalSignature
Add-OpenXmlDocumentIndex
Add-OpenXmlDocumentTOA
Add-OpenXmlDocumentTOC
Add-OpenXmlDocumentTOF
Add-OpenXmlPicture
Export-OpenXmlSpreadsheet
Export-OpenXmlToHtml
Export-OpenXmlWordprocessing
Get-OpenXmlBackground
Get-OpenXmlComment
Get-OpenXmlCustomXmlData
Get-OpenXmlDigitalSignature
Get-OpenXmlDocument
Get-OpenXmlFooter
Get-OpenXmlHeader
Get-OpenXmlStyle
Get-OpenXmlTheme
Get-OpenXmlWatermark
Lock-OpenXmlDocument
Remove-OpenXmlComment
Remove-OpenXmlDigitalSignature
Set-OpenXmlBackground
Set-OpenXmlContentFormat
Set-OpenXmlContentStyle
Set-OpenXmlCustomXmlData
Set-OpenXmlFooter
Set-OpenXmlHeader
Set-OpenXmlStyle
Set-OpenXmlTheme
Set-OpenXmlWatermark

Open XML developers will find these cmdlets useful as source-code samples for all of the above topics, and also as samples of how to use Microsoft's Open XML Formats SDK (which was used for the development of the power tools). For detailed information about the Open XML Power Tools see Eric White's blog post "Processing Open XML documents server-side using PowerShell.

Open XML Formats SDK Version 1 released

dmahugh — Wed, 11 Jun 2008 11:16:00 GMT

Microsoft announced this week the release of Version 1 of the Open XML Formats SDK, an API that allows .NET developers to read, write, and modify Open XML documents. Follow these links to download the API or get more information:

Open XML Formats SDK download link:
http://go.microsoft.com/fwlink/?LinkId=120908
Open XML Formats SDK documentation:
http://msdn.microsoft.com/en-us/library/bb448854.aspx
MSDN Forum: Open XML Format SDK:
http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=1647&SiteID=1
What's New in the Open XML Format SDK 1.0:
http://msdn.microsoft.com/en-us/library/cc471858.aspx

Additional information is available in blog posts by Erika Ehrli and Doug Mahugh.

Microsoft announces Open XML SDK roadmap

dmahugh — Thu, 13 Mar 2008 20:08:00 GMT

Microsoft unveiled today the roadmap for the Open XML SDK that was released last June as a CTP (Community Technology Preview) version. After collecting developer feedback through the CTP release, they've put together a two-phased release plan to get developers a released version of the API quickly (May of this year) and then build on that with additional functionality for a final version in the Office 14 timeframe.

Links to resources for this article:

The Open XML API will be released in two versions. Version 1.0 will include an updated version of the CTP that was released in June 2007, to be released in April 2008 with a final release of Version 1.0 in May 2008. Version 2.0 will be available as a CTP version this summer, and the final release will be part of the Office 14 wave of products and technologies. (Office "14" is the next major release of Microsoft Office.)

Both versions will be free downloads on MSDN, available at the Open XML SDK page. Version 1.0 will include the following functionality:

Strongly typed access to parts within Open XML documents (a few typical examples: classes for the main body part or style part of a word-processing document, the workbook and worksheet parts in a spreadsheet document, or the presentation and slide parts in a presentation document)
Simple access to the parts within an Open XML document, relative to other existing APIs (example: one line of code to retrieve or replace a part)
“Linq-friendly” annotation capabilities, to allow developers to use the SDK with emerging Linq to XML technology (Eric White's blog has a code sample demonstrating this capability)
Consistency and naming changes per feedback from the developer community since the June 2007 CTP version, including adherence to .NET naming conventions
The May 2008 RTW (released to web) version will be ready to go live, and developers can build shipping products on it

Version 2.0 will add the following capabilities:

Content object model including additional classes and methods for simplifying developer work within parts (example: methods for retrieving or modifying a specific paragraph, style, cell, or shape within a part)
Search functionality, for simple searching of content in all document types
Validation functionality, to verify that modified or created documents are compliant with the Open XML standard
High-level “scenario-based” functionality (examples: creating a document from a template, accepting all revisions in a document)
Shared ML functionality (example: classes for DrawingML chart parts and other parts that can appear in multiple document types)

The functionality in this roadmap was driven by feedback received from developers since the CTP release last June. A recurring theme was that developers want more tools to help edit and manipulate the underlying XML within the parts, and this is reflected in new methods that will be included in the content object model, as well as Linq-related changes as mentioned above.

For more detailed information about what's coming in the Open XML SDK, see Jean-Christophe Cimetiere's video interview with Zeyad Rajabi and Eric White where they discuss the changes in the SDK and show some of the details of how it will work.

To download the latest version of the SDK or for links to more information, see the Open XML SDK page on MSDN.

Developer workshop videos

dmahugh — Wed, 29 Aug 2007 16:04:00 GMT

MSDN has published a comprehensive set of videos of a 2-day Open XML developer workshop. These videos cover the content that was posted on OpenXMLDeveloper recently here.

The instructors for this workshop were Doug Mahugh of Microsoft and Chris Predeek of the Ted Pattison Group, and the workshop was sponsored by Mindjet and took place at their office in San Francisco on June 18-19, 2007.

Open XML development videos

dmahugh — Mon, 19 Mar 2007 19:14:00 GMT

Several of the most active contributors to OpenXmlDeveloper were in Redmond last week for the MVP Summit and an Open XML workshop, so Doug Mahugh interviewed them on some Open XML development topics. The videos are up on Channel 9 at the links included below.

Open-source Open XML API for Java
Julien Chable demonstrates his OPENXML4J project, which is a continuation of the work described in his article on OpenXmlDeveloper here.

Package Explorer for Open XML
Wouter Van Vugt talks about the latest release of his Package Explorer tool, which was originally covered on OpenXmlDeveloper here.

Linux/Java interoperability with Open XML
Sanjay Kumar and Datta Kulkarni of Sonata Software describe how Open XML can be used from a Linux environment, building on the techniques covered on OpenXmlDeveloper here.

Generating Dynamic OpenXML Docx Files

dmahugh — Wed, 07 Mar 2007 20:08:00 GMT

Mohammad Nour El-din Marwan of Cairo University's Computer Engineering Department has posted a detailed how-to article that covers the design of a set of classes for working with Open XML documents. His approach reflects a common business need: set up a standardized look and feel in a template, which can be used as a starting point for generating dynamic data-driven documents that all share common formatting characteristics.

The article includes many diagrams that clearly explain the architecture used. Definitely worth a look if you're designing software to generate dynamic Open XML documents.

... more information ...

Updated Open XML code snippets for Visual Studio

dmahugh — Tue, 28 Nov 2006 20:39:00 GMT

Microsoft's Visual Studio code snippets for the System.IO.Packaging API have been updated for the final versions of the Office Open XML schemas and the RTM versions of Office and the .NET 3.0 Framework.

The snippets are available in both C# and Visual Basic, and you can download the latest version of them from this page on MSDN.

Content Control Toolkit

dmahugh — Tue, 21 Nov 2006 13:33:00 GMT

If you're working on Open XML solutions that use Word 2007 content controls and bind them to nodes in your custom XML data part, then you need this tool. It provides a simple graphical view of the content controls and custom XML nodes in a document, and you can bind a node to a control by simple drag&drop operations. Click on the screen shot here to see how it works.

It's a great way to manually create a data-bound document, and it's also a good developer tool for learning about the markup you need for binding controls to data. You can generate well-formed data-binding markup with a few clicks, then look at how it works and use the same markup in your custom solution as needed.

The tool, developed by Microsoft's Matt Scott, is available as a Codeplex project, and there's also a video on Channel 9 where Matt goes through the design and development of the tool and demonstrates its use.

Open XML developers at TechEd

dmahugh — Wed, 15 Nov 2006 19:24:00 GMT

November 10, 2006. Several sessions on Open XML development were presentated at the Microsoft TechEd conference in Barcelona this week. The photo here shows Peter Koen's Thursday session on Open XML architecture.

This week's announcements of the 2007 Microsoft Office System being released to manufacturing and the release of the .NET 3.0 Framework (see below) were big news for Open XML developers.

diffopc: a DIFF utility for Open XML

dmahugh — Wed, 18 Oct 2006 02:16:00 GMT

If you're doing much Open XML development, you probably sometimes need to compare two versions of a document and look closely at the differences. Stephane Rodriguez's diffopc tool is a utility program that makes short work of this sort of a task.

Diffopc takes any two OPC (Open Packaging Convention) files as inputs (e.g., Open XML documents or XPS documents), and displayes a well-organized summary of the differences in a web browser. You can look at the parts that have changed, or drill down into a part and see the specific differences in the XML markup.

Download or read more about diffopc here.

MSDN Articles on Open XML and Related Topics

dmahugh — Thu, 31 Aug 2006 19:32:00 GMT

The 2007 Microsoft Office system will use the Open XML file formats as their default format, and Microsoft has started to publish white papers, code samples, and other Open XML content for developers.

The following is an overview of some of the Open XML information that is currently available on MSDN, including general XML resources, information about Open XML development, and documentation of Microsoft schemas that can be used with Open XML due to its flexible support for custom schemas. Watch for more of this type of content in the months ahead.

Walkthrough: Word 2007 XML Format. This article by Erika Ehrli covers the basics of the packaging convention and then gets into the details of how Word uses Open XML: which parts are included and how they're related, how the custom XML data store works, and an example of how to create a typical WordprocessingML document.

2007 Office System: XML Schema Reference. Documentation in CHM and HTML format for the schemas used in the 2007 Microsoft Office system, including schemas that are not part of the Open XML specification (as used in Outlook 2007, OneNote 2007, and Visio 2007).

2007 Office System Sample: Open XML File Format Code Snippets for Visual Studio 2005. These are the snippets that were covered on OpenXmlDeveloper.org here.

Microsoft XML Team's WebLog. Microsoft's XML team covers a variety of XML topics.

Introducing the Office (2007) Open XML File Formats. Frank Rice reviews some of the most common Open XML development scenarios, and describes the benefits of Open XML in plain English. He also covers the various file formats supported by Office, how to implement Office's CustomUI functionality, and related topics.

Microsoft Office Open XML Formats Frequently Asked Questions. Answers to dozens of questions about Open XML and how it has been implemented in the 2007 Microsoft Office system.

XML in Office Developer Portal. A portal that aggregates many online resources for developers working with XML in Office, including both Open XML resources and other types of XML resources.

Creating a PresentationML Document through a browser interface

SanjayKumarM — Thu, 24 Aug 2006 10:44:00 GMT

Article by: MuthuKumar Arjunan and Vijayeta of Sonata Software Ltd.

This article explores the interoperable potential of the Open XML file formats. We will show how a simple browser on any client machine can create a PresentationML document (PPTX) on a web server. The browser provides the GUI, and the server software uses the .NET 3.0 System.IO.Packaging API to create the document.

The user can create slides, then drag and position them in his preferred order. Later he can create a downloadable power point file which comprises the slides he created, in the order he has specified.

The web page consists of text boxes to edit the contents of slide document to be created. When the user drags the slide, the vertical position of the slide is tracked and displayed in the text box on the screen, and another text box keeps the count of slides created.

The user is also provided with an editable text box to post the URL of the server, as shown:

The controls used here are HTML controls and the events are handled using Java Script.

The text boxes holding the slide contents can also be docked in the screen. For example, the first text box can be placed after the second text box, and the Presentation Document is created in the same slide order.

When the user is ready with the data that would form a presentation document,he clicks on the “Create PPT file” button. On-Click of the “Create PPT file”, the slide position, the Title and the SubTitles of each of the slides are sent to the server as an XML document, as shown:

Sending ...
<ROOT>
  <SLIDE Content="Enter the Content for Slide: 1" Header="Enter Slide Header:  1" pos="126" />
  <SLIDE Content="Enter the Content for Slide: 2" Header="Enter Slide Header: 2" pos="270" />
</ROOT>

At the server side, the XML document is processed, where in the Header and Content are separately stored and slides are created in the same order as the user wants, using .NET 3.0 System.IO.Packaging API.

The Presentation Document created is assigned a unique number series as name. The Server in turn returns a hyperlink of the URL from where the document can be downloaded to the local drive. On click of the link, the user is prompted to save it to the disk or open the document.

See the attached file for complete source code for the sample shown in this article.

Adding Header - Footer to any WordprocessingML

SanjayKumarM — Thu, 03 Aug 2006 09:36:00 GMT

Author: Vijayeta Tilak, Sonata Software Limited

This article describes how a footer or header can be programmatically added to a word document from a .NET application using the System.IO.Packaging API.

A WordprocessingML document may contain a part named footerX.xml, which holds the footer text and the page number. This part is included in the document by a footer reference tag that includes a relationship to the footer part from within the document.xml "start part" as shown here:

<w:sectPr w:rsidR="00A352BA">

<w:pgSz w:w="12240" w:h="15840" />

<w:footerReference w:type="default" r:id="rId8" />

<w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="720" w:footer="720" w:gutter="0" />

<w:cols w:space="720" />

<w:docGrid w:linePitch="360" />

</w:sectPr>

The relationship ID must be unique within the document.

The footerX.xml part has a node that specifies the style to be used to format the footer:

<w:pStyle w:val="Footer" />

A content type for the footer must also be included in the package, as shown here:

A part relationship must also be created, using the same relationship ID as was used in Document.xml:

The UI would consist of a single text box accepting the footer text from the user, which would be included the document the user selects.

Programmatically, a footer file is created with the text the user had keyed in.

A part of code (from .NET Code Snippets for Open XML Developers) would then open the package and include the footer file, create Part Relationship.

public void WDAddHeaderFooter(string docName, XmlDocument Doc,bool h)

{

// Given a document name, and a XML document

const string documentRelationshipType="http://schemas.openxmlformats.org /officeDocument/2006/ relationships/officeDocument";

const string wordmlNamespace = "http://schemas.openxmlformats.org /wordprocessingml/2006/3/main";

const string relationshipNamespace ="http://schemas.openxmlformats.org /officeDocument/2006/relationships";

PackagePart documentPart = null;

Uri uriHeaderFooter;

string headerfooterContentType;

string relationshipType;

string reference;

package = Package.Open(docName, FileMode.Open, FileAccess.ReadWrite);

// Get the main document part (document.xml).

foreach (System.IO.Packaging.PackageRelationship relationship in package. GetRelationshipsByType(documentRelationshipType))

{

Uri documentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), relationship.TargetUri);

documentPart = package.GetPart(documentUri);

// There is only one document.

break;

}

if (h)

{

uriHeaderFooter = new Uri("/word/header2.xml", UriKind.Relative);

headerfooterContentType="application/vnd.openxmlformats-officedocument. wordprocessingml.header+xml";

relationshipType = "http://schemas.openxmlformats.org/ officeDocument/2006/relationships/header";

reference = "w:headerReference";

}

else

{

uriHeaderFooter = new Uri("/word/footer2.xml", UriKind.Relative);

headerfooterContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml";

relationshipType = "http://schemas.openxmlformats.org/officeDocument/ 2006/relationships/footer";

reference = "w:footerReference";

}

if (package.PartExists(uriHeaderFooter))

{

// Although you could delete the relationship

// to the existing node, the next time you save

// the document after making changes, Word

// will take care of this for you.

package.DeletePart(uriHeaderFooter);

}

// Create the new footer part:

PackagePart headerfooterPart =package.CreatePart(uriHeaderFooter, headerfooterContentType);

// Write the footer out to its part.

Doc.Save(headerfooterPart.GetStream());

// Create the document's relationship to the new part:

PackageRelationship rel = documentPart.CreateRelationship(uriHeaderFooter, TargetMode.Internal, relationshipType);

string relID = rel.Id;

// Manage namespaces to perform Xml XPath queries.

NameTable nt = new NameTable();

XmlNamespaceManager nsManager = new XmlNamespaceManager(nt);

nsManager.AddNamespace("w", wordmlNamespace);

// Get the document part from the package.

// Load the XML in the part into an XmlDocument instance:

XmlDocument xdoc = new XmlDocument(nt);

xdoc.Load(documentPart.GetStream());

// Find the node containing the document layout:

XmlNode targetNode = xdoc.SelectSingleNode("//w:sectPr", nsManager);

if (targetNode != null)

{

// Delete any existing references to footers:

XmlNodeList headerfooterNodes = targetNode.SelectNodes("./"+reference, nsManager);

foreach (System.Xml.XmlNode headerfooterNode in headerfooterNodes)

{

targetNode.RemoveChild(headerfooterNode);

}

// Create the new header reference node:

XmlElement node = xdoc.CreateElement(reference, wordmlNamespace);

XmlAttribute attr=node.Attributes.Append(xdoc.CreateAttribute("r:id" ,relationshipNamespace));

attr.Value = relID;

node.Attributes.Append(attr);

targetNode.InsertBefore(node, targetNode.FirstChild);

}

// Save the document XML back to its part.

xdoc.Save(documentPart.GetStream(FileMode.Create, FileAccess.Write));

package.Close();

}