Coloring cells in an OpenXml SpreadsheetDocument

Tow days, and many readings. That's the time I needed to figure out how to set a cell color in an openXml spreadsheet.

It finally ends by the use of the OpenXml SDK Productivity Tool.

The main point seems to be that there must be a minimal stylesheet in the spreadsheet. Among other, this minimal stylesheet must comprise s two Fills. This styleshett may be generated by the following code:

private void GenerateWorkbookStylesPartContent(WorkbookPart workbookPart, String partId) {
    WorkbookStylesPart wsp = workbookPart.AddNewPart(partId);

    Stylesheet stylesheet = new Stylesheet() { 
        MCAttributes = new MarkupCompatibilityAttributes() { Ignorable = "x14ac" } };
    stylesheet.AddNamespaceDeclaration("mc", 
        "http://schemas.openxmlformats.org/markup-compatibility/2006");
    stylesheet.AddNamespaceDeclaration("x14ac", 
        "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac");

    Fonts fonts = new Fonts() { Count = (UInt32Value)1U, KnownFonts = true };
    Font font = new Font();
    FontSize fontSize = new FontSize() { Val = 11D };
    Color color = new Color() { Theme = (UInt32Value)1U };
    FontName fontName = new FontName() { Val = "Calibri" };
    FontFamilyNumbering fontFamilyNumbering = new FontFamilyNumbering() { Val = 2 };
    FontScheme fontScheme = new FontScheme() { Val = FontSchemeValues.Minor };
    font.Append(fontSize);
    font.Append(color);
    font.Append(fontName);
    font.Append(fontFamilyNumbering);
    font.Append(fontScheme);
    fonts.Append(font);
    stylesheet.Fonts = fonts;

    Borders borders = new Borders() { Count = (UInt32Value)1U };
    Border border = new Border();
    LeftBorder leftBorder = new LeftBorder();
    RightBorder rightBorder = new RightBorder();
    TopBorder topBorder = new TopBorder();
    BottomBorder bottomBorder = new BottomBorder();
    DiagonalBorder diagonalBorder = new DiagonalBorder();
    border.Append(leftBorder);
    border.Append(rightBorder);
    border.Append(topBorder);
    border.Append(bottomBorder);
    border.Append(diagonalBorder);
    borders.Append(border);
    stylesheet.Borders = borders;

    stylesheet.Fills = new Fills();
    Fill f = new Fill { PatternFill = 
        new PatternFill { PatternType = PatternValues.None}};
    stylesheet.Fills.Append(f);
    stylesheet.Fills.Append(new Fill { PatternFill = 
        new PatternFill { PatternType = PatternValues.Gray125 } });

    CellFormats cellFormats = new CellFormats() { Count = (UInt32Value)1U };
    CellFormat cellFormat = new CellFormat() { 
        NumberFormatId = (UInt32Value)0U, 
        FontId = (UInt32Value)0U, 
        FillId = (UInt32Value)0U, 
        BorderId = (UInt32Value)0U, 
        FormatId = (UInt32Value)0U };
    cellFormats.Append(cellFormat);
    stylesheet.CellFormats = cellFormats;

    CellStyles cellStyles = new CellStyles() { Count = (UInt32Value)1U };
    CellStyle cellStyle = new CellStyle() { 
        Name = "Normal", FormatId = (UInt32Value)0U, BuiltinId = (UInt32Value)0U };
    stylesheet.CellStyles = cellStyles;

    CellStyleFormats cellStyleFormats = new CellStyleFormats() { Count = (UInt32Value)1U };
    CellFormat cellFormat2 = new CellFormat() { 
        NumberFormatId = (UInt32Value)0U, 
        FontId = (UInt32Value)0U, 
        FillId = (UInt32Value)0U, 
        BorderId = (UInt32Value)0U };
    cellStyleFormats.Append(cellFormat2);
    stylesheet.CellStyleFormats = cellStyleFormats;

    cellStyles.Append(cellStyle);

    wsp.Stylesheet = stylesheet;
}

From here, all what remain to do is handle the color in the cells, during the process I use a dictionary to avoid querying the stylesheet. In my case the key type is System.Drawing.Color because I'm exporting a DataGridView but, of course this type can be of any type you need.

    private Dictionary _colors = 
        new Dictionary();

