private IList<OpenXmlCompositeElement> ConvertContentToParagraphs(MainDocumentPart mainDocumentPart)
 {
     var converter = new HtmlConverter(mainDocumentPart) { RenderPreAsTable = false };
     return converter.Parse(_content
         .Replace("<img", "<img style=\"max-width:550;\"")
         .Replace("<pre><code>", "<p class=\"codesnippet\"><pre>")
         .Replace("</code></pre>", "</pre></p>")
         .Replace("<code>", "<span class=\"inlinecodesnippet\">")
         .Replace("</code>", "</span>"));
 }

        public override void AppendTo(OpenXmlElement openXmlNode, MainDocumentPart mainDocumentPart)
        {
            _mainDocumentPart = mainDocumentPart;

            var imagePart = CreateImagePart();
            openXmlNode.Append(CreateImageElement(mainDocumentPart.GetIdOfPart(imagePart), Path.GetFileName(_content)));
        }

        /// <summary>
        /// Get ContentControl from word document
        /// </summary>
        /// <param name="pDoc">Document mainpart</param>
        /// <param name="pTag">ContentControl tag to find</param>
        /// <returns>The ContentControl</returns>
        public static SdtBlock GetContentControl(MainDocumentPart pDoc, string pTag)
        {
            SdtBlock cc = pDoc.Document.Body.Descendants<SdtBlock>().Where
                     (r => r.SdtProperties.GetFirstChild<Tag>().Val == pTag).Single();

            return cc;
        }

        /// <summary>
        /// Gets the custom XML part.
        /// </summary>
        /// <param name="mainDocumentPart">The main document part.</param>
        /// <returns></returns>
        public CustomXmlPart GetCustomXmlPart(MainDocumentPart mainDocumentPart)
        {
            if (mainDocumentPart == null)
            {
                throw new ArgumentNullException("mainDocumentPart");
            }

            CustomXmlPart result = null;

            foreach (CustomXmlPart part in mainDocumentPart.CustomXmlParts)
            {
                using (XmlTextReader reader = new XmlTextReader(part.GetStream(FileMode.Open, FileAccess.Read)))
                {
                    reader.MoveToContent();
                    bool exists = reader.NamespaceURI.Equals(this.namespaceUri);

                    if (exists)
                    {
                        result = part;
                        break;
                    }
                }
            }

            return result;
        }

 public NumberingListStyleCollection(MainDocumentPart mainPart)
 {
     this.mainPart = mainPart;
     this.absNumId = -1;
     this.numInstances = new Stack<Int32>();
     InitNumberingIds();
 }

        /// <summary>
        /// Gets the type of the name to value collection from element for.
        /// </summary>
        /// <param name="mainDocumentPart">The main document part.</param>
        /// <param name="elementName">Name of the element.</param>
        /// <param name="forNodeType">Type of for node.</param>
        /// <returns></returns>
        public Dictionary<string, string> GetNameToValueCollectionFromElementForType(MainDocumentPart mainDocumentPart, string elementName, NodeType forNodeType)
        {
            Dictionary<string, string> nameToValueCollection = new Dictionary<string, string>();
            CustomXmlPart customXmlPart = this.customXmlPartCore.GetCustomXmlPart(mainDocumentPart);

            if (customXmlPart != null)
            {
                XElement element = this.customXmlPartCore.GetFirstElementFromCustomXmlPart(customXmlPart, elementName);

                if (element != null)
                {
                    if (forNodeType == NodeType.Element)
                    {
                        foreach (XElement elem in element.Elements())
                        {
                            nameToValueCollection.Add(elem.Name.LocalName, elem.Nodes().Where(node => node.NodeType == XmlNodeType.Element).FirstOrDefault().ToString());
                        }
                    }
                    else if (forNodeType == NodeType.Attribute)
                    {
                        foreach (XAttribute attr in element.Attributes())
                        {
                            nameToValueCollection.Add(attr.Name.LocalName, attr.Value);
                        }
                    }
                }
            }

            return nameToValueCollection;
        }

        /// <summary>
        /// Generates a hyperlink and embed it
        /// in a paragraph tag
        /// </summary>
        /// <param name="mainDocPart">The main doc part.</param>
        /// <param name="hyperLink">The hyper link.</param>
        /// <returns></returns>
        public static Paragraph GenerateParagraphWithHyperLink(MainDocumentPart mainDocPart, String hyperLink)
        {
            //this will be display as
            //the text
            String urlLabel = hyperLink;

            //build the hyperlink
            //file:// ensure that document does not corrupt
            System.Uri uri = new Uri(@"file://" + hyperLink);

            //add it to the document
            HyperlinkRelationship rel = mainDocPart.AddHyperlinkRelationship(uri, true);

            //get the hyperlink id
            string relationshipId = rel.Id;

            //create the new paragraph tag
            Paragraph newParagraph = new Paragraph(
                new DocumentFormat.OpenXml.Wordprocessing.Hyperlink(
                    new ProofError() { Type = ProofingErrorValues.GrammarStart },
                    new DocumentFormat.OpenXml.Wordprocessing.Run(
                        new DocumentFormat.OpenXml.Wordprocessing.RunProperties(
                            new RunStyle() { Val = "Hyperlink" }),
                            new DocumentFormat.OpenXml.Wordprocessing.Text(urlLabel)
                            )) { History = OnOffValue.FromBoolean(true), Id = relationshipId });

            return newParagraph;
        }

        /// <summary>
        /// Refreshes the charts.
        /// </summary>
        /// <param name="mainDocumentPart">The main document part.</param>
        protected override void RefreshCharts(MainDocumentPart mainDocumentPart)
        {
            if (mainDocumentPart != null)
            {
                foreach (ChartPart chartPart in mainDocumentPart.ChartParts)
                {
                    Chart chart = chartPart.ChartSpace.Elements<Chart>().FirstOrDefault();

                    if (chart != null)
                    {
                        DocumentFormat.OpenXml.Drawing.Charts.ScatterChart scatterChart = chart.Descendants<DocumentFormat.OpenXml.Drawing.Charts.ScatterChart>().FirstOrDefault();
                        DocumentFormat.OpenXml.Drawing.Charts.Line3DChart lineChart = chart.Descendants<DocumentFormat.OpenXml.Drawing.Charts.Line3DChart>().FirstOrDefault();

                        if (scatterChart != null)
                        {
                            ScatterChartEx chartEx = new ScatterChartEx(chartPart, this.scatterChartData);
                            chartEx.Refresh();
                        }

                        if (lineChart != null)
                        {
                            Line3DChartEx chartEx = new Line3DChartEx(chartPart, this.lineChartData);
                            chartEx.Refresh();
                        }
                    }

                    chartPart.ChartSpace.Save();
                }
            }
        }

        public override void InsertAfter(OpenXmlElement openXmlNode, MainDocumentPart mainDocumentPart)
        {
            _mainDocumentPart = mainDocumentPart;

            var imagePart = CreateImagePart();
            openXmlNode.InsertAfterSelf(CreateImageElement(mainDocumentPart.GetIdOfPart(imagePart), Path.GetFileName(_content)));
        }

 public static Styles CreateStyles(MainDocumentPart mainPart)
 {
     StyleDefinitionsPart styleDefinitionsPart = mainPart.AddNewPart<StyleDefinitionsPart>();
     Styles styles = new Styles();
     styleDefinitionsPart.Styles = styles;
     //styles.Save();
     return styles;
 }

        /// <summary>
        /// Open an Word XML document 
        /// </summary>
        /// <param name="docname">name of the document to be opened</param>
        public void OpenTheDocuemnt(string docname)
        {
            // open the word docx
            wordProcessingDocument = WordprocessingDocument.Open(docname, true);

            // get the Main Document part
            mainDocPart = wordProcessingDocument.MainDocumentPart;
        }

        public override void AppendTo(OpenXmlElement openXmlNode, MainDocumentPart mainDocumentPart)
        {
            var text = _newParagraph 
                ? (OpenXmlElement)new Paragraph(new Run(new Text(_content)))
                : (OpenXmlElement)new Run(new Text(_content));

            openXmlNode.Append(text);
        }

 internal WordprocessingDocument CreateDocument(String fileName)
 {
     docxFile = WordprocessingDocument.Create(fileName, WordprocessingDocumentType.Document);
     mainPart = docxFile.AddMainDocumentPart();
     docxFile.MainDocumentPart.Document = new DocumentFormat.OpenXml.Wordprocessing.Document(new Body());
     body = docxFile.MainDocumentPart.Document.Body;
     return docxFile;
 }

 public override void AppendTo(OpenXmlElement openXmlNode, MainDocumentPart mainDocumentPart)
 {
     var paragraphs = ConvertContentToParagraphs(mainDocumentPart);
     foreach (var paragraph in paragraphs)
     {
         openXmlNode.Append(paragraph);
     }
 }

 internal HtmlDocumentStyle(MainDocumentPart mainPart)
 {
     PrepareStyles(mainPart);
     tableStyle = new TableStyleCollection(this);
     runStyle = new RunStyleCollection(this);
     paraStyle = new ParagraphStyleCollection(this);
     this.QuoteCharacters = QuoteChars.IE;
     this.mainPart = mainPart;
 }

 public override void InsertAfter(OpenXmlElement openXmlNode, MainDocumentPart mainDocumentPart)
 {
     var paragraphs = ConvertContentToParagraphs(mainDocumentPart);
     var insertPoint = openXmlNode;
     foreach (var paragraph in paragraphs)
     {
         insertPoint.InsertAfterSelf(paragraph);
         insertPoint = paragraph;
     }
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="mainPart">The mainDocumentPart of a document where to write the conversion to.</param>
 /// <remarks>We preload some configuration from inside the document such as style, bookmarks,...</remarks>
 public HtmlConverter(MainDocumentPart mainPart)
 {
     this.mainPart = mainPart;
     this.RenderPreAsTable = true;
     this.ImageProcessing = ImageProcessing.AutomaticDownload;
     this.knownTags = InitKnownTags();
     this.htmlStyles = new HtmlDocumentStyle(mainPart);
     this.knownImageParts = new Dictionary<Uri, CachedImagePart>();
     this.WebProxy = new WebProxy();
 }

        private OpenXmlElement GetHeaderTextElement(MainDocumentPart mainDocumentPart)
        {
            var paragraph = new Paragraph(new Run(new Text(_content)));
            var styleId = GetStyleIdbyName(mainDocumentPart, string.Format("Heading {0}", _navigationLevel));
            if (!string.IsNullOrEmpty(styleId))
            {
                paragraph.ParagraphProperties = new ParagraphProperties(new ParagraphStyleId() { Val = styleId });
            }

            return paragraph;
        }

        public void GenerateTextContent(MainDocumentPart mainPart, Client client, string contentFile)
        {
            GetContent(client, contentFile);
            string customXml = File.ReadAllText(destinationXml);
            replaceCustomXML(mainPart, customXml);
            mainPart.Document.Save();

            //Delete the temp files
            //File.Delete(tempFile);
            //File.Delete(destinationXml);
        }

        /// <summary>
        /// Removes the custom XML part.
        /// </summary>
        /// <param name="mainDocumentPart">The main part.</param>
        /// <param name="customXmlPart">The custom XML part.</param>
        public static void RemoveCustomXmlPart(MainDocumentPart mainDocumentPart, CustomXmlPart customXmlPart)
        {
            if (mainDocumentPart == null)
            {
                throw new ArgumentNullException("mainDocumentPart");
            }

            if (customXmlPart != null)
            {
                RemoveCustomXmlParts(mainDocumentPart, new List<CustomXmlPart>(new[] { customXmlPart }));
            }
        }