public static KmlNode[] SelectNodes(KmlNode ParentNode, string Path) { //check that the path is not blank if (Path != "") { List<KmlNode> SelectedNodes = new List<KmlNode>(); string[] nodeNames = Path.Split('/'); foreach (KmlNode kNode in ParentNode.ChildNodes) { if (String.Compare(kNode.FirstValue.Value, nodeNames[0], true) == 0 && nodeNames.Length == 1) { SelectedNodes.Add(kNode); //MessageBox.Show("Ad1"); } if (nodeNames.Length > 1) { //MessageBox.Show(GetNextPath(nodeNames)); SelectedNodes.AddRange(SelectNodes(kNode, GetNextPath(nodeNames))); } } return SelectedNodes.ToArray(); } else { throw new InvalidKmlPathException(Path); } }
/// <summary> /// Adds an item to the collection. /// </summary> /// <param name="item">The item to add to the collection.</param> /// <returns></returns> public KmlNode Add(KmlNode item) { List.Add(item); item.Parent = Parent; return item; }
/// <summary> /// Sets the item at the specified index in the collection. /// </summary> /// <param name="index">The index to set.</param> /// <param name="item">The item to set.</param> public void Set(int index, KmlNode item) { List[index] = item; item.Parent = Parent; }
/// <summary> /// Creates a new collection with the specified parent. /// </summary> /// <param name="parent">The parent.</param> public KmlNodeCollection(KmlNode parent) { this.Parent = parent; }
/// <summary> /// Gets the index of the specified item. /// </summary> /// <param name="item">The item to get the index of.</param> /// <returns></returns> public int IndexOf(KmlNode item) { return List.IndexOf(item); }
/// <summary> /// Removes the item from the collection. /// </summary> /// <param name="item"></param> public void Remove(KmlNode item) { if (List.Contains(item)) { List.Remove(item); item.Parent = null; } }
/// <summary> /// Checks if the collection contains the specified item. /// </summary> /// <param name="item">The item to check for.</param> /// <returns></returns> public bool Contains(KmlNode item) { return List.Contains(item); }
/// <summary> /// Copies the collection to an array starting at a specified index. /// </summary> /// <param name="array">The array to copy the collection to.</param> /// <param name="index">The index to start copying from.</param> public void CopyTo(KmlNode[] array, int index) { List.CopyTo(array, index); }
/// <summary> /// Adds a range of items to the collection /// </summary> /// <param name="range">The range of values to add to the collection.</param> public void AddRange(KmlNode[] range) { foreach (KmlNode value in range) { List.Add(value); value.Parent = Parent; } }
/// <summary> /// Returns a deep-copy of the collection. /// </summary> /// <returns></returns> public KmlNodeCollection Clone(KmlNode parent) { KmlNodeCollection newCollection = new KmlNodeCollection(parent); foreach (KmlNode item in List) { newCollection.Add(item.Clone()); } return newCollection; }
/// <summary> /// Merges the node with the target node. /// </summary> /// <param name="target">The target to merge with.</param> public void Merge(KmlNode target) { if (target == null || target == this) { return; } //merge values for(int i = this.Values.Count; i < target.Values.Count; i++) { this.Values.Add(target.Values[i]); // MessageBox.Show(target.Values[i].Value); } List<KmlNode> subNodesToAdd = new List<KmlNode>(); //match first values that are not numeric foreach (KmlNode targetSubNode in target.ChildNodes) { //merge current subnodes foreach (KmlNode subNode in this.ChildNodes) { //if it is numeric then it is probably an array. if (targetSubNode.FirstValue.IsNumeric) { if (subNode.FirstValue.IsNumeric) { //they are both numeric so we can merge the values subNode.Merge(targetSubNode); } } else { //check if the subnodes have the same key if (targetSubNode.FirstValue.Value == subNode.FirstValue.Value) { //merge them //MessageBox.Show(targetSubNode.FirstValue.Value); subNode.Merge(targetSubNode); } } } //for subnodes that don't exist if (!this.ChildNodes.ContainsKey(targetSubNode.FirstValue.Value)) { subNodesToAdd.Add(targetSubNode); } } foreach (KmlNode kNode in subNodesToAdd) { this.ChildNodes.Add(kNode); } //we have stolen any nodes needed from target, now we kill the target. target.ChildNodes.Clear(); }
public KmlNode Clone() { KmlNode newNode = new KmlNode(StartPosition.Clone(), EndPosition.Clone()); newNode.ChildNodes = ChildNodes.Clone(newNode); newNode.Values = Values.Clone(newNode); newNode.Values.Parent = newNode; if (StartPosition != null) { newNode.StartPosition = StartPosition.Clone(); } if (EndPosition != null) { newNode.EndPosition = EndPosition.Clone(); } //comments foreach (KmlComment comment in Comments) { newNode.Comments.Add(comment.Clone()); } return newNode; }
/// <summary> /// Returns a deep-copy of the collection. /// </summary> /// <returns></returns> public KmlValueCollection Clone(KmlNode parent) { KmlValueCollection newCollection = new KmlValueCollection(parent); foreach (KmlValue value in List) { newCollection.Add(value.Clone()); } return newCollection; }
/// <summary> /// Reads a comment from the stream /// </summary> /// <returns></returns> public void ReadComment(KmlNode Node) { StringBuilder buffer = new StringBuilder(); bool end = false; //record start position for errors CharPosition startPosition = GetCurrentPosition(); while (!end) { //check if we are at end of stream if (reader.Peek() < 0) { break; } char c = (char)reader.Read(); //keep track of characters read TrackPosition(c); if (c == END_COMMENT_CHAR) { end = true; } else { buffer.Append(c); } } CommentBuffer.Add(new KmlComment(buffer.ToString(), startPosition, GetCurrentPosition())); }
public KmlNode ReadNode(KmlNode Parent) { StringBuilder buffer = new StringBuilder(); bool end = false; bool readingValue = false; //record start position CharPosition nodeStartPosition = GetCurrentPosition(); CharPosition valueStartPosition = GetCurrentPosition(); //node to store values in KmlNode node = new KmlNode(nodeStartPosition); //unload comments node.Comments.AddRange(CommentBuffer); CommentBuffer.Clear(); while (!end) { //check if we are at end of stream if (reader.Peek() < 0) { throw new InvalidKmlSyntaxException(GetCurrentPosition(), new UnclosedNodeException(nodeStartPosition)); } char c = (char)reader.Read(); //keep track of characters read TrackPosition(c); //check for comment if (c == COMMENT_CHAR) { ReadComment(node); continue; } //check if we are reading whitespace if (Char.IsWhiteSpace(c) || Char.IsSeparator(c) || c== CLOSE_NODE_CHAR) { //check if we have finished reading the node if (c == CLOSE_NODE_CHAR) { //end reading end = true; } //check if we have been reading a value if (readingValue) { //create new value KmlValue val = new KmlValue(buffer.ToString(), false, valueStartPosition, GetCurrentPosition()); //give it out comments val.Comments.AddRange(CommentBuffer); //clear out our comments CommentBuffer.Clear(); //put the buffer into a value node.Values.Add(val); //finished reading value readingValue = false; //clear buffer buffer = new StringBuilder(); } //if not ignore } else { //check if theres another node to read if (c == OPEN_NODE_CHAR) { //read the node and add to child nodes KmlNode rn = ReadNode(null); node.ChildNodes.Add(rn); } //check if theres a string to read else if (c == QUOTE_CHAR) { //end pos CharPosition valueEndPosition = GetCurrentPosition(); //create our value KmlValue val = new KmlValue(ReadString(), true, valueStartPosition, valueEndPosition); //give it out comments val.Comments.AddRange(CommentBuffer); //clear out our comments CommentBuffer.Clear(); //read the string and add it to values node.Values.Add(val); } else { //check if we are reading a value if (!readingValue) { //we arnt reading a value - but we are now readingValue = true; //set value start post valueStartPosition = GetCurrentPosition(); } //add the character to the buffer buffer.Append(c); //MessageBox.Show(c.ToString()); } } } node.EndPosition = new CharPosition(Position.Row, Position.Column + 1, Position.Offset + 1); return node; }