Blog

Blog Post: Screen-Cast: Grouping Content Controls to Create Forms

Eric White — Mon, 17 Jun 2013 16:01:00 GMT

One of the more interesting scenarios with Open XML WordprocessingML is creating a document that contains a form. You can send this document to others, who fill out the form and return it to you. You can then retrieve that data directly from the Open XML markup. There are two approaches to creating a form when using content controls:

You can create content controls, and then protect the document, prohibiting editing except for within the content controls. This has one disadvantage - spell checking no longer works, so users can't tell if they have misspelled words within those content controls.
You can create content controls, and then group the content controls. Spell checking works properly when using this approach.

The following screen-cast shows the approach of creating content controls and then grouping them. It presents a bit of Open XML code that programmatically groups the content controls.

(Please visit the site to view this video)

Following is the listing of the small program that I develop in the screen-cast:

using System;  using System.Collections.Generic;  using System.IO;  using System.Linq;  using System.Text;  using System.Threading.Tasks;  using System.Xml.Linq;  using DocumentFormat.OpenXml;  using DocumentFormat.OpenXml.Packaging;  using DocumentFormat.OpenXml.Wordprocessing;    namespace GroupContentControls  {      class Program      {          // Creates an SdtBlock instance and adds its children.          public static SdtBlock GenerateSdtBlock()          {              SdtBlock sdtBlock1 = new SdtBlock();                SdtProperties sdtProperties1 = new SdtProperties();              SdtId sdtId1 = new SdtId() { Val = -1013684659 };              Lock lock1 = new Lock() { Val = LockingValues.ContentLocked };                SdtPlaceholder sdtPlaceholder1 = new SdtPlaceholder();              DocPartReference docPartReference1 = new DocPartReference() { Val = "DefaultPlaceholder_1081868574" };                sdtPlaceholder1.Append(docPartReference1);              SdtContentGroup sdtContentGroup1 = new SdtContentGroup();                sdtProperties1.Append(sdtId1);              sdtProperties1.Append(lock1);              sdtProperties1.Append(sdtPlaceholder1);              sdtProperties1.Append(sdtContentGroup1);              SdtContentBlock sdtContentBlock1 = new SdtContentBlock();                sdtBlock1.Append(sdtProperties1);              sdtBlock1.Append(sdtContentBlock1);              return sdtBlock1;          }            static void Main(string[] args)          {              FileInfo f = new FileInfo("../../../EricWhiteForm.docx");              FileInfo f2 = new FileInfo("../../../EricWhiteForm - ProgrammaticallyGrouped.docx");              if (f2.Exists)                  f2.Delete();              File.Copy(f.FullName, f2.FullName);              using (WordprocessingDocument wDoc = WordprocessingDocument.Open(f2.FullName, true))              {                  var sdtBlock = GenerateSdtBlock();                  var sdtContent = sdtBlock.SdtContentBlock;                  var body = wDoc.MainDocumentPart.Document.Body;                  foreach (var child in body.ChildElements)                  {                      if (child is SectionProperties)                      {                          continue;                      }                      sdtContent.Append((OpenXmlElement)child.Clone());                  }                  var newBody = new Body();                  newBody.AppendChild(sdtBlock);                  wDoc.MainDocumentPart.Document.ReplaceChild(newBody, body);              }          }      }  }

Blog Post: Screen-Cast: Debugging Open XML when the Office Client Crashes

Eric White — Thu, 30 May 2013 14:26:00 GMT

Document formats are pretty complex. It is fairly easy to generate a document that is invalid. In many cases, the Open XML SDK productivity tool will help us by informing us of where the errors are. In other cases, a Microsoft Office client application such as Word or Excel may inform us that we have generated an invalid document. In the worst case, it is possible to generate a document that causes Word or Excel to crash. This screen-cast shows how I debug these types of situations.

(Please visit the site to view this video)

Blog Post: Using Both the Strongly Typed Object Model and LINQ to XML in an Open XML Application

Eric White — Thu, 09 May 2013 10:45:00 GMT

Sometimes developers want to use the strongly-typed object model of the Open XML SDK in combination with code written using LINQ to XML. You may want to use functionality from PowerTools for Open XML (which is written using LINQ to XML), and you may want to write your code using the strongly typed OM. There are variations between the two approaches in how you get and set the contents of parts. If you don't take care of the mechanics properly, then you will make changes using one or the other of the approaches, and those changes will not be saved to your document. There is a super-simple formula, though, for taking care of these issues. Once you know the formula, you can use either approach whenever it makes sense for your application.

The key ideas:

Whenever you make changes using the strongly-typed object model, you need to save it before accessing that content using LINQ to XML:

// call Save on the root element of the part  wDoc.MainDocumentPart.RootElement.Save();

Whenever you are finished making changes using LINQ to XML, you can call a simple function, SaveAllParts:

private static void SaveAllParts(WordprocessingDocument wDoc)  {      foreach (var part in wDoc.GetAllParts())      {          XDocument partXDocument = part.Annotation<XDocument>();          if (partXDocument == null)              continue;            XDocument xDoc = part.GetXDocument();          part.RootElement.InnerXml = xDoc              .Root              .Elements()              .Select(e => e.ToString())              .StringConcatenate();            part.RemoveAnnotations<XDocument>();      }  }

This method, SaveAllParts uses the GetAllParts() extension method from PowerTools for Open XML. This method returns a list of all parts in a document. The method can then iterate through all the parts, see if there is an XDocument annotation on the part, and if so, replace the inner XML of the root element, using the strongly typed OM. Here is a complete example that first makes a change using the strongly-typed OM, then makes a change using PowerTools for Open XML, and then again makes a change using the strongly typed OM. The example, as well as the test documents, are attached to this post.

using System;  using System.IO;  using System.Linq;  using System.Xml.Linq;  using DocumentFormat.OpenXml;  using DocumentFormat.OpenXml.Packaging;  using DocumentFormat.OpenXml.Wordprocessing;  using OpenXmlPowerTools;  using System.Collections.Generic;    class Program  {      static void Main(string[] args)      {          FileInfo fi = new FileInfo(@"..\..\Test.docx");          fi.Delete();          fi = new FileInfo(@"..\..\Test - Copy.docx");          var dfi = new FileInfo(@"..\..\Test.docx");          fi.CopyTo(dfi.FullName);            using (WordprocessingDocument wDoc =              WordprocessingDocument.Open(@"..\..\Test.docx", true))          {              // make some changes using the strongly typed OM of the Open XML SDK              var p = wDoc                  .MainDocumentPart                  .Document                  .Body                  .Elements<Paragraph>()                  .FirstOrDefault();              var r = p.Elements<Run>().FirstOrDefault();              if (r != null)              {                  var t = r.Elements<Text>().FirstOrDefault();                  if (t != null)                  {                      t.Text = "That is ";                  }              }                // save back into the document              wDoc.MainDocumentPart.RootElement.Save();                // see the changes made by the Open XML SDK strongly-typed OM              DumpFirstParagraph(wDoc);                // make some changes using PowerTools for Open XML (using LINQ to XML)              SimplifyMarkupSettings settings = new SimplifyMarkupSettings()              {                  RemoveBookmarks = true,                  RemoveRsidInfo = true,                  AcceptRevisions = true,              };              MarkupSimplifier.SimplifyMarkup(wDoc, settings);                // save the changes back into the document              SaveAllParts(wDoc);                // see the changes made by PowerTools for OpenXML              DumpFirstParagraph(wDoc);                // again make some changes using the strongly typed OM of the Open XML SDK              p = wDoc                  .MainDocumentPart                  .Document                  .Body                  .Elements<Paragraph>()                  .FirstOrDefault();              r = p.Elements<Run>().FirstOrDefault();              if (r != null)              {                  var t = r.Elements<Text>().FirstOrDefault();                  if (t != null)                  {                      t.Text = "The paragraph has only one run.";                  }              }                // save back into the document              wDoc.MainDocumentPart.RootElement.Save();                // see the changes made by the Open XML SDK strongly-typed OM              DumpFirstParagraph(wDoc);              Console.ReadKey();            }      }        private static void DumpFirstParagraph(WordprocessingDocument wDoc)      {          Paragraph p = wDoc              .MainDocumentPart              .Document              .Body              .Elements<Paragraph>()              .FirstOrDefault();          // dump out the first paragraph          XElement z = XElement.Parse(              "<w:p xmlns:w='http://schemas.openxmlformats.org/wordprocessingml/2006/main'>" +              p.InnerXml + "</w:p>");          z.Elements()              .Attributes()              .Where(a => a.IsNamespaceDeclaration)              .Remove();          Console.WriteLine(z);          Console.WriteLine("==============================");      }        private static void SaveAllParts(WordprocessingDocument wDoc)      {          foreach (var part in wDoc.GetAllParts())          {              XDocument partXDocument = part.Annotation<XDocument>();              if (partXDocument == null)                  continue;                XDocument xDoc = part.GetXDocument();              part.RootElement.InnerXml = xDoc                  .Root                  .Elements()                  .Select(e => e.ToString())                  .StringConcatenate();                part.RemoveAnnotations<XDocument>();          }      }  }

Blog Post: Fine-Grained Control When Importing Content Using DocumentBuilder

Eric White — Wed, 08 May 2013 18:02:00 GMT

Recently I had a question about how to import the contents of one cell in one table into a cell in a different table in another document. As you probably know, moving content from one document to another in Open XML is complicated, because of interrelated markup. It isn't enough just to move the markup in the cell to the cell in the destination table; you need to also bring along any auxiliary information such as images, drawings, comments, and other such artifacts. DocumentBuilder addresses this problem of interrelated markup. However, it works at the granularity of child elements of the w:body element. Out-of-the-box, it will not import content from one cell in one table into a cell in another table. However, you can use some advanced techniques with DocumentBuilder that enable you to assemble documents from sources with a high degree of control. This screen-cast shows how.

(Please visit the site to view this video)

Blog Post: Screen-Cast: Starting Chapters on Odd Pages in WordprocessingML

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

Scenario: You need to generate a document for a book, and you want each chapter to start on an odd-numbered page, so that the chapter title page is on the right-hand side of the binding. This question has been asked on the forum here at OpenXMLDeveloper.org, so I recorded a screen-cast explaining exactly how to accomplish this. Along the way, this screen-cast can serve to fill-in your knowledge about sections and headers.

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

This screen-cast is a part of an on-going series of screen-casts on Open XML WordprocessingML.

(Please visit the site to view this video)

Blog Post: Screen-Cast: Writing a Custom Axis Method

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

Sometimes the easiest way to accomplish a particular task is to write an axis method that returns just the elements in an Open XML document that you are interested in. Sometimes you want to write the axis method in a lazy fashion so that it performs as well as possible on large documents. You also may need to use some form or another of recursion as the easiest way to write your axis method. However, recursion and laziness are at odds. You can't write a method that uses 'yield return' in some places (to implement laziness) and uses 'return' in other places to implement recursion. This screen-cast shows how to get around this limitation in the C# language.

Return to the Table of Contents of this screen-cast series. To demonstrate this scenario, I write an axis method that returns just certain runs of a WordprocessingML document, in document order.

(Please visit the site to view this video)

Blog Post: Screen-Cast: WordprocessingML Tables Part 2

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

This screen-cast continues our discussion about table markup in WordprocessingML. Going beyond the basic structure of tables, it discusses various issues about rendering. This screen-cast explains the w:cnfStyle element, and how it relates to the w:tblLook element.

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

(Please visit the site to view this video)

Blog Post: Screen-Cast: WordprocessingML Tables Part 1

Eric White — Mon, 01 Apr 2013 10:40:00 GMT

This screen-cast discusses table markup in WordprocessingML. It explains the basic structure of tables, and discusses how WordprocessingML table markup differs from HTML. The following screen-cast in this series (coming soon) examines various issues around table rendering.

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

(Please visit the site to view this video)

Blog Post: Screen-Cast: Complex Transforms of XML Elements

Eric White — Thu, 28 Mar 2013 14:13:00 GMT

This is the nineteenth screen-cast in a series on writing Recursive Pure Functional Transformations (RPFT) of XML. In this screen-cast, I discuss an interesting idiom / pattern for doing complex transforms of XML elements.

Return to the Table of Contents of this screen-cast series. To demonstrate this scenario, I write code to set the paragraph and character styles for specific paragraphs.

(Please visit the site to view this video)

Blog Post: Does Functional Programming Matter?

Eric White — Thu, 14 Mar 2013 19:39:00 GMT

A number of years ago, I gave a talk at a tech conference, and in the feedback, I received a ‘complaint’ that I didn’t really explain how I was writing the code that I was publishing as part of PowerTools for Open XML – code such as RevisionAccepter, ListItemRetriever, and HtmlConverter. Developers sometimes look at the code in those modules, and their reaction is “Huh????” The main problem with presenting those coding techniques was that I had one hour at that conference, and to explain the techniques I was using, it requires something more like five hours.

Flash-forward four years – those techniques have held up well over time. I still regularly use the approach. I can write robust code that performs well. For example, after publishing RevisionAccepter, I have not needed to touch the code even once. I have translated large chunks of that code to JavaScript and the approach works equally as well there. (I’ll publish that JavaScript code, all in good time.)

Why does Functional Programming work for me?

It lets me work in my domain. My domain is document formats, and more specifically, Open XML. When writing transformation code, I want to be thinking about the various Open XML elements and attributes, and their semantics, and contemplating on what I want to do to them. I don’t want to be writing large chunks of procedural code that doesn’t have a close correlation to the algorithm I am implementing.

While you must learn new patterns and idioms, after you master them you can write code that directly reflects your intent. Further, you can come back to code that you’ve written years previously, and read, understand, and modify it. But you must learn the patterns and idioms.

I have recorded a screen-cast series on writing Recursive Pure Functional Transforms. A single weekend invested now will yield dividends over your entire career. And further, functional programming is fun. It is an enjoyable way to write resilient, non-brittle code. It lets me leverage my time and write more code that does what I want it to. The economic benefit is clear.

So yes, functional programming matters very much.

Cheers,
Eric White

Blog Post: Screen-Cast: Why Do Transform Methods Return Object?

Eric White — Thu, 28 Feb 2013 11:11:00 GMT

This is the eighteenth screen-cast in a series on writing Recursive Pure Functional Transformations (RPFT) of XML. In this screen-cast, I discuss why the transform methods return object instead of some other type such as XObject, XElement, or XNode. The short answer is that sometimes the transform method needs to return a single element or node, and sometimes it needs to return a collection of elements or nodes.

Return to the Table of Contents of this screen-cast series. To demonstrate this scenario, I replace a content control with three paragraphs of content.

(Please visit the site to view this video)

Blog Post: Open XML Markup Explorer App for Word 2013

Eric White — Tue, 26 Feb 2013 14:40:00 GMT

This screen-cast introduces a small Word 2013 "app" that enables you to select content in a Word document, click a button in a task pane, and see the markup for the selected content. Further, you can modify the markup in the task pane, click a button, and replace the selected content in the document with the markup.

This functionality is pretty valuable to a developer new to Open XML development. You can explore the markup for a wide variety of Word document artifacts. It is also helpful to experienced Open XML developers. I, of course, can't remember all of the details of all aspects of Word markup, and when writing a complex query, it is helpful to be able to have good examples of the markup side-by-side to Visual Studio as I write the code.

The video demos the app, and then walks through the process of building it. The app is included in an attached zip file, but if you want to build the app yourself (an enjoyable and instructive task), the listings follow the video.

(Please visit the site to view this video)

Following is the HTML file showing the inclusion of the linq.js and ltxml.js modules, as well as the small about of UI markup.

<!DOCTYPE html>  <html>  <head>      <meta charset="UTF-8" />      <meta http-equiv="X-UA-Compatible" content="IE=Edge" />      <title>WordMarkupExplorer</title>        <link rel="stylesheet" type="text/css" href="../Content/Office.css" />        <!-- Add your CSS styles to the following file -->      <link rel="stylesheet" type="text/css" href="../Content/App.css" />        <script src="../Scripts/jquery-1.7.1.js"></script>        <!-- Use the CDN reference to Office.js when deploying your app -->      <!--<script src="https://appsforoffice.microsoft.com/lib/1.0/hosted/office.js"></script>-->        <!-- Use the local script references for Office.js to enable offline debugging -->      <script src="../Scripts/Office/1.0/MicrosoftAjax.js"></script>      <script src="../Scripts/Office/1.0/office.js"></script>        <!-- Add your JavaScript to the following file -->      <script src="../Scripts/linq.js"></script>      <script src="../Scripts/ltxml.js"></script>      <script src="../Scripts/WordMarkupExplorer.js"></script>  </head>  <body>      <div id="Content" style="padding: 0; margin: 0;">          <input type="button" value="Get Markup" id="getMarkupBtn" style="padding: 0px; width: 100px;" />          <input type="button" value="Set Markup" id="setMarkupBtn" style="padding: 0px; width: 100px;" />      </div>      <div id="Error" style="margin: 0; padding: 0;"></div>      <div id="Markup" style="padding: 0; margin: 0;">          <textarea rows="33" cols="120" id="txMarkup" spellcheck="false" style="font: 12px courier; height: 100%; min-height: 50%; padding: 0; width: 100%; margin: 10pt 0 0 0;"></textarea>      </div>  </body>  </html>

Here is the listing of WordMarkupExplorer.js:

// This function is run when the app is ready to start interacting with the host application  // It ensures the DOM is ready before adding click handlers to buttons  Office.initialize = function (reason) {      $(document).ready(function () {          $('#getMarkupBtn').click(function () {              getMarkup();          });          $('#setMarkupBtn').click(function () {              setMarkup();          });          $('#Error').hide(0, function () {              $('#Error').html("<p/>");          });      });  };    var getMarkup, setMarkup;    (function (root) {        var XDocument = Ltxml.XDocument;      var XElement = Ltxml.XElement;      var XAttribute = Ltxml.XAttribute;      var XNamespace = Ltxml.XNamespace;      var XName = Ltxml.XName;        var wpc = new XNamespace(          'http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas');      var mc = new XNamespace(          "http://schemas.openxmlformats.org/markup-compatibility/2006");      var o = new XNamespace(          "urn:schemas-microsoft-com:office:office");      var r = new XNamespace(          'http://schemas.openxmlformats.org/officeDocument/2006/relationships');      var m = new XNamespace(          "http://schemas.openxmlformats.org/officeDocument/2006/math");      var v = new XNamespace("urn:schemas-microsoft-com:vml");      var wp14 = new XNamespace(          "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing");      var wp = new XNamespace(          "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing");      var w10 = new XNamespace("urn:schemas-microsoft-com:office:word");      var w = new XNamespace(          'http://schemas.openxmlformats.org/wordprocessingml/2006/main');      var w14 = new XNamespace(          "http://schemas.microsoft.com/office/word/2010/wordml");      var w15 = new XNamespace(          "http://schemas.microsoft.com/office/word/2012/wordml");      var wpg = new XNamespace(          "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup");      var wpi = new XNamespace(          "http://schemas.microsoft.com/office/word/2010/wordprocessingInk");      var wne = new XNamespace(          "http://schemas.microsoft.com/office/word/2006/wordml");      var wps = new XNamespace(          "http://schemas.microsoft.com/office/word/2010/wordprocessingShape");        var W = {          rsid: new XName(w + "rsid"),          rsidDel: new XName(w + "rsidDel"),          rsidP: new XName(w + "rsidP"),          rsidR: new XName(w + "rsidR"),          rsidRDefault: new XName(w + "rsidRDefault"),          rsidRPr: new XName(w + "rsidRPr"),          rsidSect: new XName(w + "rsidSect"),          rsidTr: new XName(w + "rsidTr"),          sectPr: new XName(w + "sectPr"),          body: new XName(w + "body"),      };        function simplifyTransform(node) {          var element = node;          if (element.nodeType === 'Element') {              if (element.name === W.sectPr && element.parent.name === W.body) {                  return null;              }              if (element.name == W.rsid)                  return null;              var newElement = new Ltxml.XElement(element.name,                  element.attributes().where(function (a) {                      return a.name != W.rsid &&                      a.name != W.rsidDel &&                      a.name != W.rsidP &&                      a.name != W.rsidR &&                      a.name != W.rsidRDefault &&                      a.name != W.rsidRPr &&                      a.name != W.rsidSect &&                      a.name != W.rsidTr;                  }),                  element.nodes().select(function (n) {                      return simplifyTransform(n);                  }))              return newElement;          }          return node;      }        var regArray = [          {              regEx: /xmlns:[^\r\n]*"(\r\n|\n|\r)/g,              replaceWith: ""          },          {              regEx: /xmlns:[^\r\n]*'(\r\n|\n|\r)/g,              replaceWith: ""          },          {              regEx: /xmlns:[^>\r\n]*">/g,              replaceWith: ">"          },          {              regEx: /xmlns:[^>\r\n]*'>/g,              replaceWith: ">"          },      ];        function simplifyMarkup(body) {          var simplified = simplifyTransform(body);          simplified.add(              new XAttribute(XNamespace.xmlns + "wpc", wpc),              new XAttribute(XNamespace.xmlns + "mc", mc),              new XAttribute(XNamespace.xmlns + "o", o),              new XAttribute(XNamespace.xmlns + "r", r),              new XAttribute(XNamespace.xmlns + "m", m),              new XAttribute(XNamespace.xmlns + "v", v),              new XAttribute(XNamespace.xmlns + "wp14", wp14),              new XAttribute(XNamespace.xmlns + "wp", wp),              new XAttribute(XNamespace.xmlns + "w10", w10),              new XAttribute(XNamespace.xmlns + "w", w),              new XAttribute(XNamespace.xmlns + "w14", w14),              new XAttribute(XNamespace.xmlns + "w15", w15),              new XAttribute(XNamespace.xmlns + "wpg", wpg),              new XAttribute(XNamespace.xmlns + "wpi", wpi),              new XAttribute(XNamespace.xmlns + "wne", wne),              new XAttribute(XNamespace.xmlns + "wps", wps));          var simpString = simplified.toString(true);          for (var i = 0; i < regArray.length; i++) {              simpString = simpString.replace(regArray[i].regEx,                  regArray[i].replaceWith);          }          simpString = simpString.replace(/<w:body[ ]*>(\r\n|\n|\r)/, "");          simpString = simpString.replace(/<\/w:body>(\r\n|\n|\r)/, "");          simpString = simpString.replace(/^  /g, "");          simpString = simpString.replace(/(\r\n|\n|\r)  /g, "\r\n");          simpString = simpString.replace(/<w:p\/>(\r\n|\n|\r)$/, "");          return simpString;      }        // Reads the data from current selection of the document and displays it in a textbox      getMarkup = function () {          Office.context.document.getSelectedDataAsync(Office.CoercionType.Ooxml,          function (asyncResult) {              var t = document.getElementById('txMarkup');              var error = asyncResult.error;              if (asyncResult.status === Office.AsyncResultStatus.Failed) {                  t.value = error.name + ": " + error.message;              }              else {                  var parsedResult = XElement.parse(asyncResult.value);                  var body = parsedResult.descendants(w + "body").firstOrDefault();                  var simpString = simplifyMarkup(body);                  t.value = simpString;                  $('#Error').hide(500, function () {                      $('#Error').html("");                  });              }          });      }        function fixUpMarkup(markup) {          var newMarkup =  '<w:body xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas"' +  ' xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"' +  ' xmlns:o="urn:schemas-microsoft-com:office:office"' +  ' xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"' +  ' xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"' +  ' xmlns:v="urn:schemas-microsoft-com:vml"' +  ' xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing"' +  ' xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"' +  ' xmlns:w10="urn:schemas-microsoft-com:office:word"' +  ' xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"' +  ' xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"' +  ' xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml"' +  ' xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup"' +  ' xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk"' +  ' xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml"' +  ' xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"' +  ' mc:Ignorable="w14 w15 wp14">' + markup + "</w:body>";          return newMarkup;      }        // Reads the data from current selection of the document and displays it in a textbox      setMarkup = function () {          Office.context.document.getSelectedDataAsync(Office.CoercionType.Ooxml,          function (asyncResult) {              var t = document.getElementById('txMarkup');              var error = asyncResult.error;              if (asyncResult.status === Office.AsyncResultStatus.Failed) {                  $('#Error').html(  "<p style='font-size: 12px;background-color: red; color: white;'>Error setting markup: "                      + error.name + ": " + error.message + "</p>");                  $('#Error').show(500, function () { });              }              else {                  var parsedResult = XDocument.parse(asyncResult.value);                  var body = parsedResult.descendants(w + "body").firstOrDefault();                  var newMarkup = fixUpMarkup(t.value);                  try {                      var newBody = XElement.parse(newMarkup);                      body.replaceWith(newBody);                      $('#Error').hide(500, function () {                          $('#Error').html("");                      });                      Office.context.document.setSelectedDataAsync(                          parsedResult.toString(false), {                              coercionType: "ooxml"                          }, function (asyncResult) {                              var error = asyncResult.error;                              if (asyncResult.status === "failed") {                                  $('#Error').html(  "<p style='font-size: 12px;background-color: red; color: white;'>Error setting markup: "                                      + error.name + ": " + error.message + "</p>");                                  $('#Error').show(500, function () { });                              }                              else {                                  // get the markup back out from Word so that display                                  // any adjustments that Word made to the markup.                                  getMarkup();                              }                          });                  }                  catch (e) {                      $('#Error').html(  "<p style='font-size: 12px;background-color: red; color: white;'>XML Parsing Error: "                          + e.toString() + "</p>");                      $('#Error').show(500, function () { });                  }                }          });      }  })(this);

Blog Post: Screen-Cast: Exploring the Structure of Embedded Spreadsheets in Word Documents

Eric White — Wed, 20 Feb 2013 12:00:00 GMT

Most users of Microsoft Office are aware that you can directly embed an Excel spreadsheet (XLSX) in a Word document (DOCX). In Open XML terms, the XLSX is stored in a binary part. In addition, there is an image of the view of that spreadsheet, also in its own separate part. This screen-cast shows how to unzip the DOCX, see where the embedded XLSX is, unzip the XLSX, change some markup in one of the worksheets, re-zip the XLSX, and re-zip the DOCX. Further, it is interesting to see where the image of the embedded workbook is stored in the DOCX, and to replace that image with a different one. This screen-cast shows how to accomplish all this and end up with a valid DOCX that is put together correctly.

(Please visit the site to view this video)

Blog Post: Screen-Cast: Transforming Attributes in Recursive Pure Functional Transformations (RPFT) of XML

Eric White — Fri, 15 Feb 2013 21:41:00 GMT

This is the seventeenth screen-cast in a series on writing Recursive Pure Functional Transformations (RPFT) of XML. In this screen-cast, we discuss transforming attributes. If you have been following along closely, you probably could imagine what this code looks like, but it is worthwhile to see this in action.

Return to the Table of Contents of this screen-cast series. To demonstrate this scenario, I write code to remove the RSID attributes from a WordprocessingML document.

(Please visit the site to view this video)

Blog Post: Innovative Use of Open XML with SAP

Eric White — Wed, 13 Feb 2013 13:56:00 GMT

This is a guest post by Ronen Almog, showing an innovative use of Open XML with SAP. This Open XML application combines two of the main scenarios of Open XML: Document Generation, and Content Extraction. As a way to make it easier for SAP users to maintain certain data, this program generates some Open XML documents, the user then edits those documents, and then finally, the documents are parsed, their contents extracted, and the SAP database is updated.

Enjoy!

-Eric

SAP systems are very popular among big businesses. They serve big enterprise organizations and manage a huge number of transactions. Sometimes SAP users feel that the SAP user interface is difficult to use. It is fairly complicated, and less than intuitive.

This blog post shows another way of putting together an intuitive, easy-to-use user interface to some aspects of SAP using Open XML.

As delivered, SAP uses Microsoft Word and Microsoft Excel to present some aspects of the user interface, using OLE. This has the disadvantaging that it works slowly and on only one document at a time. Further, using SAP and OLE, you can’t create objects such as tables, graphics, and dynamic documents.

But if you use Open XML instead of OLE, you can give a much better experience to your users.

First you use Microsoft Word to create a template.

I use an empty template because on the last step in the process, I'm going to merge template and data using XSLT. We store the template on a server directory so it can be accessed by the Open XML programs.

Then connect to the SAP system:

I created an Xml transformation for merging Open XML tags and SAP data (internal tables and fields) using Xpath.

You can then run the SAP program to create Word Documents including SAP data

This process created 20 documents, each containing data about a purchase order.

Now let's open one of the word files created.

The arrows showed merging of SAP data inside the document.

The user can change the text in the short text column in the in the first 2 rows and then save the document.

Then upload the document(s) into SAP:

The next step is to run the transformation of data from Open XML file into SAP. We can see the changes in the rows inside SAP.

This system is working in a production environment in one of the biggest insurance companies in Israel. It produces thousands of letters in each batch run. A large governmental organization plans to use this approach to create letters for the SAP HCM module.

I will be happy to answer questions about this system and implementation.

Ronen Almog

SAP Development Consultant

A.R.P. Solutions

Mail: arp.solutions.il@gmail.com

Cell: 972-505602184

Blog Post: Inserting an Image into a Bookmark in an OpenXML WordprocessingML Document

Eric White — Mon, 11 Feb 2013 07:06:00 GMT

Bookmarks provide a convenient way in WordprocessingML to provide insertion points for various items, such as text, images, etc. Previously, I have outlined how to programmatically retrieve and replace text within a bookmark. In a recent project, a client wanted to use bookmarks as insertion points for one or more images. Using with the replace bookmark text sample code as a starting point, I extended it to include image insertion. There are a number of additional steps to create an Open XML package that contains a properly inserted image. The main points are described below and sample code is attached.

In a recent screencast, I discuss the mechanics of how images are handled in OpenXml. At the end of that screencast, I show how to manually insert an image into a word document package. In order to implement this in code, the following steps are performed:

Flatten the paragraphs
Create a resource ID for the image
Create the image XElement
Insert the image element into the bookmark
Move the bookmark
Create a new image part and stream the image into that part

Flattening the paragraphs

Flattening the paragraphs is a technique that I use in order to simplify XML operations. It creates temporarily invalid WordprocessingML, but is useful as an intermediate step. For example, it is valid for bookmarks to span different levels in the XML hierarchy. However, for inserting an image in between bookmark start and end tags, our job is significantly easier if the bookmarks are at the same level of hierarchy in the XML.

Create a Resource ID for the Image

The resource ID links the image part to the main document part. The only constraint for the image resource ID is that it must be unique. To create a resource ID, the code uses a GUID, strips out the dashes and prepends the number with “r”.

string imageRId = "r" + Guid.NewGuid().ToString().Replace("-", String.Empty);

Create the Image XElement

There is no easy way to create the markup for the image other than hand-coding the image element tree. In order to see this markup, I created a Word document, inserted an image, saved the document, opened it in the Open XML Package Editor Power Tool for Visual Studio 2010, and then examined the markup for the image. A fragment of the markup is shown below. We can see that the markup for the image is below a w:r element and begins with the w:drawing element:

<w:r>    <w:drawing>      <wp:inline distT="0"                  distB="0"                  distL="0"                  distR="0">        <wp:extent cx="2314575"                    cy="1647825" />        <wp:effectExtent l="0"                          t="0"                          r="0"                          b="0" />        <wp:docPr id="1"                  name="Image1" />        <wp:cNvGraphicFramePr>          <a:graphicFrameLocks xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"                                noChangeAspect="1" />        </wp:cNvGraphicFramePr>

Using the PowerTools for OpenXml utility PtOpenXmlUtil.cs, which contains the intialized XName objects for WordprocessingML, I created an image element that produces similar image markup, as shown below.

XElement imageElement =      new XElement(W.drawing,          new XElement(WP.inline,              new XAttribute("distT", "0"),              new XAttribute("distB", "0"),              new XAttribute("distL", "0"),              new XAttribute("distR", "0"),              new XElement(WP.extent,                  new XAttribute("cx", imageWidthExtent),                  new XAttribute("cy", imageHeightExtent)              ),              new XElement(WP.effectExtent,                  new XAttribute("l", "0"),                  new XAttribute("t", "0"),                  new XAttribute("r", "0"),                  new XAttribute("b", "0")              ),              new XElement(WP.docPr,                  new XAttribute("id", "1"),                     new XAttribute("name", name)                                                      ),              new XElement(WP.cNvGraphicFramePr,                  new XElement(A.graphicFrameLocks,                      new XAttribute(XNamespace.Xmlns + "a", A.a),                      new XAttribute("noChangeAspect", "1"))              ),              new XElement(A.graphic,                      new XAttribute(XNamespace.Xmlns + "a", A.a),                      new XElement(A.graphicData,                          new XAttribute("uri", Pic.pic),                          new XElement(Pic._pic,                              new XAttribute(XNamespace.Xmlns + "pic", Pic.pic),                              new XElement(Pic.nvPicPr,                                  new XElement(Pic.cNvPr,                                      new XAttribute("id", "0"),                                      new XAttribute("name", "")                                  ),                                  new XElement(Pic.cNvPicPr)                              ),                              new XElement(Pic.blipFill,                                  new XElement(A.blip,                                      new XAttribute(R.r + "embed", imageRId)                                  ),                                  new XElement(A.stretch,                                      new XElement(A.fillRect)                                  )                              ),                              new XElement(Pic.spPr,                                  new XElement(A.xfrm,                                      new XElement(A.off,                                          new XAttribute("x", "0"),                                          new XAttribute("y", "0")                                      ),                                      new XElement(A.ext,                                          new XAttribute("cx", imageWidth),                                          new XAttribute("cy", imageHeight)                                      )                                  ),                              new XElement(A.prstGeom,                                  new XAttribute("prst", "rect"),                                  new XElement(A.avLst)                              )                          )                      )                  )              )          )  );

There are several input parameters for this image element: the image dimensions, the dimensions of the space reserved for the image (extent), and the resource ID. The image name is not critical as the image part is referenced by the resource ID, not the image name.

The height and width of the image and the dimensions reserved for it are defined by the attributes in the A:ext and wp:extent elements, respectively. These values are in EMUs, English Metric Units, where 1 EMU = 1/914400 inch = 1/360000 cm. In this sample code, the image to be inserted is passed in as a Bitmap object. The methods that return the width and height for a Bitmap object return the values in a different unit, where 1 unit = 1/96 inch. Thus, the Bitmap image width and height are first converted into EMUs and then assigned as attribute values in the A:ext and wp:extent elements.

To understand how these dimensions effect the layout, see the examples below:

Image Size, Extent

Example 1

Example 2

Example 3

<a:ext

cx="2400000"

cy="1600000" />

cx="2400000"

cy="800000" />

cx="2400000"

cy="1600000" />

<wp:extent

cx="2400000"
cy="1600000" />

cx="1200000"
cy="800000" />

Notice in Example 2 that when the image size is smaller than the space reserved for it (extent), then the space is left unfilled. And when the extent dimensions are smaller than the image size, the image is squeezed into the extent space, as shown in Example 3.

After this image element has been instantiated, it is inserted between the bookmark start and end elements.

Move the Bookmark

The client requested to be able to insert multiple images at the same bookmark. Because the image is inserted between w:bookmarkStart and w:bookmarkEnd, one of these needed to be moved adjacent to the other. Otherwise the current image would be replaced by the new one. By moving the w:bookmarkEnd to after the w:bookmarkStart and before the image markup, the next image added via the method call to the same bookmark moves the existing image(s) to the right.

One important point about bookmark names in Word is that bookmark names are treated as case-insensitive within Word. That is, you cannot create bookmarks by name “A” and “a”; only one will be accepted. So when we work with bookmarks within code, we convert the bookmark name to uppercase to eliminate case-sensitivity. For example:

XElement bookmark = xDoc.Descendants(W.bookmarkStart)     .FirstOrDefault(d =>          ((string)d.Attribute(W.name)).ToUpper() == bookmarkName.ToUpper());

Create a New Part and Stream the Image into that Part

After adding the image element, the image part is created and then the image is streamed into that part. In this example, the image to be inserted at the bookmark is passed into the method as a Bitmap object: image. The variable imageFormatForSave specifies the format to save the image part as: e.g., ImageFormat.Png, ImageFormat.Jpeg, etc.

Lastly, the document’s root element is replaced with the new root element with the image markup, and then that is put into the MainDocumentPart.

MainDocumentPart mainPart = doc.MainDocumentPart;  ImagePart imagePart = mainPart.AddImagePart(ImageElement.GetImagePartType (imageFormatForSave), imageRId);                using (MemoryStream ms = new MemoryStream())  {      image.Save(ms, imageFormatForSave);      byte[] ba = ms.ToArray();      using (Stream s = imagePart.GetStream(FileMode.Create, FileAccess.ReadWrite))          s.Write(ba, 0, ba.GetUpperBound(0) + 1);  }                    xDoc.Elements().First().ReplaceWith(newRoot);  doc.MainDocumentPart.PutXDocument();

The sample code is attached. It provides several test cases to show the functionality of the image insertion utility.

Blog Post: Integrating Open XML Functionality in a PowerShell Script by using Managed Code via the Add-Type Cmdlet

Eric White — Thu, 07 Feb 2013 09:40:00 GMT

A question in a forum here at OpenXMLDeveloper.org clued me into a cool new way to add Open XML functionality into a PowerShell cmdlet -

PowerShell 2.0 and above enable you to directly embed C# code in a PowerShell script using the Add-Type cmdlet. To use this cmdlet, you pass two arguments:

A list of the fully qualified names of the assemblies that your C# code requires.
A string containing the C# code.

After calling the cmdlet, that type is available for your use in your PowerShell script. I've recorded a short video showing this approach. Here is the script that I show in the video (which is at the bottom of this post).

$assem = (    "windowsbase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",    "DocumentFormat.OpenXml, Version=2.0.5022.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"  )    $source = @"  using System;  using System.Collections;  using System.Collections.Generic;  using System.Linq;  using DocumentFormat.OpenXml.Packaging;  using DocumentFormat.OpenXml.Wordprocessing;    public class BasicTest  {    public static string DoOpenXmlFunc(string fileName)    {      using (WordprocessingDocument wDoc = WordprocessingDocument.Open(fileName, false))      {        var paragraphs = wDoc.MainDocumentPart.Document.Descendants<Paragraph>();        return paragraphs.Count().ToString();      }    }  }  "@    Add-Type -ReferencedAssemblies $assem -TypeDefinition $source  [BasicTest]::DoOpenXmlFunc(".\test.docx")

(Please visit the site to view this video)

Happy scripting!

Blog Post: Screen-Cast: Removing Elements in Recursive Pure Functional Transforms (RPFT) of XML

Eric White — Mon, 04 Feb 2013 15:33:00 GMT

This is the sixteenth screen-cast in a series on writing Recursive Pure Functional Transformations (RPFT) of XML. In this screen-cast, we discuss the selective elimination of elements from the newly cloned XML tree. We are, in effect, 'removing' an element from the original XML tree in the newly created XML tree.

Return to the Table of Contents of this screen-cast series. To demonstrate this scenario, I remove proofing marks from a WordprocessingML document. I also show removal of comments using this approach.

(Please visit the site to view this video)

Blog Post: How to Research Open XML PresentationML

Eric White — Thu, 31 Jan 2013 09:30:00 GMT

Recently, I received a question on one of forums here on OpenXMLDeveloper.org - how do you control the height for a table row, and also how to set the font size, background color, and etc. for a cell in a table in PresentationML. Rather than directly answer the question, I recorded a screen-cast that shows how to use the various tools to answer such questions for yourself. Once you have a good grasp of the tools, these things are pretty easy to research. So this screen-cast is called, How to Set Colors and Fonts in Cells in PresentationML, but it could as easily be called, How to Research Open XML Markup.

(Please visit the site to view this video)

Blog Post: Screen-Cast: Replacing Elements in Recursive Pure Functional Transforms (RPFT) of XML

Eric White — Mon, 28 Jan 2013 12:32:00 GMT

This is the fifteenth screen-cast in a series on writing Recursive Pure Functional Transformations (RPFT) of XML. In this screen-cast, we discuss transforming one particular element in an XML tree with a different element. We are, in effect, 'replacing' an element from the original XML tree with a new element in the newly created XML tree.

Return to the Table of Contents of this screen-cast series. To demonstrate this scenario, I transform a simple WordprocessingML document into an Html page. This transform is a pretty rudimentary transform - it's main goal is to demonstrate the point of the screen-cast. It is not a comprehensive, high fidelity transform from WordprocessingML to HTML. That is going to come later!

From here on, these screen-casts are more and more fun! If you are not having fun yet, the geek police are going to require you to turn in your pocket protector!

(Please visit the site to view this video)