Then, somewhere in the code:

UInt32 cellStyleUid = 0;
if ( col != System.Drawing.Color.Transparent) {
    if (!_colors.ContainsKey(col)) {
        //that is the style does not exists for this color
        if (_ssDoc.WorkbookPart.WorkbookStylesPart == null) {
            GenerateWorkbookStylesPartContent(_ssDoc.WorkbookPart, "rId5");
        }

        //Create the Fill
        Fill fill = new Fill();
        PatternFill pf = new PatternFill { PatternType = PatternValues.Solid };
        ForegroundColor fgc = new ForegroundColor { 
             Rgb = HexBinaryValue.FromString(Convert.ToString(col.ToArgb(), 16)) };
        BackgroundColor bgc = new BackgroundColor() { Indexed = (UInt32Value)64U };
        pf.Append(fgc);
        pf.Append(bgc);
        fill.Append(pf);
        //update the stylesheet
        _ssDoc.WorkbookPart.WorkbookStylesPart.Stylesheet.Fills.Append(fill);
        Int32 iFill = _ssDoc.WorkbookPart.WorkbookStylesPart.Stylesheet.Fills.Count() - 1;
        _ssDoc.WorkbookPart.WorkbookStylesPart.Stylesheet.Fills.Count = (UInt32)(iFill + 1);

        //Create the CellFormat to use the created Fill
        CellFormat lcf = 
            (CellFormat)_ssDoc.WorkbookPart.WorkbookStylesPart.Stylesheet.CellFormats.LastChild;
        CellFormat cf = new CellFormat { 
            NumberFormatId = lcf.NumberFormatId,
            FontId = lcf.FontId,
            FillId = (UInt32Value)(UInt32)iFill,
            BorderId = lcf.BorderId,
            FormatId = lcf.FormatId,
            ApplyFill = true,
            ApplyFont = lcf.ApplyFont
        };                   

        //update the stylesheet 
        _ssDoc.WorkbookPart.WorkbookStylesPart.Stylesheet.CellFormats.Append(cf);
        Int32 iCellFormat = 
            _ssDoc.WorkbookPart.WorkbookStylesPart.Stylesheet.CellFormats.Count() - 1;
        _ssDoc.WorkbookPart.WorkbookStylesPart.Stylesheet.CellFormats.Count = 
            (UInt32)(iCellFormat + 1);

        //put the index of the new CellFormat in the buffer
        _colors.Add(col, (UInt32)iCellFormat);

    }
    //retrieve the index of the cell format for the color
    cellStyleUid = _colors[col];
}

It remains to use the updated stylesheet at the cell level. With cell being of type DocumentFormat.OpenXml.Spreadsheet.Cell

if (cellStyleUid != 0)
    cell.StyleIndex = cellStyleUid;

Et voilà !

Merging runs in an openxml file/document

The goal is to reduce the number of runs in the paragraphs of a document. I made the choice not to use the openxml SDK. Indeed my goal is a templating engine. In my process the runs may contain xsl, that is xml. So I made the choice to stay on raw XML tools.

The operational (without the usings, except those revealing a dependency) code looks like:

