public void ResolveNamespace(XElement elem, XamlContext ctx) { if (Namespace != null) return; // Since XmlnsProperty records are inside the element, // the namespace is resolved after processing the element body. string xmlNs = null; if (elem.Annotation<XmlnsScope>() != null) xmlNs = elem.Annotation<XmlnsScope>().LookupXmlns(Assembly, TypeNamespace); if (xmlNs == null) xmlNs = ctx.XmlNs.LookupXmlns(Assembly, TypeNamespace); if (xmlNs == null) { var nsSeg = TypeNamespace.Split('.'); var nsName = nsSeg[nsSeg.Length - 1].ToLowerInvariant(); var prefix = nsName; int count = 0; while (elem.GetNamespaceOfPrefix(prefix) != null) { count++; prefix = nsName + count; } xmlNs = string.Format("clr-namespace:{0};assembly={1}", TypeNamespace, Assembly); elem.Add(new XAttribute(XNamespace.Xmlns + XmlConvert.EncodeLocalName(prefix), ctx.GetXmlNamespace(xmlNs))); } Namespace = xmlNs; }
public static ASupportElement GetInstance(XElement definition) { Type eType = ElementType (definition); if (eType != null) { if (definition.Annotation (eType) != null) return definition.Annotation (eType) as ASupportElement; else { var instance = Activator.CreateInstance (eType, new object[] { definition }); definition.AddAnnotation (instance); return instance as ASupportElement; } } else return null; }
void RewriteClass(XamlContext ctx, XElement elem) { var type = elem.Annotation<XamlType>(); if (type == null || type.ResolvedType == null) return; var typeDef = type.ResolvedType.ResolveTypeDef(); var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All); if (typeDef == null || !comparer.Equals(typeDef.DefinitionAssembly, ctx.Module.Assembly)) return; var newType = typeDef.BaseType; var xamlType = new XamlType(newType.DefinitionAssembly, newType.ReflectionNamespace, newType.Name); xamlType.ResolveNamespace(elem, ctx); elem.Name = xamlType.ToXName(ctx); var attrName = ctx.GetXamlNsName("Class", elem); var attrs = elem.Attributes().ToList(); if (typeDef.IsNotPublic) { var classModifierName = ctx.GetXamlNsName("ClassModifier", elem); attrs.Insert(0, new XAttribute(classModifierName, ctx.BamlDecompilerOptions.InternalClassModifier)); } attrs.Insert(0, new XAttribute(attrName, type.ResolvedType.ReflectionFullName)); elem.ReplaceAttributes(attrs); }
bool RewriteElement(XamlContext ctx, XElement parent, XElement elem) { var type = parent.Annotation<XamlType>(); var property = elem.Annotation<XamlProperty>(); if ((property == null || type == null) && elem.Name != key) return false; if (elem.Elements().Count() != 1 || elem.Attributes().Any(t => t.Name.Namespace != XNamespace.Xmlns)) return false; var value = elem.Elements().Single(); if (!CanInlineExt(ctx, value)) return false; var ext = InlineExtension(ctx, value); if (ext == null) return false; ctx.CancellationToken.ThrowIfCancellationRequested(); var extValue = ext.ToString(ctx, parent); var attrName = elem.Name; if (attrName != key) attrName = property.ToXName(ctx, parent, property.IsAttachedTo(type)); var attr = new XAttribute(attrName, extValue); parent.Add(attr); elem.Remove(); return true; }
public void ResolveNamespace(XElement elem, XamlContext ctx) { if (Namespace != null) return; // Since XmlnsProperty records are inside the element, // the namespace is resolved after processing the element body. string xmlNs = null; if (elem.Annotation<XmlnsScope>() != null) xmlNs = elem.Annotation<XmlnsScope>().LookupXmlns(Assembly, TypeNamespace); if (xmlNs == null) xmlNs = ctx.XmlNs.LookupXmlns(Assembly, TypeNamespace); // Sometimes there's no reference to System.Xaml even if x:Type is used if (xmlNs == null) xmlNs = ctx.TryGetXmlNamespace(Assembly, TypeNamespace); if (xmlNs == null) { if (AssemblyNameComparer.CompareAll.Equals(Assembly, ctx.Module.Assembly)) xmlNs = $"clr-namespace:{TypeNamespace}"; else xmlNs = $"clr-namespace:{TypeNamespace};assembly={Assembly.Name}"; var nsSeg = TypeNamespace.Split('.'); var prefix = nsSeg[nsSeg.Length - 1].ToLowerInvariant(); if (string.IsNullOrEmpty(prefix)) { if (string.IsNullOrEmpty(TypeNamespace)) prefix = "global"; else prefix = "empty"; } int count = 0; var truePrefix = prefix; XNamespace prefixNs, ns = ctx.GetXmlNamespace(xmlNs); while ((prefixNs = elem.GetNamespaceOfPrefix(truePrefix)) != null && prefixNs != ns) { count++; truePrefix = prefix + count; } if (prefixNs == null) { elem.Add(new XAttribute(XNamespace.Xmlns + XmlConvert.EncodeLocalName(truePrefix), ns)); if (string.IsNullOrEmpty(TypeNamespace)) elem.AddBeforeSelf(new XComment(string.Format(dnSpy_BamlDecompiler_Resources.Msg_GlobalNamespace, truePrefix))); } } Namespace = ctx.GetXmlNamespace(xmlNs); }
/// <summary> /// Adds UVML annotations to the specified UVML element tree. /// </summary> /// <param name="dataSourceTypeName">The name of the data source wrapper associated with this tree.</param> /// <param name="root">The root of the UVML element tree to annotate.</param> public static void AddUvmlAnnotations(String dataSourceTypeName, XElement root) { Contract.RequireNotEmpty(dataSourceTypeName, nameof(dataSourceTypeName)); Contract.Require(root, nameof(root)); var templates = 0; if (root.Annotation<UvmlMetadataAnnotation>() != null) return; root.AddAnnotation(new UvmlMetadataAnnotation()); AddUvmlAnnotations(dataSourceTypeName, root, ref templates); }
private static void RemoveAllButSpecificFields(XElement root, string[] fieldTypesToRetain) { var cachedAnnotationInformation = root.Annotation<Dictionary<int, List<XElement>>>(); List<XElement> runsToKeep = new List<XElement>(); foreach (var item in cachedAnnotationInformation) { var runsForField = root .Descendants() .Where(d => { Stack<FieldRetriever.FieldElementTypeInfo> stack = d.Annotation<Stack<FieldRetriever.FieldElementTypeInfo>>(); if (stack == null) return false; if (stack.Any(stackItem => stackItem.Id == item.Key)) return true; return false; }) .Select(d => d.AncestorsAndSelf(W.r).FirstOrDefault()) .GroupAdjacent(o => o) .Select(g => g.First()) .ToList(); foreach (var r in runsForField) runsToKeep.Add(r); } foreach (var paragraph in root.Descendants(W.p).ToList()) { if (paragraph.Elements(W.r).Any(r => runsToKeep.Contains(r))) { paragraph.Elements(W.r) .Where(r => !runsToKeep.Contains(r) && !r.Elements(W.tab).Any()) .Remove(); paragraph.Elements(W.r) .Where(r => !runsToKeep.Contains(r)) .Elements() .Where(rc => rc.Name != W.rPr && rc.Name != W.tab) .Remove(); } else { paragraph.Remove(); } } root.Descendants(W.tbl).Remove(); }
bool RewriteElement(XamlContext ctx, XElement parent, XElement elem) { var property = elem.Annotation<XamlProperty>(); if (property == null && elem.Name != key) return false; if (elem.HasAttributes || elem.HasElements) return false; ctx.CancellationToken.ThrowIfCancellationRequested(); var value = elem.Value; var attrName = elem.Name; if (attrName != key) attrName = property.ToXName(ctx, parent, property.IsAttachedTo(parent.Annotation<XamlType>())); var attr = new XAttribute(attrName, value); parent.Add(attr); elem.Remove(); return true; }
private static LineInfo GetLineInfo(XElement element) { IXmlLineInfo ie = (IXmlLineInfo) element; if(ie.HasLineInfo()) return new LineInfo(ie.LineNumber, ie.LinePosition); else return element.Annotation<ABB.SrcML.LineInfo>(); }
/// Accept deleted paragraphs. /// /// Group together all paragraphs that contain w:p/w:pPr/w:rPr/w:del elements. Make a /// second group for the content element immediately following a paragraph that contains /// a w:del element. The code uses the approach of dealing with paragraph content at /// 'levels', ignoring paragraph content at other levels. Form a new paragraph that /// contains the content of the grouped paragraphs with deleted paragraph marks, and the /// content of the paragraph immediately following a paragraph that contains a deleted /// paragraph mark. Include in the new paragraph the paragraph properties from the /// paragraph following. When assembling the new paragraph, use a transform that collapses /// the paragraph nodes when adding content, thereby preserving custom XML and content /// controls. private static void AnnotateBlockContentElements(XElement contentContainer) { // For convenience, there is a ParagraphInfo annotation on the contentContainer. // It contains the same information as the ParagraphInfo annotation on the first // paragraph. if (contentContainer.Annotation<BlockContentInfo>() != null) return; XElement firstContentElement = contentContainer .Elements() .DescendantsAndSelf() .FirstOrDefault(e => e.Name == W.p || e.Name == W.tbl); // Add the annotation on the contentContainer. BlockContentInfo currentContentInfo = new BlockContentInfo() { PreviousBlockContentElement = null, ThisBlockContentElement = firstContentElement, NextBlockContentElement = null }; // Add as annotation even though NextParagraph is not set yet. contentContainer.AddAnnotation(currentContentInfo); while (true) { currentContentInfo.ThisBlockContentElement.AddAnnotation(currentContentInfo); // Find next sibling content element. XElement nextContentElement = null; XElement current = currentContentInfo.ThisBlockContentElement; while (true) { nextContentElement = current .ElementsAfterSelf() .DescendantsAndSelf() .FirstOrDefault(e => e.Name == W.p || e.Name == W.tbl); if (nextContentElement != null) { currentContentInfo.NextBlockContentElement = nextContentElement; break; } current = current.Parent; // When we've backed up the tree to the contentContainer, we're done. if (current == contentContainer) return; } currentContentInfo = new BlockContentInfo() { PreviousBlockContentElement = currentContentInfo.ThisBlockContentElement, ThisBlockContentElement = nextContentElement, NextBlockContentElement = null }; } }
private static IEnumerable<BlockContentInfo> IterateBlockContentElements(XElement element) { XElement current = element.Elements().FirstOrDefault(); if (current == null) yield break; AnnotateBlockContentElements(element); BlockContentInfo currentBlockContentInfo = element.Annotation<BlockContentInfo>(); while (true) { yield return currentBlockContentInfo; if (currentBlockContentInfo.NextBlockContentElement == null) yield break; currentBlockContentInfo = currentBlockContentInfo.NextBlockContentElement.Annotation<BlockContentInfo>(); } }
bool CanInlineExt(XamlContext ctx, XElement ctxElement) { var type = ctxElement.Annotation<XamlType>(); if (type != null && type.ResolvedType != null) { var typeDef = type.ResolvedType.GetBaseType(); bool isExt = false; while (typeDef != null) { if (typeDef.FullName == "System.Windows.Markup.MarkupExtension") { isExt = true; break; } typeDef = typeDef.GetBaseType(); } if (!isExt) return false; } else if (ctxElement.Annotation<XamlProperty>() == null && ctxElement.Name != ctor) return false; foreach (var child in ctxElement.Elements()) { if (!CanInlineExt(ctx, child)) return false; } return true; }
private Location GetIncludeElementLocation(XElement includeElement, ref string currentXmlFilePath, ref CSharpSyntaxNode originatingSyntax) { Location location = includeElement.Annotation<Location>(); if (location != null) { return location; } // If we are not in an XML file, then we must be in a source file. Since we're traversing the XML tree in the same // order as the DocumentationCommentWalker, we can access the elements of includeElementNodes in order. if (currentXmlFilePath == null) { Debug.Assert(nextSourceIncludeElementIndex < sourceIncludeElementNodes.Length); Debug.Assert(originatingSyntax == null); originatingSyntax = sourceIncludeElementNodes[nextSourceIncludeElementIndex]; location = originatingSyntax.Location; nextSourceIncludeElementIndex++; // #line shall not affect the base path: currentXmlFilePath = location.GetLineSpan().Path; } else { location = XmlLocation.Create(includeElement, currentXmlFilePath); } Debug.Assert(location != null); includeElement.AddAnnotation(location); return location; }
public static string RetrieveListItem(WordprocessingDocument wordDoc, XElement paragraph, ListItemRetrieverSettings settings) { if (wordDoc.MainDocumentPart.NumberingDefinitionsPart == null) return null; var listItemInfo = paragraph.Annotation<ListItemInfo>(); if (listItemInfo == null) InitializeListItemRetriever(wordDoc, settings); listItemInfo = paragraph.Annotation<ListItemInfo>(); if (!listItemInfo.IsListItem) return null; var numberingDefinitionsPart = wordDoc .MainDocumentPart .NumberingDefinitionsPart; if (numberingDefinitionsPart == null) return null; StyleDefinitionsPart styleDefinitionsPart = wordDoc .MainDocumentPart .StyleDefinitionsPart; if (styleDefinitionsPart == null) return null; var numXDoc = numberingDefinitionsPart.GetXDocument(); var stylesXDoc = styleDefinitionsPart.GetXDocument(); var lvl = listItemInfo.Lvl(GetParagraphLevel(paragraph)); string lvlText = (string)lvl.Elements(W.lvlText).Attributes(W.val).FirstOrDefault(); if (lvlText == null) return null; var levelNumbersAnnotation = paragraph.Annotation<LevelNumbers>(); if (levelNumbersAnnotation == null) throw new OpenXmlPowerToolsException("Internal error"); int[] levelNumbers = levelNumbersAnnotation.LevelNumbersArray; string languageIdentifier = GetLanguageIdentifier(paragraph, stylesXDoc); string listItem = FormatListItem(listItemInfo, levelNumbers, GetParagraphLevel(paragraph), lvlText, stylesXDoc, languageIdentifier, settings); return listItem; }
public static int GetParagraphLevel(XElement paragraph) { var pi = paragraph.Annotation<ParagraphInfo>(); if (pi != null) return pi.Ilvl; throw new OpenXmlPowerToolsException("Internal error - should never ask for ilvl without it first being set."); }
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 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 static string InstrText(XElement root, int id) { XNamespace w = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"; #if false // This is the old code. Both versions work - the caching version is significantly faster. var relevantElements = root.Descendants() .Where(e => { Stack<FieldElementTypeInfo> s = e.Annotation<Stack<FieldElementTypeInfo>>(); if (s != null) return s.Any(z => z.Id == id && z.FieldElementType == FieldElementTypeEnum.InstrText); return false; }) .ToList(); #else var cachedAnnotationInformation = root.Annotation<Dictionary<int, List<XElement>>>(); if (cachedAnnotationInformation == null) throw new OpenXmlPowerToolsException("Internal error"); // it is possible that a field code contains no instr text if (!cachedAnnotationInformation.ContainsKey(id)) return ""; var relevantElements = cachedAnnotationInformation[id]; #endif var groupedSubFields = relevantElements .GroupAdjacent(e => { Stack<FieldElementTypeInfo> s = e.Annotation<Stack<FieldElementTypeInfo>>(); var stackElement = s.FirstOrDefault(z => z.Id == id); var elementsBefore = s.TakeWhile(z => z != stackElement); return elementsBefore.Any(); }) .ToList(); var instrText = groupedSubFields .Select(g => { if (g.Key == false) { return g.Select(e => { Stack<FieldElementTypeInfo> s = e.Annotation<Stack<FieldElementTypeInfo>>(); var stackElement = s.FirstOrDefault(z => z.Id == id); if (stackElement.FieldElementType == FieldElementTypeEnum.InstrText && e.Name == w + "instrText") return e.Value; return ""; }) .StringConcatenate(); } else { Stack<FieldElementTypeInfo> s = g.First().Annotation<Stack<FieldElementTypeInfo>>(); var stackElement = s.FirstOrDefault(z => z.Id == id); var elementBefore = s.TakeWhile(z => z != stackElement).Last(); var subFieldId = elementBefore.Id; return InstrText(root, subFieldId); } }) .StringConcatenate(); return "{" + instrText + "}"; }
/// <summary> /// Валидизация исходного XML /// </summary> /// <param name="srcXml">Элемент для проверки соответствия PHTML</param> /// <param name="context">Контекст обработки PHTML (дополнительные настройки, опции, списки доверения)</param> /// <returns></returns> public static PortableHtmlContext Validate(XElement srcXml, PortableHtmlContext context = null) { context = context ?? new PortableHtmlContext(); context.SourceXml = srcXml; //hack way to provide addition info to method if (null == srcXml.Annotation<CheckedBySourceCheckerAnnotation>()){ CheckRootElement(context); if (!context.IsActive) return context; CheckNoComments(context); if (!context.IsActive) return context; CheckNoProcessingInstructions(context); if (!context.IsActive) return context; } CheckDeprecatedElements(context); if (!context.IsActive) return context; CheckNamespaces(context); if (!context.IsActive) return context; CheckDeprecatedAttributes(context); if (!context.IsActive) return context; CheckUpperCase(context); if (!context.IsActive) return context; CheckEmptyElements(context); if (!context.IsActive) return context; CheckAnchorLinks(context); if (!context.IsActive) return context; CheckImageLinks(context); if (!context.IsActive) return context; CheckRootTextNodes(context); if (!context.IsActive) return context; CheckRootInlineElements(context); if (!context.IsActive) return context; CheckNestedParas(context); if (!context.IsActive) return context; CheckNoTextElementsText(context); if (!context.IsActive) return context; CheckNoTextElementsInlines(context); if (!context.IsActive) return context; if (context.Level.HasFlag(PortableHtmlStrictLevel.AllowBr)){ CheckBrPosition(context); if (!context.IsActive) return context; } if (context.Level.HasFlag(PortableHtmlStrictLevel.AllowLists)) { CheckListSchema(context); if (!context.IsActive) return context; } if (context.Level.HasFlag(PortableHtmlStrictLevel.AllowTables)) { CheckTableSchema(context); if (!context.IsActive) return context; } return context; }
/// <summary> /// Validate the behavior of annotations on Container. /// </summary> /// <param name="contextValue"></param> /// <returns></returns> //[Variation(Desc = "ContainerAnnotations")] public void ContainerAnnotations() { XElement element1 = new XElement("e1"); XElement element2 = new XElement("e2"); // Check argument null exception on add. try { element1.AddAnnotation(null); Validate.ExpectedThrow(typeof(ArgumentNullException)); } catch (Exception ex) { Validate.Catch(ex, typeof(ArgumentNullException)); } // Before adding anything, should not be able to get any annotations. Validate.IsNull(element1.Annotation(typeof(object))); element1.RemoveAnnotations(typeof(object)); Validate.IsNull(element1.Annotation(typeof(object))); // First annotation: 2 cases, object[] and other. object obj1 = "hello"; element1.AddAnnotation(obj1); Validate.IsNull(element1.Annotation(typeof(byte))); Validate.IsReferenceEqual(element1.Annotation(typeof(string)), obj1); element1.RemoveAnnotations(typeof(string)); Validate.IsNull(element1.Annotation(typeof(string))); object[] obj2 = new object[] { 10, 20, 30 }; element2.AddAnnotation(obj2); Validate.IsReferenceEqual(element2.Annotation(typeof(object[])), obj2); Validate.Enumerator<object>((object[])element2.Annotation(typeof(object[])), new object[] { 10, 20, 30 }); element2.RemoveAnnotations(typeof(object[])); Validate.IsNull(element2.Annotation(typeof(object[]))); // Single annotation; add a second one. Check that duplicates are allowed. object obj3 = 10; element1.AddAnnotation(obj3); Validate.IsReferenceEqual(element1.Annotation(typeof(int)), obj3); element1.AddAnnotation(1000); element1.RemoveAnnotations(typeof(int[])); Validate.IsNull(element1.Annotation(typeof(object[]))); object obj4 = "world"; element1.AddAnnotation(obj4); Validate.IsReferenceEqual(element1.Annotation(typeof(int)), obj3); Validate.IsReferenceEqual(element1.Annotation(typeof(string)), obj4); // Multiple annotations already. Add one on the end. object obj5 = 20L; element1.AddAnnotation(obj5); Validate.IsReferenceEqual(element1.Annotation(typeof(int)), obj3); Validate.IsReferenceEqual(element1.Annotation(typeof(string)), obj4); Validate.IsReferenceEqual(element1.Annotation(typeof(long)), obj5); // Remove one from the middle and then add, which should use the // freed slot. element1.RemoveAnnotations(typeof(string)); Validate.IsNull(element1.Annotation(typeof(string))); object obj6 = 30m; element1.AddAnnotation(obj6); Validate.IsReferenceEqual(element1.Annotation(typeof(int)), obj3); Validate.IsReferenceEqual(element1.Annotation(typeof(long)), obj5); Validate.IsReferenceEqual(element1.Annotation(typeof(decimal)), obj6); // Ensure that duplicates are allowed. element1.AddAnnotation(40m); Validate.IsNull(element1.Annotation(typeof(sbyte))); // A couple of additional remove cases. element2.AddAnnotation(obj2); element2.AddAnnotation(obj3); element2.AddAnnotation(obj5); element2.AddAnnotation(obj6); element2.RemoveAnnotations(typeof(float)); Validate.IsNull(element2.Annotation(typeof(float))); }
public static ListItemInfo GetListItemInfo(XDocument numXDoc, XDocument stylesXDoc, XElement paragraph) { // The following is an optimization - only determine ListItemInfo once for a // paragraph. ListItemInfo listItemInfo = paragraph.Annotation<ListItemInfo>(); if (listItemInfo != null) return listItemInfo; throw new OpenXmlPowerToolsException("Attempting to retrieve ListItemInfo before initialization"); }
//[Variation(Desc = "Tuple - New Dev10 Types", Param = 1)] //[Variation(Desc = "DynamicObject - New Dev10 Types", Param = 2)] //[Variation(Desc = "Guid - old type", Param = 3)] //[Variation(Desc = "Dictionary - old type", Param = 4)] public void CreatingXElementsFromNewDev10Types() { object t = null; Type type = typeof(object); int param = (int)this.Variation.Param; switch (param) { case 1: t = Tuple.Create(1, "Melitta", 7.5); type = typeof(Tuple); break; case 3: t = new Guid(); type = typeof(Guid); break; case 4: t = new Dictionary<int, string>(); ((Dictionary<int, string>)t).Add(7, "a"); type = typeof(Dictionary<int, string>); break; } XElement e = new XElement("e1", new XElement("e2"), "text1", new XElement("e3"), t); e.Add(t); e.FirstNode.ReplaceWith(t); XNode n = e.FirstNode.NextNode; n.AddBeforeSelf(t); n.AddAnnotation(t); n.ReplaceWith(t); e.FirstNode.AddAfterSelf(t); e.AddFirst(t); e.Annotation(type); e.Annotations(type); e.RemoveAnnotations(type); e.ReplaceAll(t); e.ReplaceAttributes(t); e.ReplaceNodes(t); e.SetAttributeValue("a", t); e.SetElementValue("e2", t); e.SetValue(t); XAttribute a = new XAttribute("a", t); XStreamingElement se = new XStreamingElement("se", t); se.Add(t); try { new XDocument(t); } catch (ArgumentException) { try { new XDocument(t); } catch (ArgumentException) { return; } } TestLog.Compare(false, "Failed"); }
void CheckConnectionId(XamlContext ctx, XElement elem, Dictionary<int, Action<XamlContext, XElement>> connIds) { var connId = elem.Annotation<BamlConnectionId>(); if (connId == null) return; Action<XamlContext, XElement> cb; if (!connIds.TryGetValue((int)connId.Id, out cb)) { elem.AddBeforeSelf(new XComment("Unknown connection ID: " + connId.Id)); return; } cb(ctx, elem); }
/// <summary> /// Searches the specified XML tree for any elements which are annotated as framework templates. /// </summary> private static void GetFrameworkTemplateElements(XElement root, IDictionary<String, XElement> elements) { var annotation = root.Annotation<FrameworkTemplateNameAnnotation>(); if (annotation != null) elements[annotation.Name] = root; var children = root.Elements(); foreach (var child in children) GetFrameworkTemplateElements(child, elements); }
public static void SetParagraphLevel(XElement paragraph, int ilvl) { var pi = paragraph.Annotation<ParagraphInfo>(); if (pi == null) { pi = new ParagraphInfo() { Ilvl = ilvl, }; paragraph.AddAnnotation(pi); return; } throw new OpenXmlPowerToolsException("Internal error - should never set ilvl more than once."); }
/// <summary> /// </summary> /// <param name="el"></param> /// <returns></returns> public bool InChecking(XElement el){ if (Strategy == PortableHtmlVerificationStrategy.Full) return true; return null == el.Annotation<SkipInElementChecking>(); }
private static IEnumerable<XElement> ParaStyleParaPropsStack(XDocument stylesXDoc, string paraStyleName, XElement para) { if (stylesXDoc == null) yield break; var localParaStyleName = paraStyleName; while (localParaStyleName != null) { XElement paraStyle = stylesXDoc.Root.Elements(W.style).FirstOrDefault(s => s.Attribute(W.type).Value == "paragraph" && s.Attribute(W.styleId).Value == localParaStyleName); if (paraStyle == null) { yield break; } if (paraStyle.Element(W.pPr) == null) { if (paraStyle.Element(W.rPr) != null) { var elementToYield2 = new XElement(W.pPr, paraStyle.Element(W.rPr)); yield return elementToYield2; } localParaStyleName = (string)(paraStyle .Elements(W.basedOn) .Attributes(W.val) .FirstOrDefault()); continue; } var elementToYield = new XElement(W.pPr, paraStyle.Element(W.pPr).Attributes(), paraStyle.Element(W.pPr).Elements(), paraStyle.Element(W.rPr)); yield return (elementToYield); var listItemInfo = para.Annotation<ListItemRetriever.ListItemInfo>(); if (listItemInfo != null) { if (listItemInfo.IsListItem) { XElement lipPr = listItemInfo.Lvl(ListItemRetriever.GetParagraphLevel(para)).Element(W.pPr); if (lipPr == null) lipPr = new XElement(W.pPr); XElement lirPr = listItemInfo.Lvl(ListItemRetriever.GetParagraphLevel(para)).Element(W.rPr); var elementToYield2 = new XElement(W.pPr, lipPr.Attributes(), lipPr.Elements(), lirPr); yield return (elementToYield2); } } localParaStyleName = (string)paraStyle .Elements(W.basedOn) .Attributes(W.val) .FirstOrDefault(); } yield break; }
void CheckConnectionId(XamlContext ctx, XElement elem, Dictionary<int, Action<XamlContext, XElement>> connIds) { var connId = elem.Annotation<BamlConnectionId>(); if (connId == null) return; Action<XamlContext, XElement> cb; if (!connIds.TryGetValue((int)connId.Id, out cb)) { elem.AddBeforeSelf(new XComment(string.Format(dnSpy_BamlDecompiler_Resources.Error_UnknownConnectionId, connId.Id))); return; } cb(ctx, elem); }
XamlExtension InlineExtension(XamlContext ctx, XElement ctxElement) { var type = ctxElement.Annotation<XamlType>(); if (type == null) return null; var ext = new XamlExtension(type); foreach (var attr in ctxElement.Attributes().Where(attr => attr.Name.Namespace != XNamespace.Xmlns)) ext.NamedArguments[attr.Name.LocalName] = attr.Value; foreach (var child in ctxElement.Nodes()) { var elem = child as XElement; if (elem == null) return null; if (elem.Name == ctor) { if (ext.Initializer != null) return null; var args = InlineCtor(ctx, elem); if (args == null) return null; ext.Initializer = args; continue; } var property = elem.Annotation<XamlProperty>(); if (property == null || elem.Nodes().Count() != 1 || elem.Attributes().Any(attr => attr.Name.Namespace != XNamespace.Xmlns)) return null; var name = property.PropertyName; var value = InlineObject(ctx, elem.Nodes().Single()); ext.NamedArguments[name] = value; } return ext; }
/// <summary> /// Searches the specified XML element tree for binding expressions and adds them to the specified collection. /// </summary> /// <param name="state">The expression compiler's current state.</param> /// <param name="dataSourceDefinition">The data source definition for the data source which is being compiled.</param> /// <param name="dataSourceWrappedType">The type for which a data source wrapper is being compiled.</param> /// <param name="element">The root of the XML element tree to search.</param> /// <param name="expressions">The list to populate with any binding expressions that are found.</param> private static void FindBindingExpressionsInDataSource(ExpressionCompilerState state, DataSourceDefinition dataSourceDefinition, Type dataSourceWrappedType, XElement element, List<BindingExpressionInfo> expressions) { var templateAnnotation = element.Annotation<FrameworkTemplateNameAnnotation>(); if (templateAnnotation != null) return; var elementName = element.Name.LocalName; var elementType = GetPlaceholderType(dataSourceWrappedType, elementName); if (elementType != null || state.GetKnownType(elementName, out elementType)) { var attrs = element.Attributes(); foreach (var attr in attrs) { var attrValue = attr.Value; if (!BindingExpressions.IsBindingExpression(attrValue)) continue; var dprop = FindDependencyOrAttachedPropertyByName(state, attr.Name.LocalName, elementType); if (dprop == null) { throw new BindingExpressionCompilationErrorException(attr, dataSourceDefinition.DefinitionPath, CompilerStrings.OnlyDependencyPropertiesCanBeBound.Format(attr.Name.LocalName)); } var expText = BindingExpressions.GetBindingMemberPathPart(attrValue); var expProp = GetBindablePropertyOnDataSource(dataSourceWrappedType, expText); expressions.Add(new BindingExpressionInfo(attr, attrValue, expProp?.PropertyType ?? dprop.PropertyType) { GenerateGetter = true }); } if (element.Nodes().Count() == 1) { var singleChild = element.Nodes().Single(); if (singleChild.NodeType == XmlNodeType.Text) { var elementValue = ((XText)singleChild).Value; if (BindingExpressions.IsBindingExpression(elementValue)) { String defaultProperty; if (!state.GetElementDefaultProperty(elementType, out defaultProperty) || defaultProperty == null) { throw new BindingExpressionCompilationErrorException(singleChild, dataSourceDefinition.DefinitionPath, CompilerStrings.ElementDoesNotHaveDefaultProperty.Format(elementType.Name)); } var dprop = FindDependencyOrAttachedPropertyByName(state, defaultProperty, elementType); if (dprop == null) { throw new BindingExpressionCompilationErrorException(singleChild, dataSourceDefinition.DefinitionPath, CompilerStrings.OnlyDependencyPropertiesCanBeBound.Format(defaultProperty)); } var expText = BindingExpressions.GetBindingMemberPathPart(elementValue); var expProp = GetBindablePropertyOnDataSource(dataSourceWrappedType, expText); expressions.Add(new BindingExpressionInfo(singleChild, elementValue, expProp?.PropertyType ?? dprop.PropertyType) { GenerateGetter = true }); } } } } var children = element.Elements(); foreach (var child in children) { FindBindingExpressionsInDataSource(state, dataSourceDefinition, dataSourceWrappedType, child, expressions); } }