private void ProcessElement(XPathNavigator navigator) { //TODO: prob a better way of doing this using the navigator if (!isFirstElement) { textWriter.Write(Environment.NewLine); } isFirstElement = false; WriteIndent(); if (navigator.LocalName.ToLower() == "pre") { isInsidePre = true; } if (navigator.LocalName == "div") { var temp = navigator.CreateNavigator(); if (temp.MoveToAttribute("id", null)) { textWriter.Write("#"); textWriter.Write(temp.Value); } else if (temp.MoveToAttribute("class", null)) { var strings = temp.Value.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries); foreach (var s in strings) { textWriter.Write("."); textWriter.Write(s); } } else { textWriter.Write("%div"); } } else if (navigator.Prefix == string.Empty) { textWriter.Write("%{0}", navigator.LocalName); CheckForAndAppendClass(navigator); } //else //{ //TODO: //Console.Write(" <{0}:{1}>",oNavigator.Prefix,oNavigator.LocalName); //Console.WriteLine("\t" + oNavigator.NamespaceURI); //} var attributeNavigator = navigator.CreateNavigator(); ProcessAttributes(attributeNavigator); indent++; }
/// <summary> /// Updates the node replacing inheritdoc node with comments found. /// </summary> /// <param name="inheritDocNodeNavigator">Navigator for inheritdoc node</param> /// <param name="contentNodeNavigator">Navigator for content</param> private void UpdateNode(XPathNavigator inheritDocNodeNavigator, XPathNavigator contentNodeNavigator) { // retrieve the selection filter if specified. string selectValue = inheritDocNodeNavigator.GetAttribute("select", string.Empty); if (!string.IsNullOrEmpty(selectValue)) { sourceExpression = XPathExpression.Compile(selectValue); } inheritDocNodeNavigator.MoveToParent(); if (inheritDocNodeNavigator.LocalName != "comments" && inheritDocNodeNavigator.LocalName != "element") { sourceExpression = XPathExpression.Compile(inheritDocNodeNavigator.LocalName); } else { inheritDocNodeNavigator.MoveTo(this.sourceDocument.CreateNavigator().SelectSingleNode(inheritDocExpression)); } XPathNodeIterator sources = (XPathNodeIterator)contentNodeNavigator.CreateNavigator().Evaluate(sourceExpression); inheritDocNodeNavigator.DeleteSelf(); // append the source nodes to the target node foreach (XPathNavigator source in sources) { inheritDocNodeNavigator.AppendChild(source); } }
public override XPathNavigator CreateNavigator() { var r1 = _nav1.CreateNavigator(); var r2 = _nav2.CreateNavigator(); return(new NavigatorComparer(r1, r2)); }
public string PeekType() { XPathNavigator peekingNavigator = navigator.CreateNavigator(); peekingNavigator.MoveToFirstChild(); return(peekingNavigator.LocalName); }
/// <summary> /// Updates the node replacing inheritdoc node with comments found. /// </summary> /// <param name="inheritDocNodeNavigator">Navigator for inheritdoc node</param> /// <param name="contentNodeNavigator">Navigator for content</param> private void UpdateNode(XPathNavigator inheritDocNodeNavigator, XPathNavigator contentNodeNavigator) { // retrieve the selection filter if specified. string selectValue = inheritDocNodeNavigator.GetAttribute("select", String.Empty); if (!String.IsNullOrEmpty(selectValue)) { this.WriteMessage(MessageLevel.Info, "Filter: " + selectValue); sourceExpression = XPathExpression.Compile(selectValue); } inheritDocNodeNavigator.MoveToParent(); bool isInnerText = false; if (inheritDocNodeNavigator.LocalName != "comments" && inheritDocNodeNavigator.LocalName != "element") { sourceExpression = XPathExpression.Compile(inheritDocNodeNavigator.LocalName); isInnerText = true; } else { inheritDocNodeNavigator.MoveTo( this.sourceDocument.CreateNavigator().SelectSingleNode(inheritDocExpression)); } XPathNodeIterator sources = (XPathNodeIterator)contentNodeNavigator.CreateNavigator().Evaluate(sourceExpression); if (isInnerText && sources.Count == 1) { //inheritDocNodeNavigator.DeleteSelf(); inheritDocNodeNavigator.MoveTo( this.sourceDocument.CreateNavigator().SelectSingleNode(inheritDocExpression)); // append the source nodes to the target node foreach (XPathNavigator source in sources) { inheritDocNodeNavigator.ReplaceSelf(source.InnerXml); } } else { inheritDocNodeNavigator.DeleteSelf(); // append the source nodes to the target node foreach (XPathNavigator source in sources) { XPathNodeIterator childIterator = inheritDocNodeNavigator.SelectChildren( source.Name, String.Empty); if (childIterator.Count == 0) { inheritDocNodeNavigator.AppendChild(source); } } } }
public Vector GetVector(XPathNavigator root) { XmlNamespaceManager nsm = FhirNamespaceManager.CreateManager(root); Structure structure = specification.GetStructureByName(root.Name); XPathNavigator node = root.CreateNavigator(); return(Vector.Create(structure, node, nsm)); }
private void WriteNextNode(XmlWriter writer, XPathNavigator nav, bool iterateSiblings) { if (nav.Name == "ScatterFile") { writer.WriteStartElement(nav.Name, nav.NamespaceURI); } else { writer.WriteStartElement(nav.Name); } XPathNavigator attrib = nav.CreateNavigator(); if (attrib.MoveToFirstAttribute()) { do { writer.WriteAttributeString(attrib.Name, attrib.Value); }while (attrib.MoveToNextAttribute()); } if (nav.Name == "LoadRegion") { string lrName = nav.GetAttribute("Name", ""); foreach (ExecRegion er in (m_execRegionOrderMap[lrName] as SortedList).Values) { WriteNextNode(writer, m_execRegionsToNavNode[lrName + ":" + er.Name] as XPathNavigator, false); } } /* * else if (nav.Name == "ExecRegion") * { * string erName = nav.GetAttribute("Name", ""); * * foreach (FileMapping fm in (m_symOrderMap[erName] as SortedList).Values) * { * WriteNextNode(writer, m_symToNavNode[erName + ":" + fm.Name] as XPathNavigator, false); * } * } */ else { XPathNodeIterator children = nav.SelectChildren(XPathNodeType.Element); while (children.MoveNext()) { WriteNextNode(writer, children.Current, iterateSiblings); } } writer.WriteEndElement(); if (iterateSiblings && nav.MoveToNext()) { WriteNextNode(writer, nav, iterateSiblings); } }
public static void RemoveAttribute(this XPathNavigator navigator, string name) { var navi = navigator.CreateNavigator(); if (navi.MoveToAttribute(name)) { navi.DeleteSelf(); } }
protected virtual Paragraph CreateCodeParagraph(XPathNavigator codeNavigator, Story story, FlowDocumentStyleProvider styleProvider) { Paragraph paragraph = new Paragraph(new Run()); // Navigate paragraph using a duplicate navigator. Step inside paragraph's first child before beginning navigation XPathNavigator parsingNavigator = codeNavigator.CreateNavigator(); if (parsingNavigator.NodeType == XPathNodeType.Element && parsingNavigator.Name.ToLower(CultureInfo.InvariantCulture) == "code" && parsingNavigator.MoveToFirstChild()) { ParseContent(parsingNavigator.CreateNavigator(), paragraph.ContentStart, styleProvider); } MsdnStoryToFlowDocumentConverter.ApplyStyle(paragraph, GetArticleCodeStyle(styleProvider)); return(paragraph); }
internal Element(XPathNavigator node) : this(node.Name) { XPathNavigator navigator = node.CreateNavigator(); if (navigator.MoveToFirstAttribute()) { do { AddAttribute(navigator.Name, navigator.Value); } while (navigator.MoveToNextAttribute()); } }
private static string GetFullPath(XPathNavigator nav) { nav = nav.CreateNavigator(); var names = new Stack <string>(); names.Push(nav.Name); while (nav.MoveToParent()) { names.Push(nav.Name); } return("/" + string.Join("/", names)); }
public static void SetOrCreateAttribute(this XPathNavigator navigator, string name, string value) { var navi = navigator.CreateNavigator(); if (navi.MoveToAttribute(name)) { navi.SetValue(value); } else { navi.CreateAttribute(name, value); } }
public void PopulateDisplayItems() { XPathNavigator root = UserOptions.OptionsDoc.CreateNavigator(); root.MoveToFirstChild(); root = root.SelectSingleNode("results/resultFonts"); if (root != null) { XPathNavigator nav = root.CreateNavigator(); if (nav.MoveToFirstChild()) { DisplayItem item; string colorName; itemsBox.Items.Clear(); do { item = new DisplayItem(); item.Name = nav.Name; item.InternalName = nav.LocalName; item.FamilyName = nav.GetAttribute("family", nav.NamespaceURI); item.Size = Int32.Parse(nav.GetAttribute("size", nav.NamespaceURI)); colorName = nav.GetAttribute("foreColor", nav.NamespaceURI); item.ForeColor = Color.FromName(colorName); if (!item.ForeColor.IsKnownColor) { item.ForeColor = Color.FromArgb(int.Parse( colorName, System.Globalization.NumberStyles.HexNumber)); } colorName = nav.GetAttribute("backColor", nav.NamespaceURI); item.BackColor = Color.FromName(colorName); if (!item.BackColor.IsKnownColor) { item.BackColor = Color.FromArgb(int.Parse( colorName, System.Globalization.NumberStyles.HexNumber)); } item.FontStyle = (FontStyle)Enum.Parse( typeof(FontStyle), nav.GetAttribute("style", nav.NamespaceURI)); itemsBox.Items.Add(item); }while (nav.MoveToNext()); } } itemsBox.SelectedIndex = 0; }
public string NodePath() { XPathNavigator n = Node.CreateNavigator(); string s = n.Name; while (!n.IsSamePosition(Origin.Node) && n.MoveToParent()) { if (!string.IsNullOrEmpty(n.Name)) { s = n.Name + "." + s; } } return(s); }
/// <summary> /// Creates a body text paragraph from body navigator. Paragraph number is passed in in case different styles /// are desired for the first paragraph, etc. /// </summary> protected override Paragraph CreateBodyTextParagraph(XPathNavigator paragraphNavigator, Story story, FlowDocumentStyleProvider styleProvider, int paragraphNumber) { Paragraph paragraph = new Paragraph(new Run()); // Navigate paragraph using a duplicate navigator. Step inside paragraph's first child before beginning navigation XPathNavigator parsingNavigator = paragraphNavigator.CreateNavigator(); if (parsingNavigator.NodeType == XPathNodeType.Element && parsingNavigator.Name.ToLower(CultureInfo.InvariantCulture) == "para" && parsingNavigator.MoveToFirstChild()) { ParseContent(parsingNavigator.CreateNavigator(), paragraph.ContentStart, styleProvider); } ApplyStyle(paragraph, GetBodyTextParagraphStyle(styleProvider, paragraphNumber)); return(paragraph); }
private void DeleteDestinationRows() { XPathNavigator sas_OrgCountyArea = MainDataSource.CreateNavigator().SelectSingleNode("/my:myFields/my:Sec04_PropAreaOfCaverageOrg/my:sas_OrgCountyArea", NamespaceManager); XPathNodeIterator OrgCountyAreaCoverageItems = sas_OrgCountyArea.Select("./my:OrgCountyAreaCoverage", NamespaceManager); if (OrgCountyAreaCoverageItems.Count > 0) { for (int i = OrgCountyAreaCoverageItems.Count; i > 0; i--) { XPathNavigator OrgCountyAreaCoverageItem = sas_OrgCountyArea.CreateNavigator().SelectSingleNode("my:OrgCountyAreaCoverage[position() = " + i + "]", NamespaceManager); OrgCountyAreaCoverageItem.DeleteSelf(); } } }
/// <summary> /// Loads this <see cref="OpmlOutline"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="OpmlOutline"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="OpmlOutline"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { bool wasLoaded = false; Guard.ArgumentNotNull(source, "source"); if (source.HasAttributes) { XPathNavigator attributesNavigator = source.CreateNavigator(); if (attributesNavigator.MoveToFirstAttribute()) { if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } while (attributesNavigator.MoveToNextAttribute()) { if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } } } } if (source.HasChildren) { XPathNodeIterator outlinesIterator = source.Select("outline"); if (outlinesIterator != null && outlinesIterator.Count > 0) { while (outlinesIterator.MoveNext()) { OpmlOutline outline = new OpmlOutline(); if (outline.Load(outlinesIterator.Current, settings)) { this.Outlines.Add(outline); wasLoaded = true; } } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return(wasLoaded); }
public void Read(XPathNavigator navigator, ContentItem item, ReadingJournal journal) { IDictionary<string, IAttachmentHandler> attachments = explorer.Map<IAttachmentHandler>(item.GetContentType()); foreach(XPathNavigator attachmentElement in EnumerateChildren(navigator)) { string name = attachmentElement.GetAttribute("name", string.Empty); if(attachments.ContainsKey(name)) { XPathNavigator attachmentContents = navigator.CreateNavigator(); attachmentContents.MoveToFirstChild(); Attachment a = attachments[name].Read(attachmentContents, item); if(a != null) journal.Report(a); } } }
protected virtual void ProcessXml(bool stripResource, bool ignoreResource) { if (!AllowedAssemblySelector.HasFlag(AllowedAssemblies.AnyAssembly) && _resourceAssembly == null) { throw new InvalidOperationException("The containing assembly must be specified for XML which is restricted to modifying that assembly only."); } try { XPathNavigator nav = _document.CreateNavigator(); // Initial structure check - ignore XML document which don't look like linker XML format if (!nav.MoveToChild(LinkerElementName, XmlNamespace)) { return; } if (_resource != null) { if (stripResource) { _context.Annotations.AddResourceToRemove(_resourceAssembly, _resource); } if (ignoreResource) { return; } } if (!ShouldProcessElement(nav)) { return; } ProcessAssemblies(nav.SelectChildren("assembly", "")); // For embedded XML, allow not specifying the assembly explicitly in XML. if (_resourceAssembly != null) { ProcessAssembly(_resourceAssembly, nav, warnOnUnresolvedTypes: true); } } catch (Exception ex) when(!(ex is LinkerFatalErrorException)) { throw new LinkerFatalErrorException(MessageContainer.CreateErrorMessage($"Error processing '{_xmlDocumentLocation}'", 1013), ex); } }
internal static object ReadArrayProperty(this XPathNavigator reader, string path) { var comment = reader.CreateNavigator(); comment.MoveToFirstChild(); bool isSet = comment.NodeType == XPathNodeType.Comment && comment.Value == "Set"; var childs = reader.SelectChildren(XPathNodeType.Element); var values = new List <object>(); path += isSet ? "/set" : "/array"; foreach (XPathNavigator child in childs) { string childpath = String.Format("{0}[{1}]", path, values.Count); object obj = child.ReadObject(childpath); values.Add(obj); } return(isSet ? (object)new Set(values.ToArray()) : (object)values.ToArray()); }
protected virtual void ProcessXml(bool ignoreResource) { if (!AllowedAssemblySelector.HasFlag(AllowedAssemblies.AnyAssembly) && _owningModule == null) { throw new InvalidOperationException("The containing assembly must be specified for XML which is restricted to modifying that assembly only."); } try { XPathNavigator nav = _document.CreateNavigator(); // Initial structure check - ignore XML document which don't look like linker XML format if (!nav.MoveToChild(LinkerElementName, XmlNamespace)) { return; } if (_owningModule != null) { if (ignoreResource) { return; } } if (!ShouldProcessElement(nav)) { return; } ProcessAssemblies(nav); // For embedded XML, allow not specifying the assembly explicitly in XML. if (_owningModule != null) { ProcessAssembly(_owningModule, nav, warnOnUnresolvedTypes: true); } } catch (Exception ex) { // throw new LinkerFatalErrorException(MessageContainer.CreateErrorMessage(null, DiagnosticId.ErrorProcessingXmlLocation, _xmlDocumentLocation), ex); throw ex; } }
public void XPathNavigatorMembers(XPathNavigator nav, IXmlNamespaceResolver nsResolver, XPathExpression pathExpression) { const string constantPath = "/my/xpath/expression"; string path = "variable path"; // Should not raise for hard-coded paths nav.Compile(constantPath); nav.Evaluate("xpath-expression"); nav.Select(constantPath); nav.Matches(FixedPath); // Should raise for variable paths nav.Compile(path); // Noncompliant nav.Evaluate(path); // Noncompliant nav.Evaluate(path, nsResolver); // Noncompliant nav.Evaluate(pathExpression); // Compliant - using path expression objects is ok nav.Evaluate(pathExpression, null); nav.Matches(path); // Noncompliant nav.Matches(pathExpression); // XPathNavigator selection methods nav.Select(path); // Noncompliant nav.Select(path, nsResolver); // Noncompliant nav.Select(pathExpression); nav.SelectSingleNode(path); // Noncompliant nav.SelectSingleNode(path, nsResolver); // Noncompliant nav.SelectSingleNode(pathExpression); nav.SelectAncestors("name", "uri", false); nav.SelectChildren("name", "uri"); nav.SelectDescendants("name", "uri", false); nav.AppendChild("newChild"); nav.AppendChildElement("prefix", "localName", "uri", "value"); nav.CheckValidity(null, null); var nav2 = nav.CreateNavigator(); nav2.DeleteRange(nav); }
/// <summary> /// Loads this <see cref="OpmlOutline"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="OpmlOutline"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="OpmlOutline"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { bool wasLoaded = false; Guard.ArgumentNotNull(source, "source"); if (source.HasAttributes) { XPathNavigator attributesNavigator = source.CreateNavigator(); if (attributesNavigator.MoveToFirstAttribute()) { if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } while (attributesNavigator.MoveToNextAttribute()) { if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } } } } if (source.HasChildren) { XPathNodeIterator outlinesIterator = source.Select("outline"); if (outlinesIterator != null && outlinesIterator.Count > 0) { while (outlinesIterator.MoveNext()) { OpmlOutline outline = new OpmlOutline(); if (outline.Load(outlinesIterator.Current)) { this.Outlines.Add(outline); wasLoaded = true; } } } } return(wasLoaded); }
/// ----------------------------------------------------------------------------- /// <summary> /// The ReadComponents method reads the components node of the manifest file. /// </summary> /// ----------------------------------------------------------------------------- private void ReadComponents(XPathNavigator manifestNav) { foreach (XPathNavigator componentNav in manifestNav.CreateNavigator().Select("components/component")) { // Set default order to next value (ie the same as the size of the collection) int order = this._componentInstallers.Count; string type = componentNav.GetAttribute("type", string.Empty); if (this.InstallMode == InstallMode.Install) { string installOrder = componentNav.GetAttribute("installOrder", string.Empty); if (!string.IsNullOrEmpty(installOrder)) { order = int.Parse(installOrder); } } else { string unInstallOrder = componentNav.GetAttribute("unInstallOrder", string.Empty); if (!string.IsNullOrEmpty(unInstallOrder)) { order = int.Parse(unInstallOrder); } } if (this.Package.InstallerInfo != null) { this.Log.AddInfo(Util.DNN_ReadingComponent + " - " + type); } ComponentInstallerBase installer = InstallerFactory.GetInstaller(componentNav, this.Package); if (installer == null) { this.Log.AddFailure(Util.EXCEPTION_InstallerCreate); } else { this._componentInstallers.Add(order, installer); this.Package.InstallerInfo.AllowableFiles += ", " + installer.AllowableFiles; } } }
static void ParseDelegate(XPathNavigator node) { SpecDelegate result = new SpecDelegate(); result.Parameters = new List <SpecField> (); XPathNavigator nameNode = node.SelectSingleNode("name"); result.Name = result.MapName = nameNode.InnerXml; GetSpecType(result.Name).TypeObject = result; delegateMap.Add(result.Name, result); // move to name tag var child = node.CreateNavigator(); child.MoveToFirstChild(); var returnType = Regex.Match(child.Value, @"typedef (\w*)", RegexOptions.CultureInvariant); result.Return = GetSpecType(returnType.Groups[1].Value); result.ReturnIsPointer = Regex.IsMatch(child.Value, @"typedef (\w*)\s*\*", RegexOptions.CultureInvariant); foreach (XPathNavigator item in node.Select("type")) { var paramType = item.Value; item.MoveToNext(XPathNodeType.Text); var raw = Regex.Match(item.Value, @"\s*(\*)?\s*(\w+)", RegexOptions.CultureInvariant); var paramName = raw.Groups[2].Value; var paramIsPointer = raw.Groups[1].Success; result.Parameters.Add(new SpecField() { Type = GetSpecType(paramType), Name = paramName, MapName = paramName, IsPointer = paramIsPointer, }); } }
/// <summary> /// Updates the node replacing inheritdoc node with comments found. /// </summary> /// <param name="key">Id of the topic specified</param> /// <param name="inheritDocNodeNavigator">Navigator for inheritdoc node</param> /// <param name="contentNodeNavigator">Navigator for content</param> private void UpdateNode(string key, XPathNavigator inheritDocNodeNavigator, XPathNavigator contentNodeNavigator) { // retrieve the selection filter if specified. string selectValue = inheritDocNodeNavigator.GetAttribute("select", string.Empty); if (!String.IsNullOrWhiteSpace(selectValue)) { this.ParentBuildComponent.WriteMessage(key, MessageLevel.Warn, "The inheritdoc 'select' " + "attribute has been deprecated. Use the equivalent 'path' attribute instead."); } else { selectValue = inheritDocNodeNavigator.GetAttribute("path", string.Empty); } if (!String.IsNullOrWhiteSpace(selectValue)) { sourceExpression = XPathExpression.Compile(selectValue); } inheritDocNodeNavigator.MoveToParent(); if (inheritDocNodeNavigator.LocalName != "comments" && inheritDocNodeNavigator.LocalName != "element") { sourceExpression = XPathExpression.Compile(inheritDocNodeNavigator.LocalName); } else { inheritDocNodeNavigator.MoveTo(this.sourceDocument.CreateNavigator().SelectSingleNode(inheritDocExpression)); } XPathNodeIterator sources = (XPathNodeIterator)contentNodeNavigator.CreateNavigator().Evaluate(sourceExpression); inheritDocNodeNavigator.DeleteSelf(); // append the source nodes to the target node foreach (XPathNavigator source in sources) { inheritDocNodeNavigator.AppendChild(source); } }
public IList <string> GrabBackDropUrls(XPathNavigator nav) { List <string> urls = new List <string>(); XPathNodeIterator nIter = nav.SelectChildren("backdrop", ""); if (nav.MoveToFollowing("backdrop", "")) { XPathNavigator localNav = nav.CreateNavigator(); nav.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { if (localNav.GetAttribute("size", "").ToUpperInvariant().Equals("original".ToUpperInvariant())) { urls.Add(localNav.Value); } localNav.MoveToNext(); } } return(urls); }
private static void WriteElement(TextWriter writer, XPathNavigator nav, int depth, string leadIn) { writer.Write(leadIn); writer.WriteLine(nav.Name); WriteNamespaces(writer, nav, leadIn); if (nav.HasAttributes) { WriteAttributes(writer, nav, leadIn); } if (!nav.HasChildren) { return; } var childNav = nav.CreateNavigator(); childNav.MoveToFirstChild(); Traverse(writer, childNav, depth + 1); }
public void PopulateDisplayItems () { XPathNavigator root = UserOptions.OptionsDoc.CreateNavigator(); root.MoveToFirstChild(); root = root.SelectSingleNode("editor/editorFonts/lexStyles"); if (root != null) { XPathNavigator nav = root.CreateNavigator(); DisplayItem item; string colorName; foreach (LexStyleItem lexItem in LexStyleItems.Items) { if ((nav = nav.SelectSingleNode(lexItem.InternalName)) != null) { item = new DisplayItem(lexItem); colorName = nav.GetAttribute("foreColor", nav.NamespaceURI); item.ForeColor = Color.FromName(colorName); colorName = nav.GetAttribute("backColor", nav.NamespaceURI); item.BackColor = Color.FromName(colorName); item.FontStyle = (FontStyle)Enum.Parse( typeof(FontStyle), nav.GetAttribute("style", nav.NamespaceURI)); itemsBox.Items.Add(item); Logger.WriteLine("Populate (" + item.Name + ", " + item.ForeColor + ", " + item.BackColor + ")"); } nav = root; } while (nav.MoveToNext()) ; } itemsBox.SelectedIndex = 0; }
private void WriteMultilineValue(XPathNavigator nav) { string type = null; var props = nav.CreateNavigator(); var keepGoing = true; while (keepGoing) { props.MoveToParent(); if (props.MoveToFirstAttribute()) { keepGoing = false; } } keepGoing = true; while (keepGoing) { if (props.Name == "type") { type = props.Value; } if (!(props.MoveToNextAttribute())) { keepGoing = false; } } if (string.IsNullOrEmpty(type)) { WriteJsonValue(nav); } else { props.MoveToRoot(); props.MoveToFirstChild(); WriteJsonValue(nav); } }