public override XmlNode Item(int index)
{
XmlNode requestedNode = null;
// Return null if index is out of range. by DOM design.
if (Count <= index)
{
return(null);
}
// Instead of checking for && index < Count which has to walk
// the whole list to get a count, we'll just keep a count since
// we have to walk the list anyways to get to index.
if ((index >= 0) && (parent.LastLinkedChild != null))
{
XmlLinkedNode currentChild = parent.LastLinkedChild.NextLinkedSibling;
int count = 0;
while ((count < index) && !Object.ReferenceEquals(currentChild, parent.LastLinkedChild))
{
currentChild = currentChild.NextLinkedSibling;
count++;
}
if (count == index)
{
requestedNode = currentChild;
}
}
return(requestedNode);
}
internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
XmlNodeChangedEventArgs insertEventArgsForLoad = doc.GetInsertEventArgsForLoad(newChild, this);
if (insertEventArgsForLoad != null)
{
doc.BeforeEvent(insertEventArgsForLoad);
}
XmlLinkedNode nextNode = (XmlLinkedNode) newChild;
if ((this.lastChild == null) || (this.lastChild == this))
{
nextNode.next = nextNode;
this.lastChild = nextNode;
nextNode.SetParentForLoad(this);
}
else
{
XmlLinkedNode lastChild = this.lastChild;
nextNode.next = lastChild.next;
lastChild.next = nextNode;
this.lastChild = nextNode;
if (lastChild.IsText && nextNode.IsText)
{
XmlNode.NestTextNodes(lastChild, nextNode);
}
else
{
nextNode.SetParentForLoad(this);
}
}
if (insertEventArgsForLoad != null)
{
doc.AfterEvent(insertEventArgsForLoad);
}
return nextNode;
}
internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
XmlNodeChangedEventArgs args = doc.GetInsertEventArgsForLoad(newChild, this);
if (args != null)
{
doc.BeforeEvent(args);
}
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (lastChild == null || lastChild == emptyElem)
{
newNode.next = newNode;
}
else
{
newNode.next = lastChild.next;
lastChild.next = newNode;
}
lastChild = newNode;
newNode.SetParentForLoad(this);
if (args != null)
{
doc.AfterEvent(args);
}
return(newNode);
}
//the function is provided only at Load time to speed up Load process
internal virtual XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
XmlNodeChangedEventArgs args = doc.GetInsertEventArgsForLoad(newChild, this);
if (args != null)
{
doc.BeforeEvent(args);
}
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (LastNode == null)
{
newNode.next = newNode;
}
else
{
newNode.next = LastNode.next;
LastNode.next = newNode;
}
LastNode = newNode;
newNode.SetParentForLoad(this);
if (args != null)
{
doc.AfterEvent(args);
}
return(newNode);
}
internal XmlElement(XmlName name, bool empty, XmlDocument doc) : base(doc)
{
Debug.Assert(name != null);
if (!doc.IsLoading)
{
XmlDocument.CheckName(name.Prefix);
XmlDocument.CheckName(name.LocalName);
}
if (name.LocalName == "")
{
throw new ArgumentException(Res.GetString(Res.Xdom_Empty_LocalName));
}
if (name.Prefix.Length >= 3 && (!doc.IsLoading) && String.Compare(name.Prefix, 0, "xml", 0, 3, true, CultureInfo.InvariantCulture) == 0)
{
throw new ArgumentException(Res.GetString(Res.Xdom_Ele_Prefix));
}
this.name = name;
if (empty)
{
lastChild = emptyElem;
}
else
{
lastChild = null;
}
}
public virtual bool MoveNext()
{
bool movedNext = true;
if (parent.LastLinkedChild == null)
{
movedNext = false;
}
else if (currentChild == null)
{
currentChild = parent.LastLinkedChild.NextLinkedSibling;
}
else
{
if (Object.ReferenceEquals(currentChild, parent.LastLinkedChild))
{
movedNext = false;
passedLastNode = true;
}
else
{
currentChild = currentChild.NextLinkedSibling;
}
}
return(movedNext);
}
/// <include file='doc\XmlNode.uex' path='docs/doc[@for="XmlNode.RemoveChild"]/*' />
/// <devdoc>
/// <para>Removes specified child node.</para>
/// </devdoc>
public virtual XmlNode RemoveChild(XmlNode oldChild)
{
if (!IsContainer)
{
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Remove_Contain));
}
if (oldChild.ParentNode != this)
{
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Remove_Child));
}
XmlLinkedNode oldNode = (XmlLinkedNode)oldChild;
XmlNodeChangedEventArgs args = GetEventArgs(oldNode, this, null, XmlNodeChangedAction.Remove);
if (args != null)
{
BeforeEvent(args);
}
if (oldNode == FirstChild)
{
if (LastNode.next == LastNode)
{
LastNode = null;
}
else
{
LastNode.next = (XmlLinkedNode)FirstChild.NextSibling;
}
}
else
{
XmlLinkedNode prev = (XmlLinkedNode)oldNode.PreviousSibling;
prev.next = oldNode.next;
if (oldNode == LastNode)
{
LastNode = prev;
}
}
oldNode.next = null;
oldNode.SetParent(null);
if (args != null)
{
AfterEvent(args);
}
return(oldChild);
}
XmlLinkedNode lastChild; // == this for empty elements otherwise it is the last child
internal XmlElement( XmlName name, bool empty, XmlDocument doc ): base( doc ) {
Debug.Assert(name!=null);
this.parentNode = null;
if ( !doc.IsLoading ) {
XmlDocument.CheckName( name.Prefix );
XmlDocument.CheckName( name.LocalName );
}
if (name.LocalName.Length == 0)
throw new ArgumentException(Res.GetString(Res.Xdom_Empty_LocalName));
this.name = name;
if (empty) {
this.lastChild = this;
}
}
internal XmlElement( XmlName name, bool empty, XmlDocument doc ): base( doc ) {
Debug.Assert(name!=null);
if ( !doc.IsLoading ) {
XmlDocument.CheckName( name.Prefix );
XmlDocument.CheckName( name.LocalName );
}
if (name.LocalName == "")
throw new ArgumentException(Res.GetString(Res.Xdom_Empty_LocalName));
if ( name.Prefix.Length >= 3 && (! doc.IsLoading) && String.Compare( name.Prefix, 0, "xml", 0, 3, true, CultureInfo.InvariantCulture) == 0 )
throw new ArgumentException(Res.GetString(Res.Xdom_Ele_Prefix));
this.name = name;
if (empty)
lastChild = emptyElem;
else
lastChild = null;
}
XmlLinkedNode lastChild; // == this for empty elements otherwise it is the last child
internal XmlElement( XmlName name, bool empty, XmlDocument doc ): base( doc ) {
Debug.Assert(name!=null);
this.parentNode = null;
if ( !doc.IsLoading ) {
XmlDocument.CheckName( name.Prefix );
XmlDocument.CheckName( name.LocalName );
}
if (name.LocalName.Length == 0)
throw new ArgumentException(Res.GetString(Res.Xdom_Empty_LocalName));
if ( name.Prefix.Length >= 3 && (! doc.IsLoading) && String.Compare( name.Prefix, 0, "xml", 0, 3, StringComparison.OrdinalIgnoreCase ) == 0 )
throw new ArgumentException(Res.GetString(Res.Xdom_Ele_Prefix));
this.name = name;
if (empty) {
this.lastChild = this;
}
}
internal XmlElement(System.Xml.XmlName name, bool empty, XmlDocument doc) : base(doc)
{
base.parentNode = null;
if (!doc.IsLoading)
{
XmlDocument.CheckName(name.Prefix);
XmlDocument.CheckName(name.LocalName);
}
if (name.LocalName.Length == 0)
{
throw new ArgumentException(Res.GetString("Xdom_Empty_LocalName"));
}
this.name = name;
if (empty)
{
this.lastChild = this;
}
}
internal XmlElement(System.Xml.XmlName name, bool empty, XmlDocument doc) : base(doc)
{
base.parentNode = null;
if (!doc.IsLoading)
{
XmlDocument.CheckName(name.Prefix);
XmlDocument.CheckName(name.LocalName);
}
if (name.LocalName.Length == 0)
{
throw new ArgumentException(Res.GetString("Xdom_Empty_LocalName"));
}
this.name = name;
if (empty)
{
this.lastChild = this;
}
}
private XmlLinkedNode _lastChild; // == this for empty elements otherwise it is the last child
internal XmlElement(XmlName name, bool empty, XmlDocument doc) : base(doc)
{
Debug.Assert(name != null);
this.parentNode = null;
if (!doc.IsLoading)
{
XmlDocument.CheckName(name.Prefix);
XmlDocument.CheckName(name.LocalName);
}
if (name.LocalName.Length == 0)
{
throw new ArgumentException(SR.Xdom_Empty_LocalName);
}
_name = name;
if (empty)
{
_lastChild = this;
}
}
internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
Debug.Assert(doc == this);
if (!IsValidChildType(newChild.NodeType))
{
throw new InvalidOperationException(SR.Xdom_Node_Insert_TypeConflict);
}
if (!CanInsertAfter(newChild, LastChild))
{
throw new InvalidOperationException(SR.Xdom_Node_Insert_Location);
}
XmlNodeChangedEventArgs args = GetInsertEventArgsForLoad(newChild, this);
if (args != null)
{
BeforeEvent(args);
}
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (lastChild == null)
{
newNode.next = newNode;
}
else
{
newNode.next = lastChild.next;
lastChild.next = newNode;
}
lastChild = newNode;
newNode.SetParentForLoad(this);
if (args != null)
{
AfterEvent(args);
}
return(newNode);
}
//the function is provided only at Load time to speed up Load process
internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
XmlNodeChangedEventArgs?args = doc.GetInsertEventArgsForLoad(newChild, this);
if (args != null)
{
doc.BeforeEvent(args);
}
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (_lastChild == null ||
_lastChild == this)
{ // if LastNode == null
newNode.next = newNode;
_lastChild = newNode; // LastNode = newNode;
newNode.SetParentForLoad(this);
}
else
{
XmlLinkedNode refNode = _lastChild; // refNode = LastNode;
newNode.next = refNode.next;
refNode.next = newNode;
_lastChild = newNode; // LastNode = newNode;
if (refNode.IsText &&
newNode.IsText)
{
NestTextNodes(refNode, newNode);
}
else
{
newNode.SetParentForLoad(this);
}
}
if (args != null)
{
doc.AfterEvent(args);
}
return(newNode);
}
public virtual bool MoveNext()
{
bool movedNext = true;
if (parent.LastLinkedChild == null) {
movedNext = false;
}
else if (currentChild == null) {
currentChild = parent.LastLinkedChild.NextLinkedSibling;
}
else {
if (Object.ReferenceEquals(currentChild, parent.LastLinkedChild)) {
movedNext = false;
passedLastNode = true;
}
else {
currentChild = currentChild.NextLinkedSibling;
}
}
return movedNext;
}
public virtual bool MoveNext()
{
bool result = true;
if (this.parent.LastLinkedChild == null)
{
result = false;
}
else if (this.currentChild == null)
{
this.currentChild = this.parent.LastLinkedChild.NextLinkedSibling;
}
else if (object.ReferenceEquals(this.currentChild, this.parent.LastLinkedChild))
{
result = false;
this.passedLastNode = true;
}
else
{
this.currentChild = this.currentChild.NextLinkedSibling;
}
return(result);
}
XmlLinkedNode lastChild; // == this for empty elements otherwise it is the last child
internal XmlElement(XmlName name, bool empty, XmlDocument doc) : base(doc)
{
Debug.Assert(name != null);
this.parentNode = null;
if (!doc.IsLoading)
{
XmlDocument.CheckName(name.Prefix);
XmlDocument.CheckName(name.LocalName);
}
if (name.LocalName.Length == 0)
{
throw new ArgumentException(Res.GetString(Res.Xdom_Empty_LocalName));
}
if (name.Prefix.Length >= 3 && (!doc.IsLoading) && String.Compare(name.Prefix, 0, "xml", 0, 3, StringComparison.OrdinalIgnoreCase) == 0)
{
throw new ArgumentException(Res.GetString(Res.Xdom_Ele_Prefix));
}
this.name = name;
if (empty)
{
this.lastChild = this;
}
}
internal virtual XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
XmlNodeChangedEventArgs insertEventArgsForLoad = doc.GetInsertEventArgsForLoad(newChild, this);
if (insertEventArgsForLoad != null)
{
doc.BeforeEvent(insertEventArgsForLoad);
}
XmlLinkedNode lastNode = this.LastNode;
XmlLinkedNode nextNode = (XmlLinkedNode)newChild;
if (lastNode == null)
{
nextNode.next = nextNode;
this.LastNode = nextNode;
nextNode.SetParentForLoad(this);
}
else
{
nextNode.next = lastNode.next;
lastNode.next = nextNode;
this.LastNode = nextNode;
if (lastNode.IsText && nextNode.IsText)
{
NestTextNodes(lastNode, nextNode);
}
else
{
nextNode.SetParentForLoad(this);
}
}
if (insertEventArgsForLoad != null)
{
doc.AfterEvent(insertEventArgsForLoad);
}
return(nextNode);
}
public override XmlNode Item(int index)
{
XmlNode result = null;
if (this.Count <= index)
{
return(null);
}
if (index >= 0 && this.parent.LastLinkedChild != null)
{
XmlLinkedNode nextLinkedSibling = this.parent.LastLinkedChild.NextLinkedSibling;
int num = 0;
while (num < index && !object.ReferenceEquals(nextLinkedSibling, this.parent.LastLinkedChild))
{
nextLinkedSibling = nextLinkedSibling.NextLinkedSibling;
num++;
}
if (num == index)
{
result = nextLinkedSibling;
}
}
return(result);
}
internal override XmlNode AppendChildForLoad( XmlNode newChild, XmlDocument doc ) {
XmlNodeChangedEventArgs args = doc.GetInsertEventArgsForLoad( newChild, this );
if (args != null)
doc.BeforeEvent( args );
XmlLinkedNode newNode = (XmlLinkedNode) newChild;
if (lastChild == null || lastChild == emptyElem) {
newNode.next = newNode;
}
else {
newNode.next = lastChild.next;
lastChild.next = newNode;
}
lastChild = newNode;
newNode.SetParentForLoad( this );
if (args != null)
doc.AfterEvent( args );
return newNode;
}
//This should be used only to create the emptyElem as above.
private XmlElement(): base() {
this.name = null;
this.lastChild = null;
}
// Adds the specified node to the end of the list of children of this node.
public virtual XmlNode AppendChild(XmlNode newChild)
{
XmlDocument thisDoc = OwnerDocument;
if (thisDoc == null)
{
thisDoc = this as XmlDocument;
}
if (!IsContainer)
throw new InvalidOperationException(SR.Xdom_Node_Insert_Contain);
if (this == newChild || AncestorNode(newChild))
throw new ArgumentException(SR.Xdom_Node_Insert_Child);
if (newChild.ParentNode != null)
newChild.ParentNode.RemoveChild(newChild);
XmlDocument childDoc = newChild.OwnerDocument;
if (childDoc != null && childDoc != thisDoc && childDoc != this)
throw new ArgumentException(SR.Xdom_Node_Insert_Context);
// special case for doc-fragment.
if (newChild.NodeType == XmlNodeType.DocumentFragment)
{
XmlNode first = newChild.FirstChild;
XmlNode node = first;
while (node != null)
{
XmlNode next = node.NextSibling;
newChild.RemoveChild(node);
AppendChild(node);
node = next;
}
return first;
}
if (!(newChild is XmlLinkedNode) || !IsValidChildType(newChild.NodeType))
throw new InvalidOperationException(SR.Xdom_Node_Insert_TypeConflict);
if (!CanInsertAfter(newChild, LastChild))
throw new InvalidOperationException(SR.Xdom_Node_Insert_Location);
string newChildValue = newChild.Value;
XmlNodeChangedEventArgs args = GetEventArgs(newChild, newChild.ParentNode, this, newChildValue, newChildValue, XmlNodeChangedAction.Insert);
if (args != null)
BeforeEvent(args);
XmlLinkedNode refNode = LastNode;
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (refNode == null)
{
newNode.next = newNode;
LastNode = newNode;
newNode.SetParent(this);
}
else
{
newNode.next = refNode.next;
refNode.next = newNode;
LastNode = newNode;
newNode.SetParent(this);
if (refNode.IsText)
{
if (newNode.IsText)
{
NestTextNodes(refNode, newNode);
}
}
}
if (args != null)
AfterEvent(args);
return newNode;
}
// Removes specified child node.
public virtual XmlNode RemoveChild(XmlNode oldChild)
{
if (!IsContainer)
{
throw new InvalidOperationException(SR.Xdom_Node_Remove_Contain);
}
if (oldChild.ParentNode != this)
{
throw new ArgumentException(SR.Xdom_Node_Remove_Child);
}
XmlLinkedNode oldNode = (XmlLinkedNode)oldChild;
string oldNodeValue = oldNode.Value;
XmlNodeChangedEventArgs args = GetEventArgs(oldNode, this, null, oldNodeValue, oldNodeValue, XmlNodeChangedAction.Remove);
if (args != null)
{
BeforeEvent(args);
}
XmlLinkedNode lastNode = LastNode;
if (oldNode == FirstChild)
{
if (oldNode == lastNode)
{
LastNode = null;
oldNode.next = null;
oldNode.SetParent(null);
}
else
{
XmlLinkedNode nextNode = oldNode.next;
if (nextNode.IsText)
{
if (oldNode.IsText)
{
UnnestTextNodes(oldNode, nextNode);
}
}
lastNode.next = nextNode;
oldNode.next = null;
oldNode.SetParent(null);
}
}
else
{
if (oldNode == lastNode)
{
XmlLinkedNode prevNode = (XmlLinkedNode)oldNode.PreviousSibling;
prevNode.next = oldNode.next;
LastNode = prevNode;
oldNode.next = null;
oldNode.SetParent(null);
}
else
{
XmlLinkedNode prevNode = (XmlLinkedNode)oldNode.PreviousSibling;
XmlLinkedNode nextNode = oldNode.next;
if (nextNode.IsText)
{
if (prevNode.IsText)
{
NestTextNodes(prevNode, nextNode);
}
else
{
if (oldNode.IsText)
{
UnnestTextNodes(oldNode, nextNode);
}
}
}
prevNode.next = nextNode;
oldNode.next = null;
oldNode.SetParent(null);
}
}
if (args != null)
{
AfterEvent(args);
}
return(oldChild);
}
internal XmlLinkedNode(XmlDocument doc) : base(doc)
{
this.next = null;
}
public virtual XmlNode InsertBefore(XmlNode newChild, XmlNode refChild)
{
if ((this == newChild) || this.AncestorNode(newChild))
{
throw new ArgumentException(Res.GetString("Xdom_Node_Insert_Child"));
}
if (refChild == null)
{
return(this.AppendChild(newChild));
}
if (!this.IsContainer)
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_Contain"));
}
if (refChild.ParentNode != this)
{
throw new ArgumentException(Res.GetString("Xdom_Node_Insert_Path"));
}
if (newChild == refChild)
{
return(newChild);
}
XmlDocument ownerDocument = newChild.OwnerDocument;
XmlDocument document2 = this.OwnerDocument;
if (((ownerDocument != null) && (ownerDocument != document2)) && (ownerDocument != this))
{
throw new ArgumentException(Res.GetString("Xdom_Node_Insert_Context"));
}
if (!this.CanInsertBefore(newChild, refChild))
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_Location"));
}
if (newChild.ParentNode != null)
{
newChild.ParentNode.RemoveChild(newChild);
}
if (newChild.NodeType == XmlNodeType.DocumentFragment)
{
XmlNode firstChild = newChild.FirstChild;
XmlNode oldChild = firstChild;
if (oldChild != null)
{
newChild.RemoveChild(oldChild);
this.InsertBefore(oldChild, refChild);
this.InsertAfter(newChild, oldChild);
}
return(firstChild);
}
if (!(newChild is XmlLinkedNode) || !this.IsValidChildType(newChild.NodeType))
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_TypeConflict"));
}
XmlLinkedNode prevNode = (XmlLinkedNode)newChild;
XmlLinkedNode nextNode = (XmlLinkedNode)refChild;
string oldValue = newChild.Value;
XmlNodeChangedEventArgs args = this.GetEventArgs(newChild, newChild.ParentNode, this, oldValue, oldValue, XmlNodeChangedAction.Insert);
if (args != null)
{
this.BeforeEvent(args);
}
if (nextNode == this.FirstChild)
{
prevNode.next = nextNode;
this.LastNode.next = prevNode;
prevNode.SetParent(this);
if (prevNode.IsText && nextNode.IsText)
{
NestTextNodes(prevNode, nextNode);
}
}
else
{
XmlLinkedNode previousSibling = (XmlLinkedNode)nextNode.PreviousSibling;
prevNode.next = nextNode;
previousSibling.next = prevNode;
prevNode.SetParent(this);
if (previousSibling.IsText)
{
if (prevNode.IsText)
{
NestTextNodes(previousSibling, prevNode);
if (nextNode.IsText)
{
NestTextNodes(prevNode, nextNode);
}
}
else if (nextNode.IsText)
{
UnnestTextNodes(previousSibling, nextNode);
}
}
else if (prevNode.IsText && nextNode.IsText)
{
NestTextNodes(prevNode, nextNode);
}
}
if (args != null)
{
this.AfterEvent(args);
}
return(prevNode);
}
/// <include file='doc\XmlNode.uex' path='docs/doc[@for="XmlNode.InsertAfter"]/*' />
/// <devdoc>
/// <para>Inserts the specified node immediately after the specified reference node.</para>
/// </devdoc>
public virtual XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) {
if (this == newChild || AncesterNode(newChild))
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Child));
if (refChild == null)
return PrependChild(newChild);
if (!IsContainer)
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_Contain));
if (refChild.ParentNode != this)
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Path));
if (newChild == refChild)
return newChild;
XmlDocument childDoc = newChild.OwnerDocument;
XmlDocument thisDoc = OwnerDocument;
if (childDoc != null && childDoc != thisDoc && childDoc != this)
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Context));
if (!CanInsertAfter( newChild, refChild ))
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_Location));
if (newChild.ParentNode != null)
newChild.ParentNode.RemoveChild( newChild );
// special case for doc-fragment.
if (newChild.NodeType == XmlNodeType.DocumentFragment) {
XmlNode last = refChild;
XmlNode first = newChild.FirstChild;
XmlNode node = first;
while (node != null) {
XmlNode next = node.NextSibling;
newChild.RemoveChild( node );
InsertAfter( node, last );
last = node;
node = next;
}
return first;
}
if (!(newChild is XmlLinkedNode) || !IsValidChildType(newChild.NodeType))
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_TypeConflict));
XmlLinkedNode newNode = (XmlLinkedNode) newChild;
XmlLinkedNode refNode = (XmlLinkedNode) refChild;
XmlNodeChangedEventArgs args = GetEventArgs( newChild, newChild.ParentNode, this, XmlNodeChangedAction.Insert );
if (args != null)
BeforeEvent( args );
newNode.next = refNode.next;
refNode.next = newNode;
if (LastNode == refNode)
LastNode = newNode;
newNode.SetParent( this );
if (args != null)
AfterEvent( args );
return newNode;
}
/// <include file='doc\XmlNode.uex' path='docs/doc[@for="XmlNode.RemoveChild"]/*' />
/// <devdoc>
/// <para>Removes specified child node.</para>
/// </devdoc>
public virtual XmlNode RemoveChild(XmlNode oldChild) {
if (!IsContainer)
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Remove_Contain));
if (oldChild.ParentNode != this)
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Remove_Child));
XmlLinkedNode oldNode = (XmlLinkedNode) oldChild;
XmlNodeChangedEventArgs args = GetEventArgs( oldNode, this, null, XmlNodeChangedAction.Remove );
if (args != null)
BeforeEvent( args );
if (oldNode == FirstChild) {
if (LastNode.next == LastNode) {
LastNode = null;
}
else {
LastNode.next = (XmlLinkedNode) FirstChild.NextSibling;
}
}
else {
XmlLinkedNode prev = (XmlLinkedNode) oldNode.PreviousSibling;
prev.next = oldNode.next;
if (oldNode == LastNode)
LastNode = prev;
}
oldNode.next = null;
oldNode.SetParent( null );
if (args != null)
AfterEvent( args );
return oldChild;
}
internal Enumerator(IHasXmlChildNode parent)
{
this.currentChild = null;
this.parent = parent;
this.passedLastNode = false;
}
public virtual void Reset()
{
this.currentChild = null;
}
internal XmlNode RemoveChild(XmlNode oldChild, bool checkNodeType)
{
if (oldChild == null)
{
throw new NullReferenceException();
}
XmlDocument ownerDoc = (NodeType == XmlNodeType.Document) ? (XmlDocument)this : OwnerDocument;
if (oldChild.ParentNode != this)
{
throw new ArgumentException("The node to be removed is not a child of this node.");
}
if (checkNodeType)
{
ownerDoc.onNodeRemoving(oldChild, oldChild.ParentNode);
}
if (checkNodeType)
{
CheckNodeRemoval();
}
IHasXmlChildNode l = (IHasXmlChildNode)this;
if (Object.ReferenceEquals(l.LastLinkedChild, l.LastLinkedChild.NextLinkedSibling) && Object.ReferenceEquals(l.LastLinkedChild, oldChild))
{
// If there is only one children, simply clear.
l.LastLinkedChild = null;
}
else
{
XmlLinkedNode oldLinkedChild = (XmlLinkedNode)oldChild;
XmlLinkedNode beforeLinkedChild = l.LastLinkedChild;
XmlLinkedNode firstChild = (XmlLinkedNode)FirstChild;
while (Object.ReferenceEquals(beforeLinkedChild.NextLinkedSibling, l.LastLinkedChild) == false &&
Object.ReferenceEquals(beforeLinkedChild.NextLinkedSibling, oldLinkedChild) == false)
{
beforeLinkedChild = beforeLinkedChild.NextLinkedSibling;
}
if (Object.ReferenceEquals(beforeLinkedChild.NextLinkedSibling, oldLinkedChild) == false)
{
throw new ArgumentException();
}
beforeLinkedChild.NextLinkedSibling = oldLinkedChild.NextLinkedSibling;
// Each derived class may have its own l.LastLinkedChild, so we must set it explicitly.
if (oldLinkedChild.NextLinkedSibling == firstChild)
{
l.LastLinkedChild = beforeLinkedChild;
}
oldLinkedChild.NextLinkedSibling = null;
}
if (checkNodeType)
{
ownerDoc.onNodeRemoved(oldChild, oldChild.ParentNode);
}
oldChild.parentNode = null; // clear parent 'after' above logic.
return(oldChild);
}
internal XmlNode InsertBefore(XmlNode newChild, XmlNode refChild, bool checkNodeType, bool raiseEvent)
{
if (checkNodeType)
{
CheckNodeInsertion(newChild, refChild);
}
if (newChild == refChild)
{
return(newChild);
}
IHasXmlChildNode l = (IHasXmlChildNode)this;
XmlDocument ownerDoc = (NodeType == XmlNodeType.Document) ? (XmlDocument)this : OwnerDocument;
if (raiseEvent)
{
ownerDoc.onNodeInserting(newChild, this);
}
if (newChild.ParentNode != null)
{
newChild.ParentNode.RemoveChild(newChild, checkNodeType);
}
if (newChild.NodeType == XmlNodeType.DocumentFragment)
{
// This recursively invokes events. (It is compatible with MS implementation.)
XmlNode ret = null;
while (newChild.FirstChild != null)
{
var c = this.InsertBefore(newChild.FirstChild, refChild);
ret = ret ?? c;
}
return(ret);
}
else
{
XmlLinkedNode newLinkedChild = (XmlLinkedNode)newChild;
newLinkedChild.parentNode = this;
if (refChild == null)
{
// newChild is the last child:
// * set newChild as NextSibling of the existing lastchild
// * set LastChild = newChild
// * set NextSibling of newChild as FirstChild
if (l.LastLinkedChild != null)
{
XmlLinkedNode formerFirst = (XmlLinkedNode)FirstChild;
l.LastLinkedChild.NextLinkedSibling = newLinkedChild;
l.LastLinkedChild = newLinkedChild;
newLinkedChild.NextLinkedSibling = formerFirst;
}
else
{
l.LastLinkedChild = newLinkedChild;
l.LastLinkedChild.NextLinkedSibling = newLinkedChild; // FirstChild
}
}
else
{
// newChild is not the last child:
// * if newchild is first, then set next of lastchild is newChild.
// otherwise, set next of previous sibling to newChild
// * set next of newChild to refChild
XmlLinkedNode prev = refChild.PreviousSibling as XmlLinkedNode;
if (prev == null)
{
l.LastLinkedChild.NextLinkedSibling = newLinkedChild;
}
else
{
prev.NextLinkedSibling = newLinkedChild;
}
newLinkedChild.NextLinkedSibling = refChild as XmlLinkedNode;
}
switch (newChild.NodeType)
{
case XmlNodeType.EntityReference:
((XmlEntityReference)newChild).SetReferencedEntityContent();
break;
case XmlNodeType.Entity:
break;
case XmlNodeType.DocumentType:
break;
}
if (raiseEvent)
{
ownerDoc.onNodeInserted(newChild, newChild.ParentNode);
}
return(newChild);
}
}
//the function is provided only at Load time to speed up Load process
internal virtual XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc) {
XmlNodeChangedEventArgs args = doc.GetInsertEventArgsForLoad( newChild, this );
if (args != null)
doc.BeforeEvent( args );
XmlLinkedNode newNode = (XmlLinkedNode) newChild;
if (LastNode == null) {
newNode.next = newNode;
}
else {
newNode.next = LastNode.next;
LastNode.next = newNode;
}
LastNode = newNode;
newNode.SetParentForLoad( this );
if (args != null)
doc.AfterEvent( args );
return newNode;
}
public virtual void Reset()
{
currentChild = null;
}
internal XmlLinkedNode()
{
this.next = null;
}
internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
Debug.Assert(doc == this);
if (!IsValidChildType(newChild.NodeType))
throw new InvalidOperationException(SR.Xdom_Node_Insert_TypeConflict);
if (!CanInsertAfter(newChild, LastChild))
throw new InvalidOperationException(SR.Xdom_Node_Insert_Location);
XmlNodeChangedEventArgs args = GetInsertEventArgsForLoad(newChild, this);
if (args != null)
BeforeEvent(args);
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (_lastChild == null)
{
newNode.next = newNode;
}
else
{
newNode.next = _lastChild.next;
_lastChild.next = newNode;
}
_lastChild = newNode;
newNode.SetParentForLoad(this);
if (args != null)
AfterEvent(args);
return newNode;
}
public virtual XmlNode AppendChild(XmlNode newChild)
{
XmlDocument ownerDocument = this.OwnerDocument;
if (ownerDocument == null)
{
ownerDocument = this as XmlDocument;
}
if (!this.IsContainer)
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_Contain"));
}
if ((this == newChild) || this.AncestorNode(newChild))
{
throw new ArgumentException(Res.GetString("Xdom_Node_Insert_Child"));
}
if (newChild.ParentNode != null)
{
newChild.ParentNode.RemoveChild(newChild);
}
XmlDocument document2 = newChild.OwnerDocument;
if (((document2 != null) && (document2 != ownerDocument)) && (document2 != this))
{
throw new ArgumentException(Res.GetString("Xdom_Node_Insert_Context"));
}
if (newChild.NodeType == XmlNodeType.DocumentFragment)
{
XmlNode nextSibling;
XmlNode firstChild = newChild.FirstChild;
for (XmlNode node2 = firstChild; node2 != null; node2 = nextSibling)
{
nextSibling = node2.NextSibling;
newChild.RemoveChild(node2);
this.AppendChild(node2);
}
return(firstChild);
}
if (!(newChild is XmlLinkedNode) || !this.IsValidChildType(newChild.NodeType))
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_TypeConflict"));
}
if (!this.CanInsertAfter(newChild, this.LastChild))
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_Location"));
}
string oldValue = newChild.Value;
XmlNodeChangedEventArgs args = this.GetEventArgs(newChild, newChild.ParentNode, this, oldValue, oldValue, XmlNodeChangedAction.Insert);
if (args != null)
{
this.BeforeEvent(args);
}
XmlLinkedNode lastNode = this.LastNode;
XmlLinkedNode nextNode = (XmlLinkedNode)newChild;
if (lastNode == null)
{
nextNode.next = nextNode;
this.LastNode = nextNode;
nextNode.SetParent(this);
}
else
{
nextNode.next = lastNode.next;
lastNode.next = nextNode;
this.LastNode = nextNode;
nextNode.SetParent(this);
if (lastNode.IsText && nextNode.IsText)
{
NestTextNodes(lastNode, nextNode);
}
}
if (args != null)
{
this.AfterEvent(args);
}
return(nextNode);
}
internal XmlLinkedNode(XmlDocument doc) : base(doc)
{
this.next = null;
}
public virtual XmlNode RemoveChild(XmlNode oldChild)
{
if (!this.IsContainer)
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Remove_Contain"));
}
if (oldChild.ParentNode != this)
{
throw new ArgumentException(Res.GetString("Xdom_Node_Remove_Child"));
}
XmlLinkedNode node = (XmlLinkedNode)oldChild;
string oldValue = node.Value;
XmlNodeChangedEventArgs args = this.GetEventArgs(node, this, null, oldValue, oldValue, XmlNodeChangedAction.Remove);
if (args != null)
{
this.BeforeEvent(args);
}
XmlLinkedNode lastNode = this.LastNode;
if (node == this.FirstChild)
{
if (node == lastNode)
{
this.LastNode = null;
node.next = null;
node.SetParent(null);
}
else
{
XmlLinkedNode next = node.next;
if (next.IsText && node.IsText)
{
UnnestTextNodes(node, next);
}
lastNode.next = next;
node.next = null;
node.SetParent(null);
}
}
else if (node == lastNode)
{
XmlLinkedNode previousSibling = (XmlLinkedNode)node.PreviousSibling;
previousSibling.next = node.next;
this.LastNode = previousSibling;
node.next = null;
node.SetParent(null);
}
else
{
XmlLinkedNode prevNode = (XmlLinkedNode)node.PreviousSibling;
XmlLinkedNode nextNode = node.next;
if (nextNode.IsText)
{
if (prevNode.IsText)
{
NestTextNodes(prevNode, nextNode);
}
else if (node.IsText)
{
UnnestTextNodes(node, nextNode);
}
}
prevNode.next = nextNode;
node.next = null;
node.SetParent(null);
}
if (args != null)
{
this.AfterEvent(args);
}
return(oldChild);
}
internal XmlLinkedNode()
{
this.next = null;
}
// Inserts the specified node immediately after the specified reference node.
public virtual XmlNode InsertAfter(XmlNode newChild, XmlNode refChild)
{
if (this == newChild || AncestorNode(newChild))
{
throw new ArgumentException(SR.Xdom_Node_Insert_Child);
}
if (refChild == null)
{
return(PrependChild(newChild));
}
if (!IsContainer)
{
throw new InvalidOperationException(SR.Xdom_Node_Insert_Contain);
}
if (refChild.ParentNode != this)
{
throw new ArgumentException(SR.Xdom_Node_Insert_Path);
}
if (newChild == refChild)
{
return(newChild);
}
XmlDocument childDoc = newChild.OwnerDocument;
XmlDocument thisDoc = OwnerDocument;
if (childDoc != null && childDoc != thisDoc && childDoc != this)
{
throw new ArgumentException(SR.Xdom_Node_Insert_Context);
}
if (!CanInsertAfter(newChild, refChild))
{
throw new InvalidOperationException(SR.Xdom_Node_Insert_Location);
}
if (newChild.ParentNode != null)
{
newChild.ParentNode.RemoveChild(newChild);
}
// special case for doc-fragment.
if (newChild.NodeType == XmlNodeType.DocumentFragment)
{
XmlNode last = refChild;
XmlNode first = newChild.FirstChild;
XmlNode node = first;
while (node != null)
{
XmlNode next = node.NextSibling;
newChild.RemoveChild(node);
InsertAfter(node, last);
last = node;
node = next;
}
return(first);
}
if (!(newChild is XmlLinkedNode) || !IsValidChildType(newChild.NodeType))
{
throw new InvalidOperationException(SR.Xdom_Node_Insert_TypeConflict);
}
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
XmlLinkedNode refNode = (XmlLinkedNode)refChild;
string newChildValue = newChild.Value;
XmlNodeChangedEventArgs args = GetEventArgs(newChild, newChild.ParentNode, this, newChildValue, newChildValue, XmlNodeChangedAction.Insert);
if (args != null)
{
BeforeEvent(args);
}
if (refNode == LastNode)
{
newNode.next = refNode.next;
refNode.next = newNode;
LastNode = newNode;
newNode.SetParent(this);
if (refNode.IsText)
{
if (newNode.IsText)
{
NestTextNodes(refNode, newNode);
}
}
}
else
{
XmlLinkedNode nextNode = refNode.next;
newNode.next = nextNode;
refNode.next = newNode;
newNode.SetParent(this);
if (refNode.IsText)
{
if (newNode.IsText)
{
NestTextNodes(refNode, newNode);
if (nextNode.IsText)
{
NestTextNodes(newNode, nextNode);
}
}
else
{
if (nextNode.IsText)
{
UnnestTextNodes(refNode, nextNode);
}
}
}
else
{
if (newNode.IsText)
{
if (nextNode.IsText)
{
NestTextNodes(newNode, nextNode);
}
}
}
}
if (args != null)
{
AfterEvent(args);
}
return(newNode);
}
internal Enumerator (IHasXmlChildNode parent)
{
currentChild = null;
this.parent = parent;
passedLastNode = false;
}
// Removes specified child node.
public virtual XmlNode RemoveChild(XmlNode oldChild)
{
if (!IsContainer)
throw new InvalidOperationException(SR.Xdom_Node_Remove_Contain);
if (oldChild.ParentNode != this)
throw new ArgumentException(SR.Xdom_Node_Remove_Child);
XmlLinkedNode oldNode = (XmlLinkedNode)oldChild;
string oldNodeValue = oldNode.Value;
XmlNodeChangedEventArgs args = GetEventArgs(oldNode, this, null, oldNodeValue, oldNodeValue, XmlNodeChangedAction.Remove);
if (args != null)
BeforeEvent(args);
XmlLinkedNode lastNode = LastNode;
if (oldNode == FirstChild)
{
if (oldNode == lastNode)
{
LastNode = null;
oldNode.next = null;
oldNode.SetParent(null);
}
else
{
XmlLinkedNode nextNode = oldNode.next;
if (nextNode.IsText)
{
if (oldNode.IsText)
{
UnnestTextNodes(oldNode, nextNode);
}
}
lastNode.next = nextNode;
oldNode.next = null;
oldNode.SetParent(null);
}
}
else
{
if (oldNode == lastNode)
{
XmlLinkedNode prevNode = (XmlLinkedNode)oldNode.PreviousSibling;
prevNode.next = oldNode.next;
LastNode = prevNode;
oldNode.next = null;
oldNode.SetParent(null);
}
else
{
XmlLinkedNode prevNode = (XmlLinkedNode)oldNode.PreviousSibling;
XmlLinkedNode nextNode = oldNode.next;
if (nextNode.IsText)
{
if (prevNode.IsText)
{
NestTextNodes(prevNode, nextNode);
}
else
{
if (oldNode.IsText)
{
UnnestTextNodes(oldNode, nextNode);
}
}
}
prevNode.next = nextNode;
oldNode.next = null;
oldNode.SetParent(null);
}
}
if (args != null)
AfterEvent(args);
return oldChild;
}
//This should be used only to create the emptyElem as above.
private XmlElement() : base()
{
this.name = null;
this.lastChild = null;
}
/// <include file='doc\XmlNode.uex' path='docs/doc[@for="XmlNode.InsertBefore"]/*' />
/// <devdoc>
/// <para>Inserts the specified node immediately before the specified reference node.</para>
/// </devdoc>
public virtual XmlNode InsertBefore(XmlNode newChild, XmlNode refChild)
{
if (this == newChild || AncesterNode(newChild))
{
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Child));
}
if (refChild == null)
{
return(AppendChild(newChild));
}
if (!IsContainer)
{
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_Contain));
}
if (refChild.ParentNode != this)
{
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Path));
}
if (newChild == refChild)
{
return(newChild);
}
XmlDocument childDoc = newChild.OwnerDocument;
XmlDocument thisDoc = OwnerDocument;
if (childDoc != null && childDoc != thisDoc && childDoc != this)
{
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Context));
}
if (!CanInsertBefore(newChild, refChild))
{
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_Location));
}
if (newChild.ParentNode != null)
{
newChild.ParentNode.RemoveChild(newChild);
}
// special case for doc-fragment.
if (newChild.NodeType == XmlNodeType.DocumentFragment)
{
XmlNode first = newChild.FirstChild;
XmlNode node = first;
if (node != null)
{
newChild.RemoveChild(node);
InsertBefore(node, refChild);
// insert the rest of the children after this one.
InsertAfter(newChild, node);
}
return(first);
}
if (!(newChild is XmlLinkedNode) || !IsValidChildType(newChild.NodeType))
{
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_TypeConflict));
}
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
XmlLinkedNode refNode = (XmlLinkedNode)refChild;
XmlNodeChangedEventArgs args = GetEventArgs(newChild, newChild.ParentNode, this, XmlNodeChangedAction.Insert);
if (args != null)
{
BeforeEvent(args);
}
if (refNode == FirstChild)
{
newNode.next = (XmlLinkedNode)FirstChild;
LastNode.next = newNode;
}
else
{
XmlLinkedNode prev = (XmlLinkedNode)refNode.PreviousSibling;
newNode.next = refNode;
prev.next = newNode;
}
newNode.SetParent(this);
if (args != null)
{
AfterEvent(args);
}
return(newNode);
}
FrameworkElement FillLinkedNode(XmlLinkedNode linkedNode) {
StackPanel commonPanel = new StackPanel();
commonPanel.Orientation = Orientation.Vertical;
if (linkedNode.Value != null) {
commonPanel.Children.Add(FillSimpleValue(linkedNode));
} else {
Expander childExpander = new Expander();
childExpander.ExpandDirection = ExpandDirection.Down;
childExpander.Header = linkedNode.Name;
StackPanel childPanel = new StackPanel();
childPanel.Orientation = Orientation.Vertical;
linkedNode.ForEach(lnode => {
var res = lnode as System.Xml.XmlLinkedNode;
childPanel.Children.Add(FillLinkedNode(res));
});
if (childPanel.Children.Count == 1)
commonPanel.Children.Add(childPanel);
else {
childPanel.Margin = new Thickness(20, 0, 0, 0);
childExpander.Content = childPanel;
commonPanel.Children.Add(childExpander);
}
}
return commonPanel;
}
/// <include file='doc\XmlNode.uex' path='docs/doc[@for="XmlNode.AppendChild"]/*' />
/// <devdoc>
/// <para>Adds the specified node to the end of the list of children of
/// this node.</para>
/// </devdoc>
public virtual XmlNode AppendChild(XmlNode newChild)
{
XmlDocument thisDoc = OwnerDocument;
if (thisDoc == null)
{
thisDoc = this as XmlDocument;
}
if (!IsContainer)
{
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_Contain));
}
if (this == newChild || AncesterNode(newChild))
{
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Child));
}
if (newChild.ParentNode != null)
{
newChild.ParentNode.RemoveChild(newChild);
}
XmlDocument childDoc = newChild.OwnerDocument;
if (childDoc != null && childDoc != thisDoc && childDoc != this)
{
throw new ArgumentException(Res.GetString(Res.Xdom_Node_Insert_Context));
}
// special case for doc-fragment.
if (newChild.NodeType == XmlNodeType.DocumentFragment)
{
XmlNode first = newChild.FirstChild;
XmlNode node = first;
while (node != null)
{
XmlNode next = node.NextSibling;
newChild.RemoveChild(node);
AppendChild(node);
node = next;
}
return(first);
}
if (!(newChild is XmlLinkedNode) || !IsValidChildType(newChild.NodeType))
{
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_TypeConflict));
}
if (!CanInsertAfter(newChild, LastChild))
{
throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Insert_Location));
}
XmlNodeChangedEventArgs args = GetEventArgs(newChild, newChild.ParentNode, this, XmlNodeChangedAction.Insert);
if (args != null)
{
BeforeEvent(args);
}
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (LastNode == null)
{
newNode.next = newNode;
}
else
{
newNode.next = LastNode.next;
LastNode.next = newNode;
}
LastNode = newNode;
newNode.SetParent(this);
if (args != null)
{
AfterEvent(args);
}
return(newNode);
}
FrameworkElement FillSimpleValue(XmlLinkedNode linkedNode) {
StackPanel nsp = new StackPanel();
nsp.Orientation = Orientation.Horizontal;
nsp.Children.Add(new Label() { MinWidth = 100, Content = linkedNode.ParentNode.Name });
//TextBlock tb = new TextBlock();
//tb.MinWidth = 50;
//tb.CreateBinding(TextBlock.TextProperty, linkedNode, x => x.Value, (m, v) => { m.Value = v; });
nsp.Children.Add(new TextBox() { MinWidth = 50, Text = linkedNode.Value });
return nsp;
}
//the function is provided only at Load time to speed up Load process
internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc) {
XmlNodeChangedEventArgs args = doc.GetInsertEventArgsForLoad( newChild, this );
if (args != null)
doc.BeforeEvent( args );
XmlLinkedNode newNode = (XmlLinkedNode)newChild;
if (lastChild == null) { // if LastNode == null
newNode.next = newNode;
lastChild = newNode;
newNode.SetParentForLoad(this);
}
else {
XmlLinkedNode refNode = lastChild; // refNode = LastNode;
newNode.next = refNode.next;
refNode.next = newNode;
lastChild = newNode; // LastNode = newNode;
if (refNode.IsText
&& newNode.IsText) {
NestTextNodes(refNode, newNode);
}
else {
newNode.SetParentForLoad(this);
}
}
if (args != null)
doc.AfterEvent( args );
return newNode;
}
internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
{
if (!this.IsValidChildType(newChild.NodeType))
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_TypeConflict"));
}
if (!this.CanInsertAfter(newChild, this.LastChild))
{
throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_Location"));
}
XmlNodeChangedEventArgs insertEventArgsForLoad = this.GetInsertEventArgsForLoad(newChild, this);
if (insertEventArgsForLoad != null)
{
this.BeforeEvent(insertEventArgsForLoad);
}
XmlLinkedNode node = (XmlLinkedNode) newChild;
if (this.lastChild == null)
{
node.next = node;
}
else
{
node.next = this.lastChild.next;
this.lastChild.next = node;
}
this.lastChild = node;
node.SetParentForLoad(this);
if (insertEventArgsForLoad != null)
{
this.AfterEvent(insertEventArgsForLoad);
}
return node;
}