public override List<string> Tag(XElement element) { return element.Ancestors() .Where(e => e.Name.LocalName == "classdef") .Select(e => e.NthElementOrDefault(1)) .Where(e => e != null) .Select(e => e.Value) .ToList(); }
/// <summary> /// Gets the access modifiers for this method. In C++, methods are contained within /// "specifier" blocks /// </summary> /// <param name="methodElement">The method typeUseElement</param> /// <returns>The access modifier for this method; if none, it returns see /// cref="AccessModifier.None"/></returns> protected override AccessModifier GetAccessModifierForMethod(XElement methodElement) { Dictionary<XName, AccessModifier> accessModifierMap = new Dictionary<XName, AccessModifier>() { { SRC.Public, AccessModifier.Public }, { SRC.Private, AccessModifier.Private }, { SRC.Protected, AccessModifier.Protected }, }; var specifiers = from container in methodElement.Ancestors() where SpecifierContainerNames.Contains(container.Name) select accessModifierMap[container.Name]; return (specifiers.Any() ? specifiers.First() : AccessModifier.None); }
public static List<string> GetTag(XElement element) { var result = element.Ancestors("compilationUnit") .Elements("packageDeclaration") .Select(e => e.ElementAt(1).Value) .ToList(); result.AddRange( element.AncestorsAndSelf() .Where( e => e.Name.LocalName == "normalClassDeclaration" || e.Name.LocalName == "methodDeclaration") // ReSharper disable PossibleNullReferenceException .Select(e => e.Element("IDENTIFIER").Value) // ReSharper restore PossibleNullReferenceException .Reverse()); return result; }
private static IEnumerable<string> ExtractCategories(XElement testCaseNode) { var categories = NUnitParsingHelper.GetCategories(testCaseNode, true); // if this is a parameterized test, get the categories from the parent test-suite var parameterizedTestElement = testCaseNode .Ancestors("test-suite").ToList() .Where(x => x.Attribute("type").Value == "ParameterizedTest") .FirstOrDefault(); if (null != parameterizedTestElement) { var paramCategories = NUnitParsingHelper.GetCategories(parameterizedTestElement, false); categories.AddRange(paramCategories); } return categories; }
public static ElementCompileTreeNode BuildRec(XElement element) { int depth = element.Ancestors().Count(); var debugInfo = new XmlSourceNodeInformation(depth, element.Name.LocalName, element.Name.LocalName, element.Name.NamespaceName); var result = new ElementCompileTreeNode(debugInfo); foreach (var attribute in element.Attributes()) { if (attribute.Name.LocalName == "xmlns") continue; bool isNamespaceDeclaration = attribute.Name.Namespace == "http://www.w3.org/2000/xmlns/"; var property = new PropertyCompileTreeNode(attribute.Name.LocalName, debugInfo, isNamespaceDeclaration); property.Value = StringResourceSystemFacade.ParseString(attribute.Value); result.AddNamedProperty(property); } foreach (var node in element.Nodes()) { if (node is XElement) { result.Children.Add(BuildRec(node as XElement)); continue; } if (node is XText) { string text = (node as XText).Value; if (string.IsNullOrWhiteSpace(text)) { continue; } var textProperty = new PropertyCompileTreeNode(CompilerGlobals.DefaultPropertyName, debugInfo); textProperty.Value = StringResourceSystemFacade.ParseString(text); result.DefaultProperties.Add(textProperty); continue; } } return result; }
public static StructElement RetrieveStructElement(XElement field, List<ProgramElement> programElements) { IEnumerable<XElement> ownerStructs = from el in field.Ancestors(SRC.Struct) select el; if (ownerStructs.Count() > 0) { XElement name = ownerStructs.First().Element(SRC.Name); string ownerStructName = name.Value; //now find the StructElement object corresponding to ownerClassName, since those should have been gen'd by now ProgramElement ownerStruct = programElements.Find(element => element is StructElement && ((StructElement)element).Name == ownerStructName); return ownerStruct as StructElement; } else { //field is not contained by a class return null; } }
private static bool MatchesLocalVariable(SrcMLDataContext db, VariableDeclaration def, XElement use) { if (def.IsGlobal ?? false) return false; if (def.DeclarationName != use.Value) return false; var useXPath = use.GetXPath(false); var validScopes = from scope in db.ValidScopes where scope.DefinitionId == def.Id select scope; foreach (var scope in validScopes) { if (useXPath.StartsWith(scope.XPath)) return true; } var method = (from ancestor in use.Ancestors() where ContainerNames.MethodDefinitions.Any(mn => mn == ancestor.Name) select ancestor).FirstOrDefault(); var classNameFromMethod = SrcMLHelper.GetClassNameForMethod(method); if (null == classNameFromMethod) { return false; } var classDef = from scope in def.ValidScopes.OfType<TypeDefinition>() where scope.TypeName == classNameFromMethod.Value select scope; if (classDef.Any()) { return true; } return false; }
private static void DetermineRunMarks(XElement run, XElement rPr, Dictionary<string, string> style, out XEntity runStartMark, out XEntity runEndMark) { runStartMark = null; runEndMark = null; // Only do the following for text runs. if (run.Element(W.t) == null) return; // Can't add directional marks if the font-family is symbol - they are visible, and display as a ? var addDirectionalMarks = true; if (style.ContainsKey("font-family")) { if (style["font-family"].ToLower() == "symbol") addDirectionalMarks = false; } if (!addDirectionalMarks) return; var isRtl = rPr.Element(W.rtl) != null; if (isRtl) { runStartMark = new XEntity("#x200f"); // RLM runEndMark = new XEntity("#x200f"); // RLM } else { var paragraph = run.Ancestors(W.p).First(); var paraIsBidi = paragraph .Elements(W.pPr) .Elements(W.bidi) .Any(b => b.Attribute(W.val) == null || b.Attribute(W.val).ToBoolean() == true); if (paraIsBidi) { runStartMark = new XEntity("#x200e"); // LRM runEndMark = new XEntity("#x200e"); // LRM } } }
private static int CalcWidthOfRunInTwips(XElement r) { var fontName = (string)r.Attribute(PtOpenXml.pt + "FontName") ?? (string)r.Ancestors(W.p).First().Attribute(PtOpenXml.pt + "FontName"); if (fontName == null) throw new OpenXmlPowerToolsException("Internal Error, should have FontName attribute"); if (UnknownFonts.Contains(fontName)) return 0; var rPr = r.Element(W.rPr); if (rPr == null) throw new OpenXmlPowerToolsException("Internal Error, should have run properties"); var sz = GetFontSize(r) ?? 22m; // unknown font families will throw ArgumentException, in which case just return 0 if (!KnownFamilies.Contains(fontName)) return 0; // in theory, all unknown fonts are found by the above test, but if not... FontFamily ff; try { ff = new FontFamily(fontName); } catch (ArgumentException) { UnknownFonts.Add(fontName); return 0; } var fs = FontStyle.Regular; if (GetBoolProp(rPr, W.b) || GetBoolProp(rPr, W.bCs)) fs |= FontStyle.Bold; if (GetBoolProp(rPr, W.i) || GetBoolProp(rPr, W.iCs)) fs |= FontStyle.Italic; // Appended blank as a quick fix to accommodate that will get // appended to some layout-critical runs such as list item numbers. // In some cases, this might not be required or even wrong, so this // must be revisited. // TODO: Revisit. var runText = r.DescendantsTrimmed(W.txbxContent) .Where(e => e.Name == W.t) .Select(t => (string) t) .StringConcatenate() + " "; var tabLength = r.DescendantsTrimmed(W.txbxContent) .Where(e => e.Name == W.tab) .Select(t => (decimal)t.Attribute(PtOpenXml.TabWidth)) .Sum(); if (runText.Length == 0 && tabLength == 0) return 0; int multiplier = 1; if (runText.Length <= 2) multiplier = 100; else if (runText.Length <= 4) multiplier = 50; else if (runText.Length <= 8) multiplier = 25; else if (runText.Length <= 16) multiplier = 12; else if (runText.Length <= 32) multiplier = 6; if (multiplier != 1) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < multiplier; i++) sb.Append(runText); runText = sb.ToString(); } try { using (Font f = new Font(ff, (float) sz/2f, fs)) { const TextFormatFlags tff = TextFormatFlags.NoPadding; var proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels const decimal dpi = 96m; var twip = (int) (((sf.Width/dpi)*1440m)/multiplier + tabLength*1440m); return twip; } } catch (ArgumentException) { try { const FontStyle fs2 = FontStyle.Regular; using (Font f = new Font(ff, (float) sz/2f, fs2)) { const TextFormatFlags tff = TextFormatFlags.NoPadding; var proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels const decimal dpi = 96m; var twip = (int) (((sf.Width/dpi)*1440m)/multiplier + tabLength*1440m); return twip; } } catch (ArgumentException) { const FontStyle fs2 = FontStyle.Bold; try { using (var f = new Font(ff, (float) sz/2f, fs2)) { const TextFormatFlags tff = TextFormatFlags.NoPadding; var proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels const decimal dpi = 96m; var twip = (int) (((sf.Width/dpi)*1440m)/multiplier + tabLength*1440m); return twip; } } catch (ArgumentException) { // if both regular and bold fail, then get metrics for Times New Roman // use the original FontStyle (in fs) var ff2 = new FontFamily("Times New Roman"); using (var f = new Font(ff2, (float) sz/2f, fs)) { const TextFormatFlags tff = TextFormatFlags.NoPadding; var proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels const decimal dpi = 96m; var twip = (int) (((sf.Width/dpi)*1440m)/multiplier + tabLength*1440m); return twip; } } } } catch (OverflowException) { // This happened on Azure but interestingly enough not while testing locally. return 0; } }
/// <summary> /// Gets an elements namespace. /// </summary> /// <param name="element">The element.</param> /// <returns> /// The element namespace. /// </returns> private static string GetElementNamespace(XElement element) { // Move up the tree to get the parent elements var namespaces = element.Ancestors("test-suite").Where(x => x.Attribute("type").Value.ToLower() == "namespace"); // Get the namespace return string.Join(".", namespaces.Select(x => x.Attribute("name").Value)); }
/// <summary> /// Finds the nearest class or struct element that encloses the given element. /// </summary> /// <param name="startElement">The element from which to start looking for the enclosing class or struct.</param> /// <returns>The nearest class or struct XElement that encloses the given element. /// If there is no enclosing class or struct element, this function returns null.</returns> private static XElement FindEnclosingClassElement(XElement startElement) { if (startElement == null) { return null; } var ancestors = from a in startElement.Ancestors() where a.Name == SRC.Class || a.Name == SRC.Struct select a; if (ancestors.Count() > 0) { return ancestors.First(); } else { return null; } }
/* * Handle: * - b * - bdr * - caps * - color * - dstrike * - highlight * - i * - position * - rFonts * - shd * - smallCaps * - spacing * - strike * - sz * - u * - vanish * - vertAlign * * Don't handle: * - em * - emboss * - fitText * - imprint * - kern * - outline * - shadow * - w * */ private static object ConvertRun(WordprocessingDocument wordDoc, HtmlConverterSettings settings, XElement run) { var style = new Dictionary<string, string>(); var sn = (string)run.Attribute(PtOpenXml.StyleName); if (sn != null) style.Add("PtStyleName", sn); var rPr = run.Element(W.rPr); if (rPr == null) { object content2 = run.Elements().Select(e => ConvertToHtmlTransform(wordDoc, settings, e, false, 0m)); return content2; } // hide all content that contains the w:rPr/w:webHidden element if (rPr.Element(W.webHidden) != null) return null; // W.bdr if (rPr.Element(W.bdr) != null && (string)rPr.Elements(W.bdr).Attributes(W.val).FirstOrDefault() != "none") { style.AddIfMissing("border", "solid windowtext 1.0pt"); style.AddIfMissing("padding", "0in"); } // W.color string color = (string)rPr.Elements(W.color).Attributes(W.val).FirstOrDefault(); if (color != null) CreateColorProperty("color", color, style); // W.highlight string highlight = (string)rPr.Elements(W.highlight).Attributes(W.val).FirstOrDefault(); if (highlight != null) CreateColorProperty("background", highlight, style); // W.shd string shade = (string)rPr.Elements(W.shd).Attributes(W.fill).FirstOrDefault(); if (shade != null) CreateColorProperty("background", shade, style); // Pt.FontName string font = null; if (run.Element(W.sym) != null) font = (string)run.Elements(W.sym).Attributes(W.font).FirstOrDefault(); else font = (string)run.Attributes(PtOpenXml.FontName).FirstOrDefault(); if (font != null) CreateFontCssProperty(font, style); // W.sz var languageType = (string)run.Attribute(PtOpenXml.LanguageType); decimal? sz = null; if (languageType == "bidi") sz = (decimal?)rPr.Elements(W.szCs).Attributes(W.val).FirstOrDefault(); else sz = (decimal?)rPr.Elements(W.sz).Attributes(W.val).FirstOrDefault(); if (sz != null) style.AddIfMissing("font-size", string.Format("{0}pt", sz / 2.0m)); // W.caps if (getBoolProp(rPr, W.caps)) style.AddIfMissing("text-transform", "uppercase"); // W.smallCaps if (getBoolProp(rPr, W.smallCaps)) style.AddIfMissing("font-variant", "small-caps"); // W.spacing decimal? spacingInTwips = (decimal?)rPr.Elements(W.spacing).Attributes(W.val).FirstOrDefault(); if (spacingInTwips != null) style.AddIfMissing("letter-spacing", string.Format("{0}pt", spacingInTwips / 20)); // W.position decimal? position = (decimal?)rPr.Elements(W.position).Attributes(W.val).FirstOrDefault(); if (position != null) { style.AddIfMissing("position", "relative"); style.AddIfMissing("top", string.Format("{0}pt", -(position / 2))); } // W.vanish if (getBoolProp(rPr, W.vanish)) style.AddIfMissing("display", "none"); object content = run.Elements().Select(e => ConvertToHtmlTransform(wordDoc, settings, e, false, 0m)); // W.u if (rPr.Element(W.u) != null && (string)rPr.Elements(W.u).Attributes(W.val).FirstOrDefault() != "none") { var newContent = new XElement(Xhtml.u, content); if (newContent.Nodes().Any()) content = newContent; style.AddIfMissing("text-decoration", "underline"); } // W.i if (getBoolProp(rPr, W.i)) { var newContent = new XElement(Xhtml.i, content); if (newContent.Nodes().Any()) content = newContent; style.AddIfMissing("font-style", "italic"); } // W.b if (getBoolProp(rPr, W.b)) { var newContent = new XElement(Xhtml.b, content); if (newContent.Nodes().Any()) content = newContent; style.AddIfMissing("font-weight", "bold"); } else { style.AddIfMissing("font-weight", "normal"); } // W.strike if (getBoolProp(rPr, W.strike) || getBoolProp(rPr, W.dstrike)) { var newContent = new XElement(Xhtml.s, content); if (newContent.Nodes().Any()) content = newContent; style.AddIfMissing("text-decoration", "line-through"); } // W.vertAlign if (rPr.Element(W.vertAlign) != null && (string)rPr.Elements(W.vertAlign).Attributes(W.val).FirstOrDefault() == "superscript") { var newContent = new XElement(Xhtml.sup, content); if (newContent.Nodes().Any()) content = newContent; } if (rPr.Element(W.vertAlign) != null && (string)rPr.Elements(W.vertAlign).Attributes(W.val).FirstOrDefault() == "subscript") { var newContent = new XElement(Xhtml.sub, content); if (newContent.Nodes().Any()) content = newContent; } var rtl = rPr.Element(W.rtl); var isRtl = rtl != null; var paragraph = run.Ancestors(W.p).FirstOrDefault(); var paraBidi = paragraph .Elements(W.pPr) .Elements(W.bidi) .Where(b => b.Attribute(W.val) == null || b.Attribute(W.val).ToBoolean() == true) .FirstOrDefault(); var paraIsBidi = paraBidi != null; string lang = null; if (languageType == "western") lang = (string)rPr.Elements(W.lang).Attributes(W.val).FirstOrDefault(); else if (languageType == "bidi") lang = (string)rPr.Elements(W.lang).Attributes(W.bidi).FirstOrDefault(); else if (languageType == "eastAsia") lang = (string)rPr.Elements(W.lang).Attributes(W.eastAsia).FirstOrDefault(); // only do the following for text runs. XEntity runStartMark = null; XEntity runEndMark = null; // Can't add directional marks if the font-family is symbol - they are visible, and display as a ? bool addDirectionalMarks = true; if (style.ContainsKey("font-family")) { if (style["font-family"].ToLower() == "symbol") addDirectionalMarks = false; } if (addDirectionalMarks) { if (run.Element(W.t) != null) { if (isRtl) { runStartMark = new XEntity("#x200f"); // RLM runEndMark = new XEntity("#x200f"); // RLM } else { if (paraIsBidi) { runStartMark = new XEntity("#x200e"); // LRM runEndMark = new XEntity("#x200e"); // LRM } } } } string defaultLanguage = "en-US"; // todo need to get defaultLanguage if (lang == null) lang = defaultLanguage; XAttribute langAttribute = new XAttribute("lang", lang); if (lang == defaultLanguage) langAttribute = null; if (style.Any() || isRtl || langAttribute != null) { style.AddIfMissing("margin", "0in"); style.AddIfMissing("padding", "0in"); var xe = new XElement(Xhtml.span, langAttribute, runStartMark, content, runEndMark); xe.AddAnnotation(style); content = xe; } return content; }
private ProgramElement ParseClassOrStruct(XElement cls, string fileName, bool parseStruct) { string name; int definitionLineNumber; int definitionColumnNumber; SrcMLParsingUtils.ParseNameAndLineNumber(cls, out name, out definitionLineNumber, out definitionColumnNumber); AccessLevel accessLevel = SrcMLParsingUtils.RetrieveAccessLevel(cls, AccessLevel.Public); //parse namespace IEnumerable<XElement> ownerNamespaces = from el in cls.Ancestors(SRC.Declaration) where el.Element(SRC.Type).Element(SRC.Name).Value == "namespace" select el; string namespaceName = String.Empty; foreach (XElement ownerNamespace in ownerNamespaces) { foreach (XElement spc in ownerNamespace.Elements(SRC.Name)) { namespaceName += spc.Value + " "; } } namespaceName = namespaceName.TrimEnd(); //parse extended classes string extendedClasses = String.Empty; XElement super = cls.Element(SRC.Super); if (super != null) { XElement implements = super.Element(SRC.Implements); if (implements != null) { IEnumerable<XElement> impNames = from el in implements.Descendants(SRC.Name) select el; foreach (XElement impName in impNames) { extendedClasses += impName.Value + " "; } extendedClasses = extendedClasses.TrimEnd(); } } string fullFilePath = System.IO.Path.GetFullPath(fileName); string source = SrcMLParsingUtils.RetrieveSource(cls); string body = cls.Value; if (parseStruct) { return new StructElement(name, definitionLineNumber, definitionColumnNumber, fullFilePath, source, accessLevel, namespaceName, body, extendedClasses, String.Empty); } else { string implementedInterfaces = String.Empty; return new ClassElement(name, definitionLineNumber, definitionColumnNumber, fullFilePath, source, accessLevel, namespaceName, extendedClasses, implementedInterfaces, String.Empty, body); } }
private static IEnumerable<Reference> ParseReferences(XNamespace ns, IEnumerable<XElement> referenceGroups, out XElement referencesNode) { referencesNode = referenceGroups.FirstOrDefault(); if (referencesNode != null) { referencesNode = referencesNode.Ancestors(ns + "ItemGroup").Single(); } return ParseReferencesImpl(referenceGroups, ns); }
private static object ProcessContentControl(WordprocessingDocument wordDoc, HtmlConverterSettings settings, XElement element, decimal currentMarginLeft) { var relevantAncestors = element.Ancestors().TakeWhile(a => a.Name != W.txbxContent); var isRunLevelContentControl = relevantAncestors.Any(a => a.Name == W.p); if (isRunLevelContentControl) { return element.Elements(W.sdtContent).Elements() .Select(e => ConvertToHtmlTransform(wordDoc, settings, e, false, currentMarginLeft)) .ToList(); } return CreateBorderDivs(wordDoc, settings, element.Elements(W.sdtContent).Elements()); }
private static string GetFilePath( TestWorkspace workspace, XElement documentElement, ref int documentId) { var filePathAttribute = documentElement.Attribute(FilePathAttributeName); if (filePathAttribute != null) { return filePathAttribute.Value; } var language = GetLanguage(workspace, documentElement.Ancestors(ProjectElementName).Single()); documentId++; var name = "Test" + documentId; return language == LanguageNames.CSharp ? name + ".cs" : name + ".vb"; }
/// <summary> /// Validate enumeration of element ancestors. /// </summary> /// <param name="contextValue"></param> /// <returns></returns> //[Variation(Desc = "ElementAncestors")] public void ElementAncestors() { XElement level3 = new XElement("Level3"); XElement level2 = new XElement("Level2", level3); XElement level1 = new XElement("Level1", level2); XElement level0 = new XElement("Level1", level1); Validate.EnumeratorDeepEquals(level3.Ancestors(), new XElement[] { level2, level1, level0 }); Validate.EnumeratorDeepEquals(level3.Ancestors("Level1"), new XElement[] { level1, level0 }); Validate.EnumeratorDeepEquals(level3.Ancestors(null), new XElement[0]); Validate.EnumeratorDeepEquals(level3.AncestorsAndSelf(), new XElement[] { level3, level2, level1, level0 }); Validate.EnumeratorDeepEquals(level3.AncestorsAndSelf("Level3"), new XElement[] { level3 }); Validate.EnumeratorDeepEquals(level3.AncestorsAndSelf(null), new XElement[0]); }
public static XElement getParentStatement(XElement element) { if (null == element) throw new ArgumentNullException("element"); if (!element.Ancestors().Any()) return null; return element.Ancestors().Where(a => a.Name == SRC.ExpressionStatement || a.Name == SRC.DeclarationStatement).First(); }
public static IEnumerable<XElement> ElementsBetween(XElement startElement, XElement endElement) { if (startElement == null) { throw new ArgumentNullException("startElement"); } if (endElement == null) { throw new ArgumentNullException("endElement"); } if (startElement.Parent.Equals(endElement.Parent)) { return startElement.ElementsAfterSelf().Where(e => e.IsBefore(endElement)); } var commonParent = startElement.Ancestors().Intersect(endElement.Ancestors()).FirstOrDefault(); if (commonParent == null) { return Enumerable.Empty<XElement>(); } var endElementFirstLevel = commonParent.Elements().First(e => e.Descendants().Contains(endElement) || e.Equals(endElement)); var startElementFirstLevel = commonParent.Elements().First(e => e.Descendants().Contains(startElement) || e.Equals(startElement)); var afterStart = startElement.ElementsAfterSelf(); var between = ElementsBetween(startElementFirstLevel, endElementFirstLevel); var beforeEnd = endElementFirstLevel.DescendantsBefore(endElement); return afterStart.Union(between).Union(beforeEnd); }
internal static IEnumerable<XElement> GetPageElementsByScope(SitemapScope associationScope, XElement currentPageElement) { IEnumerable<XElement> scopeElements = null; XElement matchPage; switch (associationScope) { case SitemapScope.Parent: if (currentPageElement.Parent != null && currentPageElement.Parent.Name == PageElementName) { yield return currentPageElement.Parent; } break; case SitemapScope.Descendants: scopeElements = currentPageElement.Descendants(PageElementName); break; case SitemapScope.DescendantsAndCurrent: scopeElements = currentPageElement.DescendantsAndSelf(PageElementName); break; case SitemapScope.Children: scopeElements = currentPageElement.Elements(PageElementName); break; case SitemapScope.Siblings: scopeElements = currentPageElement.Parent.Elements(PageElementName); break; case SitemapScope.Ancestors: scopeElements = currentPageElement.Ancestors(PageElementName); break; case SitemapScope.AncestorsAndCurrent: scopeElements = currentPageElement.AncestorsAndSelf(PageElementName); break; case SitemapScope.Level1: scopeElements = GetPageElementBySiteDepth(currentPageElement, 1); break; case SitemapScope.Level2: scopeElements = GetPageElementBySiteDepth(currentPageElement, 2); break; case SitemapScope.Level3: scopeElements = GetPageElementBySiteDepth(currentPageElement, 3); break; case SitemapScope.Level4: scopeElements = GetPageElementBySiteDepth(currentPageElement, 4); break; case SitemapScope.Level1AndDescendants: scopeElements = GetPageElementBySiteDepth(currentPageElement, 1).DescendantsAndSelf(); break; case SitemapScope.Level2AndDescendants: scopeElements = GetPageElementBySiteDepth(currentPageElement, 2).DescendantsAndSelf(); break; case SitemapScope.Level3AndDescendants: scopeElements = GetPageElementBySiteDepth(currentPageElement, 3).DescendantsAndSelf(); break; case SitemapScope.Level4AndDescendants: scopeElements = GetPageElementBySiteDepth(currentPageElement, 4).DescendantsAndSelf(); break; case SitemapScope.Level1AndSiblings: matchPage = GetPageElementBySiteDepth(currentPageElement, 1).FirstOrDefault(); if (matchPage != null && matchPage.Parent != null) { scopeElements = matchPage.Parent.Elements(PageElementName); } break; case SitemapScope.Level2AndSiblings: matchPage = GetPageElementBySiteDepth(currentPageElement, 1).FirstOrDefault(); if (matchPage != null) { scopeElements = matchPage.Elements(PageElementName); } break; case SitemapScope.Level3AndSiblings: matchPage = GetPageElementBySiteDepth(currentPageElement, 2).FirstOrDefault(); if (matchPage != null) { scopeElements = matchPage.Elements(PageElementName); } break; case SitemapScope.Level4AndSiblings: matchPage = GetPageElementBySiteDepth(currentPageElement, 3).FirstOrDefault(); if (matchPage != null) { scopeElements = matchPage.Elements(PageElementName); } break; default: throw new NotImplementedException("Unhandled SitemapScope type: " + associationScope); } if (scopeElements != null) { foreach (XElement scopeElement in scopeElements) { yield return scopeElement; } } }
private static object ProcessTab(XElement element) { var tabWidthAtt = element.Attribute(PtOpenXml.TabWidth); if (tabWidthAtt == null) return null; var leader = (string) element.Attribute(PtOpenXml.Leader); var tabWidth = (decimal) tabWidthAtt; var style = new Dictionary<string, string>(); XElement span; if (leader != null) { var leaderChar = "."; if (leader == "hyphen") leaderChar = "-"; else if (leader == "dot") leaderChar = "."; else if (leader == "underscore") leaderChar = "_"; var runContainingTabToReplace = element.Ancestors(W.r).First(); var fontNameAtt = runContainingTabToReplace.Attribute(PtOpenXml.pt + "FontName") ?? runContainingTabToReplace.Ancestors(W.p).First().Attribute(PtOpenXml.pt + "FontName"); var dummyRun = new XElement(W.r, fontNameAtt, runContainingTabToReplace.Elements(W.rPr), new XElement(W.t, leaderChar)); var widthOfLeaderChar = CalcWidthOfRunInTwips(dummyRun); bool forceArial = false; if (widthOfLeaderChar == 0) { dummyRun = new XElement(W.r, new XAttribute(PtOpenXml.FontName, "Arial"), runContainingTabToReplace.Elements(W.rPr), new XElement(W.t, leaderChar)); widthOfLeaderChar = CalcWidthOfRunInTwips(dummyRun); forceArial = true; } if (widthOfLeaderChar != 0) { var numberOfLeaderChars = (int) (Math.Floor((tabWidth*1440)/widthOfLeaderChar)); if (numberOfLeaderChars < 0) numberOfLeaderChars = 0; span = new XElement(Xhtml.span, " " + "".PadRight(numberOfLeaderChars, leaderChar[0]) + " "); style.Add("margin", "0 0 0 0"); style.Add("padding", "0 0 0 0"); style.Add("width", string.Format(NumberFormatInfo.InvariantInfo, "{0:0.00}in", tabWidth)); style.Add("text-align", "center"); if (forceArial) style.Add("font-family", "Arial"); } else { span = new XElement(Xhtml.span, " "); style.Add("margin", "0 0 0 0"); style.Add("padding", "0 0 0 0"); style.Add("width", string.Format(NumberFormatInfo.InvariantInfo, "{0:0.00}in", tabWidth)); style.Add("text-align", "center"); if (leader == "underscore") { style.Add("text-decoration", "underline"); } } } else { #if false var bidi = element .Ancestors(W.p) .Take(1) .Elements(W.pPr) .Elements(W.bidi) .Where(b => b.Attribute(W.val) == null || b.Attribute(W.val).ToBoolean() == true) .FirstOrDefault(); var isBidi = bidi != null; if (isBidi) span = new XElement(Xhtml.span, new XEntity("#x200f")); // RLM else span = new XElement(Xhtml.span, new XEntity("#x200e")); // LRM #else span = new XElement(Xhtml.span, new XEntity("nbsp")); #endif style.Add("margin", string.Format(NumberFormatInfo.InvariantInfo, "0 0 0 {0:0.00}in", tabWidth)); style.Add("padding", "0 0 0 0"); } span.AddAnnotation(style); return span; }
/// <summary> /// ProcessConstraint method /// </summary> /// <param name="constraint">Xml constraint element</param> private void ProcessConstraint(XElement constraint) { Constraint c = (Constraint)Enum.Parse(typeof(Constraint), constraint.Attribute("type").Value); this.builder.AppendFormat(" "); switch (c) { case Constraint.PK: this.builder.AppendFormat("PRIMARY KEY (`{0}`)", constraint.Parent.Attribute("name").Value); break; case Constraint.FK: case Constraint.CK: this.builder.AppendFormat( "CONSTRAINT `fk_{0}_{1}_{2}_{3}`", constraint.Ancestors("table").FirstOrDefault().Attribute("name").Value, constraint.Parent.Attribute("name").Value, constraint.Attribute("table").Value, constraint.Attribute("field").Value); this.builder.AppendFormat(" FOREIGN KEY (`{0}`)", constraint.Parent.Attribute("name").Value); this.builder.AppendFormat( " REFERENCES `{0}` (`{1}`)", constraint.Attribute("table").Value, constraint.Attribute("field").Value); //// RESTRICT | CASCADE | SET NULL | NO ACTION if (constraint.Attribute("cascade") != null && constraint.Attribute("cascade").Value == "true") { this.builder.AppendFormat(" ON DELETE CASCADE"); this.builder.AppendFormat(" ON UPDATE NO ACTION"); } else if (constraint.Attribute("setnull") != null && constraint.Attribute("setnull").Value == "true") { this.builder.AppendFormat(" ON DELETE SET NULL"); this.builder.AppendFormat(" ON UPDATE NO ACTION"); } else { this.builder.AppendFormat(" ON DELETE RESTRICT"); this.builder.AppendFormat(" ON UPDATE NO ACTION"); } break; } this.builder.AppendFormat(",{0}", linefeed); }
private static object ProcessBreak(XElement element) { XElement span = null; var tabWidth = (decimal?) element.Attribute(PtOpenXml.TabWidth); if (tabWidth != null) { span = new XElement(Xhtml.span); span.AddAnnotation(new Dictionary<string, string> { { "margin", string.Format(NumberFormatInfo.InvariantInfo, "0 0 0 {0:0.00}in", tabWidth) }, { "padding", "0 0 0 0" } }); } var paragraph = element.Ancestors(W.p).FirstOrDefault(); var isBidi = paragraph != null && paragraph.Elements(W.pPr).Elements(W.bidi).Any(b => b.Attribute(W.val) == null || b.Attribute(W.val).ToBoolean() == true); var zeroWidthChar = isBidi ? new XEntity("#x200f") : new XEntity("#x200e"); return new object[] { new XElement(Xhtml.br), zeroWidthChar, span, }; }
private static XElement CharStyleRollup(FormattingAssemblerInfo fai, WordprocessingDocument wDoc, XElement runOrPara) { var sXDoc = wDoc.MainDocumentPart.StyleDefinitionsPart.GetXDocument(); string charStyle = null; string paraStyle = null; XElement rPr = null; XElement pPr = null; XElement pStyle = null; XElement rStyle = null; CachedParaInfo cpi = null; // CachedParaInfo is an optimization for the case where a paragraph contains thousands of runs. if (runOrPara.Name == W.p) { cpi = runOrPara.Annotation<CachedParaInfo>(); if (cpi != null) pPr = cpi.ParagraphProperties; else { pPr = runOrPara.Element(W.pPr); if (pPr != null) { paraStyle = (string)pPr.Elements(W.pStyle).Attributes(W.val).FirstOrDefault(); } else { paraStyle = fai.DefaultParagraphStyleName; } cpi = new CachedParaInfo { ParagraphProperties = pPr, ParagraphStyleName = paraStyle, }; runOrPara.AddAnnotation(cpi); } if (pPr != null) { rPr = pPr.Element(W.rPr); } } else { rPr = runOrPara.Element(W.rPr); } if (rPr != null) { rStyle = rPr.Element(W.rStyle); if (rStyle != null) { charStyle = (string)rStyle.Attribute(W.val); } else { if (runOrPara.Name == W.r) charStyle = (string)runOrPara .Ancestors(W.p) .Take(1) .Elements(W.pPr) .Elements(W.pStyle) .Attributes(W.val) .FirstOrDefault(); else charStyle = (string)runOrPara .Elements(W.pPr) .Elements(W.pStyle) .Attributes(W.val) .FirstOrDefault(); } } if (charStyle == null) { if (runOrPara.Name == W.r) { var ancestorPara = runOrPara.Ancestors(W.p).First(); cpi = ancestorPara.Annotation<CachedParaInfo>(); if (cpi != null) charStyle = cpi.ParagraphStyleName; else charStyle = (string)runOrPara.Ancestors(W.p).First().Elements(W.pPr).Elements(W.pStyle).Attributes(W.val).FirstOrDefault(); } if (charStyle == null) { charStyle = fai.DefaultParagraphStyleName; } } // A run always must have an ancestor paragraph. XElement para = null; var rolledUpParaStyleRunProps = new XElement(W.rPr); if (runOrPara.Name == W.r) { para = runOrPara.Ancestors(W.p).FirstOrDefault(); } else { para = runOrPara; } cpi = para.Annotation<CachedParaInfo>(); if (cpi != null) { pPr = cpi.ParagraphProperties; } else { pPr = para.Element(W.pPr); } if (pPr != null) { pStyle = pPr.Element(W.pStyle); if (pStyle != null) { paraStyle = (string)pStyle.Attribute(W.val); } else { paraStyle = fai.DefaultParagraphStyleName; } } else paraStyle = fai.DefaultParagraphStyleName; string key = (paraStyle == null ? "[null]" : paraStyle) + "~|~" + (charStyle == null ? "[null]" : charStyle); XElement rolledRunProps = null; if (fai.RolledCharacterStyles.ContainsKey(key)) rolledRunProps = fai.RolledCharacterStyles[key]; else { XElement rolledUpCharStyleRunProps = new XElement(W.rPr); if (charStyle != null) { rolledUpCharStyleRunProps = CharStyleStack(wDoc, charStyle) .Aggregate(new XElement(W.rPr), (r, s) => { var newRunProps = MergeStyleElement(s, r); return newRunProps; }); } if (paraStyle != null) { rolledUpParaStyleRunProps = ParaStyleRunPropsStack(wDoc, paraStyle) .Aggregate(new XElement(W.rPr), (r, s) => { var newCharStyleRunProps = MergeStyleElement(s, r); return newCharStyleRunProps; }); } rolledRunProps = MergeStyleElement(rolledUpCharStyleRunProps, rolledUpParaStyleRunProps); fai.RolledCharacterStyles.Add(key, rolledRunProps); } return rolledRunProps; }
public void ElementAncestors() { XElement level3 = new XElement("Level3"); XElement level2 = new XElement("Level2", level3); XElement level1 = new XElement("Level1", level2); XElement level0 = new XElement("Level1", level1); Assert.Equal(new XElement[] { level2, level1, level0 }, level3.Ancestors(), XNode.EqualityComparer); Assert.Equal(new XElement[] { level1, level0 }, level3.Ancestors("Level1"), XNode.EqualityComparer); Assert.Empty(level3.Ancestors(null)); Assert.Equal( new XElement[] { level3, level2, level1, level0 }, level3.AncestorsAndSelf(), XNode.EqualityComparer); Assert.Equal(new XElement[] { level3 }, level3.AncestorsAndSelf("Level3"), XNode.EqualityComparer); Assert.Empty(level3.AncestorsAndSelf(null)); }
string GetContainingType (XElement el) { return el.Ancestors ("class").First ().Attribute ("type").Value; }
private static void AnnotateParagraph(FormattingAssemblerInfo fai, WordprocessingDocument wDoc, XElement para, FormattingAssemblerSettings settings) { XElement localParaProps = para.Element(W.pPr); if (localParaProps == null) { localParaProps = new XElement(W.pPr); } // get para table props, to be merged. XElement tablepPr = null; var blockLevelContentContainer = para .Ancestors() .FirstOrDefault(a => a.Name == W.body || a.Name == W.tbl || a.Name == W.txbxContent || a.Name == W.ftr || a.Name == W.hdr || a.Name == W.footnote || a.Name == W.endnote); if (blockLevelContentContainer.Name == W.tbl) { XElement tbl = blockLevelContentContainer; XElement style = tbl.Element(PtOpenXml.pt + "style"); XElement cellCnf = para.Ancestors(W.tc).Take(1).Elements(W.tcPr).Elements(W.cnfStyle).FirstOrDefault(); XElement rowCnf = para.Ancestors(W.tr).Take(1).Elements(W.trPr).Elements(W.cnfStyle).FirstOrDefault(); if (style != null) { // roll up tblPr, trPr, and tcPr from within a specific style. // add each of these to the table, in PowerTools namespace. tablepPr = style.Element(W.pPr); if (tablepPr == null) tablepPr = new XElement(W.pPr); foreach (var ot in TableStyleOverrideTypes) { XName attName = TableStyleOverrideXNameMap[ot]; if ((cellCnf != null && cellCnf.Attribute(attName).ToBoolean() == true) || (rowCnf != null && rowCnf.Attribute(attName).ToBoolean() == true)) { XElement o = style .Elements(W.tblStylePr) .Where(tsp => (string)tsp.Attribute(W.type) == ot) .FirstOrDefault(); if (o != null) { XElement otpPr = o.Element(W.pPr); tablepPr = MergeStyleElement(otpPr, tablepPr); } } } } } var stylesPart = wDoc.MainDocumentPart.StyleDefinitionsPart; XDocument sXDoc = null; if (stylesPart != null) sXDoc = stylesPart.GetXDocument(); ListItemRetriever.ListItemInfo lif = para.Annotation<ListItemRetriever.ListItemInfo>(); XElement rolledParaProps = ParagraphStyleRollup(para, sXDoc, fai.DefaultParagraphStyleName); if (lif != null && lif.IsZeroNumId) rolledParaProps.Elements(W.ind).Remove(); XElement toggledParaProps = MergeStyleElement(rolledParaProps, tablepPr); XElement mergedParaProps = MergeStyleElement(localParaProps, toggledParaProps); string li = ListItemRetriever.RetrieveListItem(wDoc, para, settings.ListItemRetrieverSettings); if (lif != null && lif.IsListItem) { if (settings.RestrictToSupportedNumberingFormats) { string numFmtForLevel = (string)lif.Lvl(ListItemRetriever.GetParagraphLevel(para)).Elements(W.numFmt).Attributes(W.val).FirstOrDefault(); if (numFmtForLevel == null) { var numFmtElement = lif.Lvl(ListItemRetriever.GetParagraphLevel(para)).Elements(MC.AlternateContent).Elements(MC.Choice).Elements(W.numFmt).FirstOrDefault(); if (numFmtElement != null && (string)numFmtElement.Attribute(W.val) == "custom") numFmtForLevel = (string)numFmtElement.Attribute(W.format); } bool isLgl = lif.Lvl(ListItemRetriever.GetParagraphLevel(para)).Elements(W.isLgl).Any(); if (isLgl && numFmtForLevel != "decimalZero") numFmtForLevel = "decimal"; if (!AcceptableNumFormats.Contains(numFmtForLevel)) throw new UnsupportedNumberingFormatException(numFmtForLevel + " is not a supported numbering format"); } int paragraphLevel = ListItemRetriever.GetParagraphLevel(para); var numberingParaProps = lif .Lvl(paragraphLevel) .Elements(W.pPr) .FirstOrDefault(); if (numberingParaProps == null) { numberingParaProps = new XElement(W.pPr); } else { numberingParaProps .Elements() .Where(e => e.Name != W.ind) .Remove(); } // have: // - localParaProps // - toggledParaProps // - numberingParaProps // if a paragraph contains a numPr with a numId=0, in other words, it is NOT a numbered item, then the indentation from the style // hierarchy is ignored. ListItemRetriever.ListItemInfo lii = para.Annotation<ListItemRetriever.ListItemInfo>(); if (lii.FromParagraph != null) { // order // - toggledParaProps // - numberingParaProps // - localParaProps mergedParaProps = MergeStyleElement(numberingParaProps, toggledParaProps); mergedParaProps = MergeStyleElement(localParaProps, mergedParaProps); } else if (lii.FromStyle != null) { // order // - numberingParaProps // - toggledParaProps // - localParaProps mergedParaProps = MergeStyleElement(toggledParaProps, numberingParaProps); mergedParaProps = MergeStyleElement(localParaProps, mergedParaProps); } } else { mergedParaProps = MergeStyleElement(localParaProps, toggledParaProps); } // merge mergedParaProps with existing accumulatedParaProps, with mergedParaProps as high pri // replace accumulatedParaProps with newly merged XElement accumulatedParaProps = para.Element(PtOpenXml.pt + "pPr"); XElement newAccumulatedParaProps = MergeStyleElement(mergedParaProps, accumulatedParaProps); AdjustFontAttributes(wDoc, para, newAccumulatedParaProps, newAccumulatedParaProps.Element(W.rPr), settings); newAccumulatedParaProps.Name = PtOpenXml.pt + "pPr"; if (accumulatedParaProps != null) { accumulatedParaProps.ReplaceWith(newAccumulatedParaProps); } else { para.Add(newAccumulatedParaProps); } }
private static EnumElement ParseEnum(string fileName, XElement enm) { try { //SrcML doesn't seem to parse access level specifiers for enums, so just pretend they are all public for now AccessLevel accessLevel = AccessLevel.Public; string name = ""; int definitionLineNumber = 0; int definitionColumnNumber=0; if (enm.Element(SRC.Name) != null) { SrcMLParsingUtils.ParseNameAndLineNumber(enm, out name, out definitionLineNumber, out definitionColumnNumber); } else { //enums in C++ aren't required to have a name name = ProgramElement.UndefinedName; definitionLineNumber = Int32.Parse(enm.Attribute(POS.Line).Value); } //parse namespace IEnumerable<XElement> ownerNamespaces = from el in enm.Ancestors(SRC.Declaration) where el.Element(SRC.Type) != null && el.Element(SRC.Type).Element(SRC.Name) != null && el.Element(SRC.Type).Element(SRC.Name).Value == "namespace" select el; string namespaceName = String.Empty; foreach (XElement ownerNamespace in ownerNamespaces) { foreach (XElement spc in ownerNamespace.Elements(SRC.Name)) { namespaceName += spc.Value + " "; } } namespaceName = namespaceName.TrimEnd(); //parse values XElement block = enm.Element(SRC.Block); string values = String.Empty; if (block != null) { IEnumerable<XElement> exprs = from el in block.Descendants(SRC.Expression) select el; foreach (XElement expr in exprs) { IEnumerable<XElement> enames = expr.Elements(SRC.Name); foreach (XElement ename in enames) { values += ename.Value + " "; } } values = values.TrimEnd(); } string fullFilePath = System.IO.Path.GetFullPath(fileName); string source = SrcMLParsingUtils.RetrieveSource(enm); var enumParsed = new EnumElement(name, definitionLineNumber, definitionColumnNumber, fullFilePath, source, accessLevel, namespaceName, values); return enumParsed; } catch (Exception error) { FileLogger.DefaultLogger.Info("Exception in SrcMLCppParser " + error.Message + "\n" + error.StackTrace); return null; } }
public static int CalcWidthOfRunInTwips(XElement r) { if (KnownFamilies == null) { KnownFamilies = new HashSet<string>(); var families = FontFamily.Families; foreach (var fam in families) KnownFamilies.Add(fam.Name); } var fontName = (string)r.Attribute(PtOpenXml.pt + "FontName"); if (fontName == null) fontName = (string)r.Ancestors(W.p).First().Attribute(PtOpenXml.pt + "FontName"); if (fontName == null) throw new OpenXmlPowerToolsException("Internal Error, should have FontName attribute"); if (UnknownFonts.Contains(fontName)) return 0; var rPr = r.Element(W.rPr); if (rPr == null) throw new OpenXmlPowerToolsException("Internal Error, should have run properties"); var languageType = (string)r.Attribute(PtOpenXml.LanguageType); decimal? sz = null; if (languageType == "bidi") sz = (decimal?)rPr.Elements(W.szCs).Attributes(W.val).FirstOrDefault(); else sz = (decimal?)rPr.Elements(W.sz).Attributes(W.val).FirstOrDefault(); if (sz == null) sz = 22m; // unknown font families will throw ArgumentException, in which case just return 0 if (!KnownFamilies.Contains(fontName)) return 0; // in theory, all unknown fonts are found by the above test, but if not... FontFamily ff; try { ff = new FontFamily(fontName); } catch (ArgumentException) { UnknownFonts.Add(fontName); return 0; } FontStyle fs = FontStyle.Regular; var bold = GetBoolProp(rPr, W.b) || GetBoolProp(rPr, W.bCs); var italic = GetBoolProp(rPr, W.i) || GetBoolProp(rPr, W.iCs); if (bold && !italic) fs = FontStyle.Bold; if (italic && !bold) fs = FontStyle.Italic; if (bold && italic) fs = FontStyle.Bold | FontStyle.Italic; var runText = r.DescendantsTrimmed(W.txbxContent) .Where(e => e.Name == W.t) .Select(t => (string)t) .StringConcatenate(); var tabLength = r.DescendantsTrimmed(W.txbxContent) .Where(e => e.Name == W.tab) .Select(t => (decimal)t.Attribute(PtOpenXml.TabWidth)) .Sum(); if (runText.Length == 0 && tabLength == 0) return 0; int multiplier = 1; if (runText.Length <= 2) multiplier = 100; else if (runText.Length <= 4) multiplier = 50; else if (runText.Length <= 8) multiplier = 25; else if (runText.Length <= 16) multiplier = 12; else if (runText.Length <= 32) multiplier = 6; if (multiplier != 1) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < multiplier; i++) sb.Append(runText); runText = sb.ToString(); } try { using (Font f = new Font(ff, (float)sz / 2f, fs)) { System.Windows.Forms.TextFormatFlags tff = System.Windows.Forms.TextFormatFlags.NoPadding; Size proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = System.Windows.Forms.TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels var dpi = 96m; var twip = (int)(((sf.Width / dpi) * 1440m) / multiplier + tabLength * 1440m); return twip; } } catch (ArgumentException) { try { var fs2 = FontStyle.Regular; using (Font f = new Font(ff, (float)sz / 2f, fs2)) { System.Windows.Forms.TextFormatFlags tff = System.Windows.Forms.TextFormatFlags.NoPadding; Size proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = System.Windows.Forms.TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels var dpi = 96m; var twip = (int)(((sf.Width / dpi) * 1440m) / multiplier + tabLength * 1440m); return twip; } } catch (ArgumentException) { var fs2 = FontStyle.Bold; try { using (Font f = new Font(ff, (float)sz / 2f, fs2)) { System.Windows.Forms.TextFormatFlags tff = System.Windows.Forms.TextFormatFlags.NoPadding; Size proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = System.Windows.Forms.TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels var dpi = 96m; var twip = (int)(((sf.Width / dpi) * 1440m) / multiplier + tabLength * 1440m); return twip; } } catch (ArgumentException) { // if both regular and bold fail, then get metrics for Times New Roman // use the original FontStyle (in fs) FontFamily ff2; ff2 = new FontFamily("Times New Roman"); using (Font f = new Font(ff2, (float)sz / 2f, fs)) { System.Windows.Forms.TextFormatFlags tff = System.Windows.Forms.TextFormatFlags.NoPadding; Size proposedSize = new Size(int.MaxValue, int.MaxValue); var sf = System.Windows.Forms.TextRenderer.MeasureText(runText, f, proposedSize, tff); // sf returns size in pixels var dpi = 96m; var twip = (int)(((sf.Width / dpi) * 1440m) / multiplier + tabLength * 1440m); return twip; } } } } }
private static void AnnotateRunProperties(FormattingAssemblerInfo fai, WordprocessingDocument wDoc, XElement runOrPara, FormattingAssemblerSettings settings) { XElement localRunProps = null; if (runOrPara.Name == W.p) { var rPr = runOrPara.Elements(W.pPr).Elements(W.rPr).FirstOrDefault(); if (rPr != null) { localRunProps = rPr; } } else { localRunProps = runOrPara.Element(W.rPr); } if (localRunProps == null) { localRunProps = new XElement(W.rPr); } // get run table props, to be merged. XElement tablerPr = null; var blockLevelContentContainer = runOrPara .Ancestors() .FirstOrDefault(a => a.Name == W.body || a.Name == W.tbl || a.Name == W.txbxContent || a.Name == W.ftr || a.Name == W.hdr || a.Name == W.footnote || a.Name == W.endnote); if (blockLevelContentContainer.Name == W.tbl) { XElement tbl = blockLevelContentContainer; XElement style = tbl.Element(PtOpenXml.pt + "style"); XElement cellCnf = runOrPara.Ancestors(W.tc).Take(1).Elements(W.tcPr).Elements(W.cnfStyle).FirstOrDefault(); XElement rowCnf = runOrPara.Ancestors(W.tr).Take(1).Elements(W.trPr).Elements(W.cnfStyle).FirstOrDefault(); if (style != null) { tablerPr = style.Element(W.rPr); if (tablerPr == null) tablerPr = new XElement(W.rPr); foreach (var ot in TableStyleOverrideTypes) { XName attName = TableStyleOverrideXNameMap[ot]; if ((cellCnf != null && cellCnf.Attribute(attName).ToBoolean() == true) || (rowCnf != null && rowCnf.Attribute(attName).ToBoolean() == true)) { XElement o = style .Elements(W.tblStylePr) .Where(tsp => (string)tsp.Attribute(W.type) == ot) .FirstOrDefault(); if (o != null) { XElement otrPr = o.Element(W.rPr); tablerPr = MergeStyleElement(otrPr, tablerPr); } } } } } XElement rolledRunProps = CharStyleRollup(fai, wDoc, runOrPara); var toggledRunProps = ToggleMergeRunProps(rolledRunProps, tablerPr); var currentRunProps = runOrPara.Element(PtOpenXml.rPr); // this is already stored on the run from previous aggregation of props var mergedRunProps = MergeStyleElement(toggledRunProps, currentRunProps); var newMergedRunProps = MergeStyleElement(localRunProps, mergedRunProps); XElement pPr = null; if (runOrPara.Name == W.p) pPr = runOrPara.Element(PtOpenXml.pPr); AdjustFontAttributes(wDoc, runOrPara, pPr, newMergedRunProps, settings); newMergedRunProps.Name = PtOpenXml.rPr; if (currentRunProps != null) { currentRunProps.ReplaceWith(newMergedRunProps); } else { runOrPara.Add(newMergedRunProps); } }