private void OnRemove(object o, XmlNodeChangedEventArgs e)
{
Assert.AreEqual(0, removeAllStep, "#1");
Assert.AreEqual("foo", e.Node.Name, "#2");
removeAllStep++;
}
public void OnInserted(object o, XmlNodeChangedEventArgs e)
{
Console.WriteLine("Inserted::: " + e.Node.NodeType + " into " + e.NewParent.NodeType + " Name: " + e.Node.Name + ", Value: " + e.Node.Value);
}
/// <summary>
/// Mark the file as modified if a node is changed
/// </summary>
/// <param name="sender">The sender of the event</param>
/// <param name="e">The event arguments</param>
private void Comments_NodeChanged(object sender, XmlNodeChangedEventArgs e)
{
wasModified = true;
}
private void EventNodeInserted(Object sender, XmlNodeChangedEventArgs e)
{
inserted = true;
}
internal NodeRemovedUndo(XmlNodeChangedEventArgs e, object previous)
{
removedNode = e.Node;
parentNode = e.OldParent;
nextSibling = previous as XmlNode;
}
internal NodeChangedUndo(XmlNodeChangedEventArgs e, object pValue)
{
oldValue = pValue as string;
node = e.Node;
}
void doc_NodeChanged(object sender, XmlNodeChangedEventArgs e)
{
MessageBox.Show("Node " + e.Node.Name + " changed successfully!");
}
public void OnChanging (object o, XmlNodeChangedEventArgs e)
{
Console.WriteLine ("Changing::: " + e.Node.NodeType);
}
private void OnNodeInserted(object o, XmlNodeChangedEventArgs e)
{
Inserted = true;
}
private void OnNodeRemoved(object o, XmlNodeChangedEventArgs e)
{
Removed = true;
}
private void XMLChangedEvent(object src, XmlNodeChangedEventArgs args)
{
this.IsChanged = true;
this._seitLetztemIsChangedAufDTDFehlergeprueft = false;
this.OnChangedEvent(EventArgs.Empty);
}
//// <summary>
///
/// </summary>
/// <param name="src"></param>
/// <param name="args"></param>
private void nodeUpdateEvent(Object src, XmlNodeChangedEventArgs args)
{
//保存设置
SaveXmlDocument();
}
// Track changes to the document that may affect the search order.
private void DocumentChanged(Object sender, XmlNodeChangedEventArgs args)
{
docChanged = true;
}
public void OnRemoving(object o, XmlNodeChangedEventArgs e)
{
Console.WriteLine("Removing::: " + e.Node.NodeType);
}
public void NodeChangedEvent(object src, XmlNodeChangedEventArgs args)
{
if (_isStatic || args.Node == null || args.NewParent == null)
{
return;
}
var comparer = StringComparison.OrdinalIgnoreCase;
var nodeType = args.Node.NodeType;
var parentNodeType = args.NewParent.NodeType;
// Attribute updates
// xmlns:xml is auto-inserted whenever a selectNode is performed, we don't want those events
if (nodeType == XmlNodeType.Text && parentNodeType == XmlNodeType.Attribute &&
!string.Equals(args.NewParent.Name, XmlConstants.XmlNamespacePrefix, comparer))
{
XmlAttribute attr = args.NewParent as XmlAttribute;
CssXmlElement elm = attr.OwnerElement as CssXmlElement;
if (elm != null)
{
elm.AttributeChange(attr, args);
}
}
else if (nodeType == XmlNodeType.Attribute &&
!string.Equals(args.Node.Name, XmlConstants.XmlNamespacePrefix, comparer))
{
// the cause of the change is a XmlAttribute => happens during inserting or removing
CssXmlElement oldElm = args.OldParent as CssXmlElement;
if (oldElm != null)
{
oldElm.AttributeChange(args.Node, args);
}
CssXmlElement newElm = args.NewParent as CssXmlElement;
if (newElm != null)
{
newElm.AttributeChange(args.Node, args);
}
}
// OnElementChange
if (nodeType == XmlNodeType.Text && parentNodeType == XmlNodeType.Element)
{
CssXmlElement element = (CssXmlElement)args.NewParent;
element.ElementChange(src, args);
}
else if (args.Node is CssXmlElement)
{
if (args.Action == XmlNodeChangedAction.Insert || args.Action == XmlNodeChangedAction.Change)
{
// Changes to a child XML node may affect the sibling offsets (for example in tspan)
// By calling the parent's OnElementChange, invalidation will propogate back to Node
CssXmlElement newParent = (CssXmlElement)args.NewParent;
newParent.ElementChange(src, args);
}
else if (args.Action == XmlNodeChangedAction.Remove)
{
// Removing a child XML node may affect the sibling offsets (for example in tspan)
CssXmlElement oldParent = (CssXmlElement)args.OldParent;
oldParent.ElementChange(src, args);
}
}
}
//Define the event handler.
void NodeTouchedHandler(object src, XmlNodeChangedEventArgs args)
{
//Debug.Log("Node " + args.Node.Name + " action:"+args.Action);
if (FsmEventTarget==null || ! delegationActive)
{
return;
}
if(args.Action == XmlNodeChangedAction.Insert)
{
PlayMakerUtils.SendEventToGameObject(FsmEventTarget,FsmEventTarget.gameObject,"XML / INSERTED");
}else if(args.Action == XmlNodeChangedAction.Change)
{
PlayMakerUtils.SendEventToGameObject(FsmEventTarget,FsmEventTarget.gameObject,"XML / CHANGED");
}else if(args.Action == XmlNodeChangedAction.Remove)
{
PlayMakerUtils.SendEventToGameObject(FsmEventTarget,FsmEventTarget.gameObject,"XML / REMOVED");
}
}
public override void ElementChange(Object src, XmlNodeChangedEventArgs args)
{
Invalidate();
base.ElementChange(src, args);
}
private void elementChangeEvent(Object src, XmlNodeChangedEventArgs args)
{
lastSrc = src;
lastNode = args.Node;
lastAction = args.Action;
}
void _TranslateConfig_NodeChanged(object sender, XmlNodeChangedEventArgs e)
{
_ConfigChanged = true;
}
static internal object PreviousState(XmlNodeChangedEventArgs e)
{
return(e.Node.NextSibling);
}
/// <summary>
/// Called when any parent element is changing. If an element is moved the CSS heirarchy for that element
/// will need to change.
/// </summary>
public virtual void ParentNodeChange(Object src, XmlNodeChangedEventArgs args)
{
FireParentNodeChange(src, args, true);
}
static internal object PreviousState(XmlNodeChangedEventArgs e)
{
return(e.Node.Value);
}
/// <summary>
/// Called when any child node is changing. If an element is moved the CSS heirarchy for that element
/// will need to change. This is mainly useful when one of the child nodes parent is a
/// referenced node (for example in a <use> element.
/// </summary>
public virtual void ChildNodeChange(object src, XmlNodeChangedEventArgs args)
{
FireChildNodeChange(src, args, true);
}
// Watch for change events.
private void WatchBefore(Object sender, XmlNodeChangedEventArgs args)
{
AssertEquals("Sender", expectedNode.OwnerDocument, sender);
AssertEquals
("Action", XmlNodeChangedAction.Change, args.Action);
AssertEquals("Node", expectedNode, args.Node);
AssertEquals("OldParent", expectedNode.ParentNode,
args.OldParent);
AssertEquals("NewParent", expectedNode.ParentNode,
args.NewParent);
++changeBefore;
}
public void OnReferencedNodeChange(object src, XmlNodeChangedEventArgs args)
{
//TODO - This is getting called too often!
//instanceRoot = null;
}
private void OnChange(object o, XmlNodeChangedEventArgs e)
{
Assert.Fail("Should not be called.");
}
private void EventNodeChanging(Object sender, XmlNodeChangedEventArgs e)
{
changing = true;
}
private void EventNodeRemoved(Object sender, XmlNodeChangedEventArgs e)
{
removed = true;
}
private void XmlDocument_NodeChanging(object sender, XmlNodeChangedEventArgs e)
{
}
public void OnChanged(object o, XmlNodeChangedEventArgs e)
{
Console.WriteLine("Changed::: " + e.Node.NodeType);
}
private void XmlDocument_NodeChanged(object sender, XmlNodeChangedEventArgs e)
{
_dirty = true;
}
private void elementChangeEvent(Object src, XmlNodeChangedEventArgs args)
{
lastSrc = src;
lastNode = args.Node;
lastAction = args.Action;
}
public NodeInsertedUndo(XmlNodeChangedEventArgs e, object previous)
{
iNode = e.Node;
}
public void OnInserted (object o, XmlNodeChangedEventArgs e)
{
Console.WriteLine ("Inserted::: " + e.Node.NodeType + " into " + e.NewParent.NodeType + " Name: " + e.Node.Name + ", Value: " + e.Node.Value);
}
static internal object PreviousState(XmlNodeChangedEventArgs e)
{
return(null);
}
public void OnRemoved (object o, XmlNodeChangedEventArgs e)
{
Console.WriteLine ("Removed::: " + e.Node.NodeType);
}
private void OnRemovedLog(object o, XmlNodeChangedEventArgs e)
{
eventLogBuilder.Append("Removed: " + e.Node.NodeType + " from " + e.OldParent.NodeType + ".\n");
}
