internal virtual void AfterEvent(XmlNodeChangedEventArgs args)
 {
     if (args != null)
     {
         this.OwnerDocument.AfterEvent(args);
     }
 }

        private void AttributeChange(Object src, XmlNodeChangedEventArgs args)
        {
            XmlAttribute attribute = src as XmlAttribute;

            if(attribute.LocalName == "externalResourcesRequired")
            {
                externalResourcesRequired = null;
            }
        }

 private void OnListChanged( object sender, XmlNodeChangedEventArgs args ) {
     if( atomized == false ) {
         this.localName = this.rootNode.Document.NameTable.Add( this.localName );
         this.namespaceURI = this.rootNode.Document.NameTable.Add( this.namespaceURI );
         this.atomized = true;
     }                
     if ( IsMatch( args.Node ) ) {
         this.changeCount++ ;
         this.curInd = -1;
         this.curElem = rootNode;
         if( args.Action == XmlNodeChangedAction.Insert )
             this.empty = false;
     }
 }

 internal void ConcurrencyCheck(XmlNodeChangedEventArgs args){
     if( atomized == false ) {
         XmlNameTable nameTable = this.rootNode.Document.NameTable;
         this.localName = nameTable.Add( this.localName );
         this.namespaceURI = nameTable.Add( this.namespaceURI );
         this.atomized = true;
     }                
     if ( IsMatch( args.Node ) ) {
         this.changeCount++ ;
         this.curInd = -1;
         this.curElem = rootNode;
         if( args.Action == XmlNodeChangedAction.Insert )
             this.empty = false;
     }
     this.matchCount = -1;
 }

        private void AttributeChange(Object src, XmlNodeChangedEventArgs args)
        {
            XmlAttribute attribute = src as XmlAttribute;

            if(attribute.NamespaceURI.Length == 0)
            {
                switch(attribute.LocalName)
                {
                    case "viewBox":
                        viewBox = null;
                        break;
                    case "preserveAspectRatio":
                        preserveAspectRatio = null;
                        break;
                }
            }
        }

 internal void ConcurrencyCheck(XmlNodeChangedEventArgs args)
 {
     if (_atomized == false)
     {
         XmlNameTable nameTable = _rootNode.Document.NameTable;
         _localName = nameTable.Add(_localName);
         _namespaceURI = nameTable.Add(_namespaceURI);
         _atomized = true;
     }
     if (IsMatch(args.Node))
     {
         _changeCount++;
         _curInd = -1;
         _curElem = _rootNode;
         if (args.Action == XmlNodeChangedAction.Insert)
             _empty = false;
     }
     _matchCount = -1;
 }

		private void HandleNodeChanged(object sender, XmlNodeChangedEventArgs ea)
		{
			if (ea.Action == XmlNodeChangedAction.Change && ea.NewValue == ea.OldValue)
			{
				// A void change can be ignored.
				//
				return;
			}

			if (_changedNodes == null)
				_changedNodes = new Stack();

			_changedNodes.Push(new XmlNodeTrackBack(ea));

			// Propagate changes to parent object, if set.
			//
			if (_parent != null)
				_parent.OnPropertyChanged(_propertyInfo);
		}

 private void OnListChanged(object sender, XmlNodeChangedEventArgs args)
 {
     lock (this)
     {
         if (this.elemList != null)
         {
             XmlElementList target = (XmlElementList) this.elemList.Target;
             if (target != null)
             {
                 target.ConcurrencyCheck(args);
             }
             else
             {
                 this.doc.NodeInserted -= this.nodeChangeHandler;
                 this.doc.NodeRemoved -= this.nodeChangeHandler;
                 this.elemList = null;
             }
         }
     }
 }

        /// <summary>
        /// Called when any attribute is changing. This is typically triggered by calls to 
        /// setAttribute() and should only be called from the CssXmlDocument.
        /// </summary>
        /// <see cref="CssXmlDocument"/>
        public virtual void AttributeChange(Object src, XmlNodeChangedEventArgs args)
        {
            // Invalidate the CSS, the cascade for the CSS heirarchy will need to be recomputed
              // We do this before and after the change because we need to invalidate the old and new locations
              CssInvalidate();

              XmlAttribute attribute = src as XmlAttribute;

              if(attribute != null)
              {
            HandleAttributeChange(attribute);
              }

              // Notify any listeners
              FireAttributeChange(src, args);
              FireParentNodeChange(src, args, false);
              FireChildNodeChange(src, args, false);

              // Invalidate the CSS, the cascade for the CSS heirarchy will need to be recomputed
              CssInvalidate();
        }

 internal NodeRemovedUndo(XmlNodeChangedEventArgs e, object previous)
 {
     removedNode = e.Node;
     parentNode = e.OldParent;
     nextSibling = previous as XmlNode;
 }

		static internal object PreviousState(XmlNodeChangedEventArgs e)
		{
			return null;
		}

 public NodeInsertedUndo(XmlNodeChangedEventArgs e, object previous)
 {
     iNode = e.Node;
 }

		private void NodeChanged(object sender, XmlNodeChangedEventArgs e)
		{
			if (this._Undoing)
			{
				// if we're undoing ignore the event since it is the result of an undo
				_pState = null;
				_Undoing = false;
				return;
			}

			UndoItem undo = null;
			switch (e.Action)
			{
				case XmlNodeChangedAction.Insert:
					undo = new NodeInsertedUndo(e, _pState);
					break;
				case XmlNodeChangedAction.Remove:
					undo = new NodeRemovedUndo(e, _pState);
					break;
				case XmlNodeChangedAction.Change:
					undo = new NodeChangedUndo(e, _pState);
					break;
				default:
					throw new Exception("Unknown Action");
			}
			_pState = null;
			if (_currentUndoGroup != null)
			{
				_currentUndoGroup.AddUndoItem(undo);
			}
			else if (GroupsOnly)
			{
				_pState = null;
			}
			else
			{
				_actions.Push(undo);
			}
		}

		private void EventNodeChanging (Object sender, XmlNodeChangedEventArgs e)
		{
			changing = true;
		}

        protected void NodeRemoved(object sender, XmlNodeChangedEventArgs e)
        {
            XmlAttribute attr=GetAttributeFromEvent(e);
            if ( attr != null )
            {
                if ( e.OldParent != null && XmlUtil.HasAncestor(e.OldParent, attr.OwnerDocument.DocumentElement) )
                {
                    ValidateRemovedAttribute((XmlElement) e.OldParent, attr);
                    RemoveIdOrIdRef((XmlElement) e.OldParent, attr);
                }
                return;
            }

            switch ( e.Node.NodeType )
            {
                case XmlNodeType.Element:
                case XmlNodeType.EntityReference:
                    // remove this node and any child nodes
                    RecursiveRemove(e.Node);
                    XmlElement p=e.OldParent as XmlElement;
                    if ( p == null )
                        // go up dealing with entity references
                        p=XmlUtil.GetParentNode(e.Node) as XmlElement;

                    if ( p != null )
                        Validate(p);

                    break;

                default:
                    // any other cases?
                    break;
            }
        }

        protected void NodeInserted(object sender, XmlNodeChangedEventArgs e)
        {
            XmlAttribute attr=GetAttributeFromEvent(e);
            if ( attr != null )
            {
                // we deal with attributes differently
                if ( attr.OwnerElement != null && XmlUtil.HasAncestor(attr.OwnerElement, attr.OwnerDocument.DocumentElement) )
                    // owner element is part of doc, so validate
                    ValidateAttributeAddOrChange(attr);

                return;
            }

            Console.WriteLine("Node {0} inserted", e.Node.Name);

            if ( !XmlUtil.HasAncestor(e.NewParent, e.NewParent.OwnerDocument.DocumentElement) )
            {
                Console.WriteLine("Insert of {0} under {1}, is not part of doc", e.Node.Name, e.NewParent.Name);
                // new parent is not part of doc
                return;
            }

            XmlElement p=e.NewParent as XmlElement;
            if ( p == null )
                // must be entity reference
                p=(XmlElement) XmlUtil.GetParentNode(e.NewParent);

            RemoveValidationErrors(new ContextErrorFilter(e.Node));
            Console.WriteLine("Validating parent node {0}", e.NewParent.Name);
            Validate(p);

            XmlElement elem=e.Node as XmlElement;
            if ( elem != null )
                RecursiveInsert(elem);

            if ( e.OldParent != null )
                Validate((XmlElement) e.OldParent);
        }

        protected void NodeChanging(object sender, XmlNodeChangedEventArgs e)
        {
            // we're only interested in attribute nodes
            XmlAttribute attr=GetAttributeFromEvent(e);
            if ( attr == null || !XmlUtil.HasAncestor(attr.OwnerElement, attr.OwnerDocument.DocumentElement) )
                // attribute's parent is not part of the document
                return;

            RemoveIdOrIdRef(attr.OwnerElement, attr);
        }

        protected void NodeChanged(object sender, XmlNodeChangedEventArgs e)
        {
            // Fired when XmlNode.Value is changed
            // The only types that have non-null Value are:
            //	- Attribute (special case)
            //	- CDATASection (not significant for validation)
            //	- Comment (not significant for validation)
            //	- ProcessingInstruction (not significant for validation)
            //	- Text (not significant for validation when changed)
            //	- [Significant]Whitespace (not significant for validation)
            //	- XmlDeclaration (not significant for validation)

            Console.WriteLine("Node {0} changed", e.Node.Name);

            XmlAttribute attr=GetAttributeFromEvent(e);

            if ( attr == null || !XmlUtil.HasAncestor(attr.OwnerElement, attr.OwnerDocument.DocumentElement) )
                // attribute's parent is not part of the document
                return;

            ValidateAttributeAddOrChange(attr);
        }

        /// <summary>
        /// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
        /// <example>
        /// xmlnodechangedeventhandler.BeginInvoke(sender, e, callback);
        /// </example>
        /// </summary>
        public static IAsyncResult BeginInvoke(this XmlNodeChangedEventHandler xmlnodechangedeventhandler, Object sender, XmlNodeChangedEventArgs e, AsyncCallback callback)
        {
            if(xmlnodechangedeventhandler == null) throw new ArgumentNullException("xmlnodechangedeventhandler");

            return xmlnodechangedeventhandler.BeginInvoke(sender, e, callback, null);
        }

        private void AttributeChange(Object src, XmlNodeChangedEventArgs args)
        {
            XmlAttribute attribute = src as XmlAttribute;

            if (attribute.NamespaceURI == SvgDocument.XLinkNamespace &&
                attribute.LocalName == "href")
            {
                href = null;
                absoluteUri = null;
            }
        }