C# OpenXmlElement类代码示例

 internal static void ApplyFontStyle(string style, OpenXmlElement styleElement)
 {
     if (string.Compare(italic, style, StringComparison.InvariantCultureIgnoreCase) == 0)
     {
         styleElement.Append(new Italic());
     }
 }

        private void SetMarginBottom(OpenXmlElement parent)
        {
            Paragraph para = parent.AppendChild(new Paragraph());
            para.ParagraphProperties = new ParagraphProperties();

            DocxMargin.SetBottomMargin(defaultDLMargin, para.ParagraphProperties);
        }

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

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

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

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

 private Paragraph CreateParagraph(DocxNode node, OpenXmlElement parent)
 {
     Paragraph para = parent.AppendChild(new Paragraph());
     OnParagraphCreated(node, para);
     OnOLParagraphCreated(this, new ParagraphEventArgs(para));
     return para;
 }

        /// <summary>
        /// Gets XmlPath information of the specified OpenXmlElement.
        /// </summary>
        /// <param name="element">The OpenXmlElement.</param>
        /// <returns>XmlPath to this element from root element.</returns>
        internal static XmlPath GetXPath(OpenXmlElement element)
        {
            if (element == null)
            {
                return null;
                // throw new ArgumentNullException("element");
            }

            XmlPath xmlPath = new XmlPath();
            
            xmlPath.PartUri = element.GetPartUri();

            Dictionary<string, string> namespaces = new Dictionary<string, string>();

            StringBuilder xpath = new StringBuilder("");

            BuildXPath(element, xpath, namespaces);

            xmlPath.XPath = xpath.ToString();

            StringBuilder nsString;

            foreach (var ns in namespaces)
            {
                nsString = new StringBuilder("");
                nsString.Append("xmlns:");
                nsString.Append(ns.Key);
                nsString.Append("=\"");
                nsString.Append(ns.Value);
                nsString.Append("\"");
                xmlPath.NamespacesDefinitions.Add(nsString.ToString());
            }

            return xmlPath;
        }

 internal static void ApplyFontWeight(string style, OpenXmlElement styleElement)
 {
     if (string.Compare(bold, style, StringComparison.InvariantCultureIgnoreCase) == 0 ||
         string.Compare(bolder, style, StringComparison.InvariantCultureIgnoreCase) == 0)
     {
         styleElement.Append(new Bold());
     }
 }

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

        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 static void ApplyTextAlign(string style, OpenXmlElement styleElement)
		{
			JustificationValues alignment;
					
			if (GetJustificationValue(style, out alignment))
			{
				styleElement.Append(new Justification() { Val = alignment });
			}
		}

 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>
        /// Initializes a new instance of the OpenXmlDomReader class using the supplied OpenXmlElement and Boolean values.
        /// </summary>
        /// <param name="openXmlElement">The OpenXmlElement to read.</param>
        /// <param name="readMiscNodes">Specify false to indicate to the reader to skip all miscellaneous nodes. The default value is false.</param>
        public OpenXmlDomReader(OpenXmlElement openXmlElement, bool readMiscNodes)
            : this(readMiscNodes)
        {
            if (openXmlElement == null)
            {
                throw new ArgumentNullException("openXmlElement");
            }

            this.Init(openXmlElement);
        }

 internal static void ApplyTextDecoration(string style, OpenXmlElement styleElement)
 {
     if (string.Compare(style, underLine, StringComparison.InvariantCultureIgnoreCase) == 0)
     {
         styleElement.Append(new Underline() { Val = UnderlineValues.Single });
     }
     else if (string.Compare(style, lineThrough, StringComparison.InvariantCultureIgnoreCase) == 0)
     {
         styleElement.Append(new Strike());
     }
 }

 public static IEnumerable<MergeField> GetMergeRuns(OpenXmlElement element)
 {
     // Gets each element under the element with text representing a merge field.
     foreach (var run in element.Descendants<Run>())
     {
         if (run.InnerText.StartsWith(MergeField.StartMergeField.ToString())
             && run.InnerText.EndsWith(MergeField.EndMergeField.ToString()))
         {
             yield return ConvertRunToMergeField(run);
         }
     }
 }

        public void AddCallBackMethod(OpenXmlElement element, CallBackMethod method)
        {
            if (!_callBackMethods.Keys.Contains(element.ElementTypeId))
            {
                _callBackMethods.Add(element.ElementTypeId, new List<CallBackMethod>());
            }

            // _callBackMethods[element.ElementTypeId] is a List. Let's check if the method obj is already added to the list.
            if (!_callBackMethods[element.ElementTypeId].Contains(method))
            {
               _callBackMethods[element.ElementTypeId].Add(method);
            }
        }