internal XmlElementListListener(XmlDocument doc, XmlElementList elemList)
{
_doc = doc;
_elemList = new WeakReference(elemList);
_nodeChangeHandler = new XmlNodeChangedEventHandler(this.OnListChanged);
doc.NodeInserted += _nodeChangeHandler;
doc.NodeRemoved += _nodeChangeHandler;
}
internal XmlElementListListener(XmlDocument doc, XmlElementList elemList)
{
this.doc = doc;
this.elemList = new WeakReference(elemList);
this.nodeChangeHandler = new XmlNodeChangedEventHandler(this.OnListChanged);
doc.NodeInserted += this.nodeChangeHandler;
doc.NodeRemoved += this.nodeChangeHandler;
}
//
// Protected Methods
//
/// <summary>
/// Listen to the given source for the event.
/// </summary>
protected override void StartListening(object source)
{
XmlNodeChangedEventHandler handler = new XmlNodeChangedEventHandler(OnXmlNodeChanged);
XmlDocument doc = (XmlDocument)source;
doc.NodeInserted += handler;
doc.NodeRemoved += handler;
doc.NodeChanged += handler;
}
private void setupNodeChangeListeners()
{
XmlNodeChangedEventHandler handler = new XmlNodeChangedEventHandler(NodeChangedEvent);
NodeChanged += handler;
NodeInserted += handler;
//NodeRemoving += handler;
NodeRemoved += handler;
}
/// <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));
}
/// <summary>
/// Stop listening to the given source for the event.
/// </summary>
protected override void StopListening(object source)
{
XmlNodeChangedEventHandler handler = new XmlNodeChangedEventHandler(OnXmlNodeChanged);
XmlDocument doc = (XmlDocument)source;
doc.NodeInserted -= handler;
doc.NodeRemoved -= handler;
doc.NodeChanged -= handler;
}
protected virtual void OnBeforeNodeChange(XmlNodeChangedEventArgs e)
{
XmlNodeChangedEventHandler eh = Events[EVENT_BEFORENODECHANGE] as XmlNodeChangedEventHandler;
if (eh != null)
{
eh(this, e);
}
}
protected virtual void OnAfterNodeChange(XmlNodeChangedEventArgs e)
{
XmlNodeChangedEventHandler eh = Events[EVENT_AFTERNODECHANGE] as XmlNodeChangedEventHandler;
if (eh != null)
{
eh(this, e);
}
}
public EditableXmlDocument(XmlDocument value)
{
_changedNodes = null;
_handler = HandleNodeChanged;
_current = value;
_original = value;
StartXmlDocTracking();
}
public EditableXmlDocument(XmlDocument value)
{
_changedNodes = null;
_handler = HandleNodeChanged;
_current = value;
_original = value;
StartXmlDocTracking();
}
// Token: 0x0600774E RID: 30542 RVA: 0x002217D4 File Offset: 0x0021F9D4
protected override void StopListening(object source)
{
XmlNodeChangedEventHandler value = new XmlNodeChangedEventHandler(this.OnXmlNodeChanged);
XmlDocument xmlDocument = (XmlDocument)source;
xmlDocument.NodeInserted -= value;
xmlDocument.NodeRemoved -= value;
xmlDocument.NodeChanged -= value;
}
public Document()
{
eventTarget = new EventTarget(this);
NodeChanged += new XmlNodeChangedEventHandler(WhenNodeChanged);
NodeChanging += new XmlNodeChangedEventHandler(WhenNodeChanging);
NodeInserted += new XmlNodeChangedEventHandler(WhenNodeInserted);
NodeInserting += new XmlNodeChangedEventHandler(WhenNodeInserting);
NodeRemoved += new XmlNodeChangedEventHandler(WhenNodeRemoved);
NodeRemoving += new XmlNodeChangedEventHandler(WhenNodeRemoving);
}
public Document()
{
eventTarget = new EventTarget(this);
NodeChanged += new XmlNodeChangedEventHandler(WhenNodeChanged);
NodeChanging += new XmlNodeChangedEventHandler(WhenNodeChanging);
NodeInserted += new XmlNodeChangedEventHandler(WhenNodeInserted);
NodeInserting += new XmlNodeChangedEventHandler(WhenNodeInserting);
NodeRemoved += new XmlNodeChangedEventHandler(WhenNodeRemoved);
NodeRemoving += new XmlNodeChangedEventHandler(WhenNodeRemoving);
}
public static void RemoveEventHandler()
{
var xmlDocument = new XmlDocument();
var node = xmlDocument.CreateElement("element");
XmlNodeChangedEventHandler handler = (s, e) => { throw new ShouldNotBeInvokedException(); };
xmlDocument.NodeInserted += handler;
xmlDocument.NodeInserted -= handler;
node.InnerText = "some text";
}
public static void RemoveEventHandler()
{
var xmlDocument = new XmlDocument();
var node = xmlDocument.CreateElement("element");
XmlNodeChangedEventHandler handler = (s, e) => Assert.True(false, "Handler should have been removed");
xmlDocument.NodeInserted += handler;
xmlDocument.NodeInserted -= handler;
node.InnerText = "some text";
}
public static void RemoveEventHandler()
{
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(@"<root> <elem1>text1</elem1> <elem2>text2</elem2> </root>");
XmlNodeChangedEventHandler handler = (s, e) => Assert.True(false, "Handler should have been removed");
xmlDocument.NodeChanged += handler;
xmlDocument.NodeChanged -= handler;
xmlDocument.DocumentElement.FirstChild.InnerText = "newvalue";
}
public static void RemoveEventHandler()
{
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(@"<root> <elem1>text1</elem1> <elem2>text2</elem2> </root>");
XmlNodeChangedEventHandler handler = (s, e) => { throw new ShouldNotBeInvokedException(); };
xmlDocument.NodeChanged += handler;
xmlDocument.NodeChanged -= handler;
xmlDocument.DocumentElement.FirstChild.InnerText = "newvalue";
}
public void LoadXML(XmlDocument d)
{
XmlNodeChangedEventHandler nodeChangedHandler;
foreach (XmlType node in d.DocumentElement.ChildNodes)
{
Items.Add(new TerrainListViewItem(node));
}
nodeChangedHandler = new XmlNodeChangedEventHandler(NodeChanged);
d.NodeChanged += nodeChangedHandler;
d.NodeRemoved += nodeChangedHandler;
}
static void Main(string[] args)
{
//XmlNode -> XmlDocument
XmlDocument xmlDokumentum = new XmlDocument();
//stream-bol olvas
xmlDokumentum.Load("teszt.xml");
//sztring-bol olvas
//xmlDokumentum.LoadXml(@"<?xml version=""1.0"" encoding=""utf - 8"" ?>
// <list>
// <item>1</item>
// <item>2</item>
// <item>3</item>
// </list>");
foreach (XmlNode csomopont in xmlDokumentum.ChildNodes)
{
//HasChildNodes property is van, leteznek-e gyerekek
Console.WriteLine(csomopont.Name);
}
xmlDokumentum = new XmlDocument();
//XmlDocument esemenyeket is szolgaltat
XmlNodeChangedEventHandler lekezelo = null;
lekezelo = (sender, e) =>
{
Console.WriteLine("Node.Name: " + e.Node.Name);
Console.WriteLine("Node.Value: " + e.Node.Value);
};
xmlDokumentum.NodeInserting += lekezelo;
//XmlNode -> XmlElement, XmlText
XmlElement element = xmlDokumentum.CreateElement("Elem");
XmlText text = xmlDokumentum.CreateTextNode("szoveg elemben");
XmlNode node = xmlDokumentum.AppendChild(element);
node.AppendChild(text);
xmlDokumentum.Save("domteszt.xml");//<Elem>szoveg elemben</Elem>
//csucs klonozasa
XmlNode forras = xmlDokumentum.CreateNode(XmlNodeType.Element, "teszt", "nevterURI_teszt");
//CloneNode(bool deep) - gyerekeket is masoljuk-e
XmlNode destination = forras.CloneNode(false);
//van RemoveChild, ReplaceChild is
}
[Category("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=336180
#endif
public void SetInnerTextAndXml()
{
string original = doc.OuterXml;
doc.LoadXml("<root name='value' />");
XmlAttribute attr = doc.DocumentElement.Attributes ["name"];
attr.InnerText = "a&b";
Assert.AreEqual("a&b", attr.Value, "setInnerText");
attr.InnerXml = "a&b";
Assert.AreEqual("a&b", attr.Value, "setInnerXml");
attr.InnerXml = "'a&b'";
Assert.AreEqual("'a&b'", attr.InnerXml, "setInnerXml.InnerXml");
Assert.AreEqual("'a&b'", attr.Value, "setInnerXml.Value");
attr.InnerXml = "\"a&b\"";
Assert.AreEqual("\"a&b\"", attr.InnerXml, "Double_Quote");
attr.InnerXml = "\"a&b'";
Assert.AreEqual("\"a&b'", attr.InnerXml, "DoubleQuoteStart_SingleQuoteEnd");
attr.Value = string.Empty;
XmlNodeChangedEventHandler evInserted = new XmlNodeChangedEventHandler(EventNodeInserted);
XmlNodeChangedEventHandler evChanged = new XmlNodeChangedEventHandler(EventNodeChanged);
XmlNodeChangedEventHandler evRemoved = new XmlNodeChangedEventHandler(EventNodeRemoved);
doc.NodeInserted += evInserted;
doc.NodeChanged += evChanged;
doc.NodeRemoved += evRemoved;
try
{
// set_InnerText event
attr.InnerText = "fire";
Assert.IsFalse(inserted, "setInnerText.NodeInserted");
Assert.IsTrue(changed, "setInnerText.NodeChanged");
Assert.IsFalse(removed, "setInnerText.NodeRemoved");
inserted = changed = removed = false;
// set_InnerXml event
attr.InnerXml = "fire";
Assert.IsTrue(inserted, "setInnserXml.NodeInserted");
Assert.IsFalse(changed, "setInnserXml.NodeChanged");
Assert.IsTrue(removed, "setInnserXml.NodeRemoved");
inserted = changed = removed = false;
}
finally
{
doc.NodeInserted -= evInserted;
doc.NodeChanged -= evChanged;
doc.NodeRemoved -= evRemoved;
}
}
public override void Load(XmlReader reader)
{
XmlNodeChangedEventHandler insertHandler =
new XmlNodeChangedEventHandler(XhtmlDocument_NodeInserted);
byHtmlId.Clear();
NodeInserted += insertHandler;
try
{
base.Load(reader);
}
finally
{
NodeInserted -= insertHandler;
}
}
// Token: 0x06007BB7 RID: 31671 RVA: 0x0022BFE0 File Offset: 0x0022A1E0
private void RegisterForElement(XmlElement element)
{
if (element == null)
{
return;
}
if (!this._xmlDocsRefCounts.ContainsKey(element.OwnerDocument))
{
this._xmlDocsRefCounts[element.OwnerDocument] = 1;
XmlNodeChangedEventHandler value = new XmlNodeChangedEventHandler(this.OnNodeChanged);
element.OwnerDocument.NodeChanged += value;
element.OwnerDocument.NodeInserted += value;
element.OwnerDocument.NodeRemoved += value;
return;
}
Dictionary <XmlDocument, int> xmlDocsRefCounts = this._xmlDocsRefCounts;
XmlDocument ownerDocument = element.OwnerDocument;
int num = xmlDocsRefCounts[ownerDocument];
xmlDocsRefCounts[ownerDocument] = num + 1;
}
public UndoManager(WixFiles wixFiles, XmlDocument wxsDocument)
{
undoCommands = new ArrayList();
redoCommands = new ArrayList();
beginNewCommandRange = true;
this.wxsDocument = wxsDocument;
this.wixFiles = wixFiles;
this.docIsSavedUndoCount = 0;
nodeChangedHandler = new XmlNodeChangedEventHandler(OnNodeChanged);
nodeChangingHandler = new XmlNodeChangedEventHandler(OnNodeChanging);
nodeInsertedHandler = new XmlNodeChangedEventHandler(OnNodeInserted);
nodeRemovingHandler = new XmlNodeChangedEventHandler(OnNodeRemoving);
this.wxsDocument.NodeChanged += nodeChangedHandler;
this.wxsDocument.NodeChanging += nodeChangingHandler;
this.wxsDocument.NodeInserted += nodeInsertedHandler;
this.wxsDocument.NodeRemoving += nodeRemovingHandler;
timeCheck = DateTime.Now;
}
/// <summary>
/// Register for change notifications for this element. In
/// reality we regiser on the OwnerDocument, so we keep a count
/// of all the elements from a particular docuemnt we are listening
/// for. If that ref count gets to zero we unregister from the
/// document.
/// </summary>
/// <param name="element">the element to register for</param>
private void RegisterForElement(XmlElement element)
{
// Nulls may exist in the collection in which case we don't need to register
if (element == null)
{
return;
}
if (!_xmlDocsRefCounts.ContainsKey(element.OwnerDocument))
{
// If we aren't register on this document yet, register
// and initialize the reference count to 1.
_xmlDocsRefCounts[element.OwnerDocument] = 1;
XmlNodeChangedEventHandler handler = new XmlNodeChangedEventHandler(OnNodeChanged);
element.OwnerDocument.NodeChanged += handler;
element.OwnerDocument.NodeInserted += handler;
element.OwnerDocument.NodeRemoved += handler;
}
else
{
// Increase the reference count
_xmlDocsRefCounts[element.OwnerDocument]++;
}
}
//open
private static void open()
{
//is parameter fileName null or empty
if (fileName == null | fileName == string.Empty)
{
throwParameterNullException("fileName");
}
data = new XmlDocument();
// if file exsist load, if not create
if (File.Exists(fileName))
{
try
{
data.Load(fileName);
}
catch(XmlException ex)
{
throwXmlFormatException(ex);
}
}
else
{
data.AppendChild(data.CreateElement(RES_RootName));
root = new SettingsKey(data.DocumentElement,true);
}
//set rootkey to readonly
root = new SettingsKey(data.DocumentElement,true);
//set handlers
XmlNodeChangedEventHandler handler = new XmlNodeChangedEventHandler(handleChanges);
data.NodeChanged += handler;
data.NodeInserted += handler;
data.NodeRemoved += handler;
//set dirty flag
hasChanges = false;
//set Open
isOpen = true;
}
private void BindToDocument()
{
if (!_fBoundToDocument)
{
NodeInserting += new XmlNodeChangedEventHandler(OnNodeInserting);
NodeInserted += new XmlNodeChangedEventHandler(OnNodeInserted);
NodeRemoving += new XmlNodeChangedEventHandler(OnNodeRemoving);
NodeRemoved += new XmlNodeChangedEventHandler(OnNodeRemoved);
NodeChanging += new XmlNodeChangedEventHandler(OnNodeChanging);
NodeChanged += new XmlNodeChangedEventHandler(OnNodeChanged);
_fBoundToDocument = true;
}
}
[Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=336180
public void SetInnerTextAndXml ()
{
string original = doc.OuterXml;
doc.LoadXml ("<root name='value' />");
XmlAttribute attr = doc.DocumentElement.Attributes ["name"];
attr.InnerText = "a&b";
Assert.AreEqual ("a&b", attr.Value, "setInnerText");
attr.InnerXml = "a&b";
Assert.AreEqual ("a&b", attr.Value, "setInnerXml");
attr.InnerXml = "'a&b'";
Assert.AreEqual ("'a&b'", attr.InnerXml, "setInnerXml.InnerXml");
Assert.AreEqual ("'a&b'", attr.Value, "setInnerXml.Value");
attr.InnerXml = "\"a&b\"";
Assert.AreEqual ("\"a&b\"", attr.InnerXml, "Double_Quote");
attr.InnerXml = "\"a&b'";
Assert.AreEqual ("\"a&b'", attr.InnerXml, "DoubleQuoteStart_SingleQuoteEnd");
attr.Value = string.Empty;
XmlNodeChangedEventHandler evInserted = new XmlNodeChangedEventHandler (EventNodeInserted);
XmlNodeChangedEventHandler evChanged = new XmlNodeChangedEventHandler (EventNodeChanged);
XmlNodeChangedEventHandler evRemoved = new XmlNodeChangedEventHandler (EventNodeRemoved);
doc.NodeInserted += evInserted;
doc.NodeChanged += evChanged;
doc.NodeRemoved += evRemoved;
try {
// set_InnerText event
attr.InnerText = "fire";
Assert.IsFalse (inserted, "setInnerText.NodeInserted");
Assert.IsTrue (changed, "setInnerText.NodeChanged");
Assert.IsFalse (removed, "setInnerText.NodeRemoved");
inserted = changed = removed = false;
// set_InnerXml event
attr.InnerXml = "fire";
Assert.IsTrue (inserted, "setInnserXml.NodeInserted");
Assert.IsFalse (changed, "setInnserXml.NodeChanged");
Assert.IsTrue (removed, "setInnserXml.NodeRemoved");
inserted = changed = removed = false;
} finally {
doc.NodeInserted -= evInserted;
doc.NodeChanged -= evChanged;
doc.NodeRemoved -= evRemoved;
}
}
// Set up for the tests.
protected override void Setup()
{
doc = new XmlDocument();
handleBefore = new XmlNodeChangedEventHandler(WatchBefore);
handleAfter = new XmlNodeChangedEventHandler(WatchAfter);
}
public UndoManager(WixFiles wixFiles, XmlDocument wxsDocument)
{
undoCommands = new ArrayList();
redoCommands = new ArrayList();
beginNewCommandRange = true;
this.wxsDocument = wxsDocument;
this.wixFiles = wixFiles;
this.docIsSavedUndoCount = 0;
nodeChangedHandler = new XmlNodeChangedEventHandler(OnNodeChanged);
nodeChangingHandler = new XmlNodeChangedEventHandler(OnNodeChanging);
nodeInsertedHandler = new XmlNodeChangedEventHandler(OnNodeInserted);
nodeRemovingHandler = new XmlNodeChangedEventHandler(OnNodeRemoving);
this.wxsDocument.NodeChanged += nodeChangedHandler;
this.wxsDocument.NodeChanging += nodeChangingHandler;
this.wxsDocument.NodeInserted += nodeInsertedHandler;
this.wxsDocument.NodeRemoving += nodeRemovingHandler;
timeCheck = DateTime.Now;
}
// Set up for the tests.
protected override void Setup()
{
doc = new XmlDocument();
handleBefore = new XmlNodeChangedEventHandler(WatchBefore);
handleAfter = new XmlNodeChangedEventHandler(WatchAfter);
}
public void SetInnerTextAndXml ()
{
string original = doc.OuterXml;
doc.LoadXml ("<root name='value' />");
XmlAttribute attr = doc.DocumentElement.Attributes ["name"];
attr.InnerText = "a&b";
AssertEquals ("setInnerText", "a&b", attr.Value);
attr.InnerXml = "a&b";
AssertEquals ("setInnerXml", "a&b", attr.Value);
attr.InnerXml = "'a&b'";
AssertEquals ("setInnerXml.InnerXml", "'a&b'", attr.InnerXml);
AssertEquals ("setInnerXml.Value", "'a&b'", attr.Value);
attr.InnerXml = "\"a&b\"";
AssertEquals ("\"a&b\"", attr.InnerXml);
attr.InnerXml = "\"a&b'";
AssertEquals ("\"a&b'", attr.InnerXml);
attr.Value = "";
XmlNodeChangedEventHandler evInserted = new XmlNodeChangedEventHandler (EventNodeInserted);
XmlNodeChangedEventHandler evChanged = new XmlNodeChangedEventHandler (EventNodeChanged);
XmlNodeChangedEventHandler evRemoved = new XmlNodeChangedEventHandler (EventNodeRemoved);
doc.NodeInserted += evInserted;
doc.NodeChanged += evChanged;
doc.NodeRemoved += evRemoved;
try {
// set_InnerText event
attr.InnerText = "fire";
AssertEquals ("setInnerText.NodeInserted", false, inserted);
AssertEquals ("setInnerText.NodeChanged", true, changed);
AssertEquals ("setInnerText.NodeRemoved", false, removed);
inserted = changed = removed = false;
// set_InnerXml event
attr.InnerXml = "fire";
AssertEquals ("setInnserXml.NodeInserted", true, inserted);
AssertEquals ("setInnserXml.NodeChanged", false, changed);
AssertEquals ("setInnserXml.NodeRemoved", true, removed);
inserted = changed = removed = false;
} finally {
doc.NodeInserted -= evInserted;
doc.NodeChanged -= evChanged;
doc.NodeRemoved -= evRemoved;
}
}
private void setupNodeChangeListeners()
{
XmlNodeChangedEventHandler handler = new XmlNodeChangedEventHandler(NodeChangedEvent);
NodeChanged += handler;
NodeInserted += handler;
//NodeRemoving += handler;
NodeRemoved += handler;
}