namespace SandBox {
    class Program {
        static void Main(string[] args) {
            try {

                String fileName = @"somepath\somefile.docx";
                String destFile = "res.docx";
                
                Tuple<XPathNavigator, XmlNamespaceManager> xp = 
                    ZDocx.GetNavigatorAndManagerFromString(
                        ZDocx.GetDocxDocumentStringFromDocxFile(fileName));
                XPathNavigator xpn = xp.Item1;
                XmlNamespaceManager xnm = xp.Item2;

                XPathNodeIterator xni = xpn.Select("//w:p", xnm);
                while (xni.MoveNext()) {
                    //Merge all runs ignoring styles
                    //ZDocx.MergeRuns(xni.Current);
                    //Merge considering only Bold as a grouping condition
                    ZDocx.MergeRuns(xni.Current, new ByStylesNodesComparator  {
                        Settings = new ByStylesNodesComparatorSettings {
                            CheckBold = true
                    }});                    
                }

                System.IO.File.Copy(fileName, destFile, true);
                ZDocx.SetDocxDocumentStringToDocxFile(xpn, destFile);

            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

There are 3 main steps:

• I fristly load the document.xml part the openxml file in an XPathNavigator
• Then I process each paragraph.
• Finally I inject the modified document.xml in a new openxml file.

First the cooking code:

using Ionic.Zip;

namespace SandBox {
    public class ZDocx {
        public static String nsW = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";

        public static String GetDocxDocumentStringFromDocxFile(String fileName) {
            String tf = System.IO.Path.GetTempFileName();
            StreamWriter sw = new StreamWriter(tf);
            using (ZipFile zip = ZipFile.Read(fileName)) {
                ZipEntry e = zip["word\\document.xml"];
                e.Extract(sw.BaseStream);                
            }
            try {
                sw.Close();
            } catch { }
            
            StreamReader sr = new StreamReader(tf);
            String st = sr.ReadToEnd();
            sr.Close();
            System.IO.File.Delete(tf);
            
            return st;
        }

        public static void SetDocxDocumentStringToDocxFile(XPathNavigator xdoc, String fileName) {            
            using (ZipFile zip = ZipFile.Read(fileName)) {
                using (MemoryStream ms = new MemoryStream()) {
                    XmlWriterSettings xws = new XmlWriterSettings {
                        Encoding = Encoding.UTF8
                    };
                    using (XmlWriter xw = XmlWriter.Create(ms, xws)) {
                        xw.WriteNode(xdoc, false);
                        xw.Flush();
                        ms.Position = 0;
                        zip.UpdateEntry("word\\document.xml", ms);
                        zip.Save();
                    }
                }
            }            
        }

        public static Tuple<XPathNavigator, XmlNamespaceManager> GetNavigatorAndManagerFromString(String st) {
            XmlDocument xml = new XmlDocument();
            StringReader stReader = new StringReader(st);
            XmlReader xReader = XmlReader.Create(stReader, new XmlReaderSettings() { 
                IgnoreWhitespace = false, 
                CloseInput = true });
            xml.Load(xReader);
            xReader.Close();
            XPathNavigator navXml = xml.CreateNavigator();
            XmlNamespaceManager manager = new XmlNamespaceManager(navXml.NameTable);
            manager.AddNamespace("w", nsW);
            manager.AddNamespace("xsl", "http://www.w3.org/1999/XSL/Transform");

            return new Tuple<XPathNavigator, XmlNamespaceManager>(navXml, manager);
        }

    }
}

Then the merging code:

namespace SandBox {
    public class ZDocx {
        public static void MergeRuns(XPathNavigator paragraph, INodeComparator areMergeable = null) {
            if (paragraph.LocalName != "p")
                throw new Exception("MergeRuns: paragraph is not a 'w:p'.");
            if (areMergeable == null)
                areMergeable = AlwaysTrueNodesComparator.GetInstance();

            XPathNavigator destRun = null;
            XPathNavigator lPara = paragraph.Clone();
            lPara.MoveToFirstChild();
            do {
                if (lPara.LocalName != "r")
                    continue;

                if (destRun == null) {
                    destRun = lPara.Clone();
                    continue;
                }

                if ( areMergeable.AreMergeable(destRun, lPara) ) {
                    XPathNavigator nL = lPara.Clone();
                    XPathNavigator nK = destRun.Clone();
                    nL.MoveToChild("t", nsW);
                    nK.MoveToChild("t", nsW);
                    nK.InnerXml += nL.InnerXml;                    
                    nL.MoveToParent();
                    nL.MoveToPrevious();
                    lPara.DeleteSelf();
                    lPara = nL;
                } else {
                    destRun = lPara.Clone();
                }

            } while (lPara.MoveToNext());
        }
    }
}

In the previous code, one key is the areMergeable parameter: this parameter allows to decide how the merging occurs. This parameter implements the following interface.

    public interface INodeComparator {
        Boolean AreMergeable(XPathNavigator xpn1, XPathNavigator xpn2);
    }

This interface may be implemented as in the following samples provided as an inspiration root:

namespace SandBox {
    public class AlwaysTrueNodesComparator : INodeComparator {
        private AlwaysTrueNodesComparator() {}

        private static AlwaysTrueNodesComparator _inst = new AlwaysTrueNodesComparator();
        public static AlwaysTrueNodesComparator GetInstance() {
            return _inst;
        }

        public Boolean AreMergeable(XPathNavigator xpn1, XPathNavigator xpn2) {
            return true;
        }
    }

    public class ByStylesNodesComparatorSettings {
        public Boolean CheckBold { get; set; }
        public Boolean CheckUnderlined { get; set; }
        public Boolean CheckItalic { get; set; }
        public Boolean CheckStriked { get; set; }
    }

    public class ByStylesNodesComparator : INodeComparator {
        public ByStylesNodesComparatorSettings Settings { get; set; }

        public Boolean AreMergeable(XPathNavigator xpn1, XPathNavigator xpn2) {
            XPathNavigator nav1 = xpn1.Clone();
            XPathNavigator nav2 = xpn2.Clone();

            Boolean nav1HasRPr = nav1.MoveToChild("rPr", ZDocx.nsW);
            Boolean nav2HasRPr = nav2.MoveToChild("rPr", ZDocx.nsW);

            Boolean b1, b2;

            if (Settings == null || Settings.CheckBold) {
                b1 = nav1HasRPr && nav1.SelectChildren("b", ZDocx.nsW).Count == 1;
                b2 = nav2HasRPr && nav2.SelectChildren("b", ZDocx.nsW).Count == 1;
                if (b1 != b2)
                    return false;
            }

            if (Settings == null || Settings.CheckUnderlined) {
                b1 = nav1HasRPr && nav1.SelectChildren("u", ZDocx.nsW).Count == 1;
                b2 = nav2HasRPr && nav2.SelectChildren("u", ZDocx.nsW).Count == 1;
                if (b1 != b2)
                    return false;
            }

            if (Settings == null || Settings.CheckItalic) {
                b1 = nav1HasRPr && nav1.SelectChildren("i", ZDocx.nsW).Count == 1;
                b2 = nav2HasRPr && nav2.SelectChildren("i", ZDocx.nsW).Count == 1;
                if (b1 != b2)
                    return false;
            }

            if (Settings == null || Settings.CheckStriked) {
                b1 = nav1HasRPr && nav1.SelectChildren("strike", ZDocx.nsW).Count == 1;
                b2 = nav2HasRPr && nav2.SelectChildren("strike", ZDocx.nsW).Count == 1;
                if (b1 != b2)
                    return false;
            }

            return true;
        }
    }
}

Take care to clone the navigators in the AreMergeable method to not surprise the caller.

Using AlwaysTrueNodesComparator reduces all paragraphs to one single run with the styles (or not) of the first run of the reduced paragraph.

Using ByStylesNodesComparator allows to merge runs according to some part of their styles. In the implemented class the handled style are Bold, Underline, Strike and Italic. Be careful that only basis underlining is handled. The underline style is not handled.

Bulleting in MsWord openXml document, using OpenXml SDK: the basics.

As often the most important is the understanding of the model, here of the XML model.
This article is a simplifcation of Working with Numbered Lists in Open XML WordprocessingML.

Bulleting is a part of Numbering.

Numbering is a NumberingProperties (numPr) property in a ParagraphProperties property of a Paragraph from a Document object.

That is a hierarchy as follow:

<w:document>
    <w:body>
        <w:p>
            <w:pPr>
                <w:numPr>
                    <w:ilvl>X</w:ilvl>
                    <w:numId val="Y" />

numId leads to an NumberingInstance (num) in NumberingDefinitionsPart of MainDocumentPart of WordProcessingDocument.

//word/numbering.xml
    <w:numbering>
        <w:num w:numId="Y">
            <w:abstractNumId w:val="Z" />

abstractNumId leads to a AbstractNum (abstractNum)

//word/numbering.xml
    <w:numbering>
        <w:abstractNum w:abstractNumId="Z" >
            <w:lvl w:ilvl="X">
                ...
            </w:lvl>
        <w:num w:numId="Y">
            <w:abstractNumId w:val="Z" />

It is now clear that to get the bullet properties we have to traverse from the NumberingProperties of the Paragraph comprising the text of the bullet. Then we go to the NumberingDefinitionsPart searching the corresponding numId, That give us an abstractNumId which, with the ilvl of the ParagraphProperties, give us the Level we seek.
Remark
If you have a ParagraphProperties at the Paragraph level, the Paragraph stays a bullet (because of Paragraph.NumberingProperties), but the values from Paragraph.ParagraphProperties prevail over those of NumberingProperties.