` value.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.Constructor
**Constructor**
>
>
>
>
> Note
>
>
>
> `Constructors` are special methods called when you create an object with the `New` keyword and pass in the parameters above.
>
>
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.Constructor
**Constructor**(xmlDoc As `String`)
> Parses the passed XML string into the document.
>
> This example loads the following XML, contained in a constant called `kXml`, into a new \`XMLDocument\`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> ``` Xojo
> ' Load XML
> Var xml As New XmlDocument
> Try
> xml.LoadXml(kXml)
> Catch e As XmlException
> MessageBox("XML error: " + e.Message)
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.Constructor
**Constructor**(fItem As `FolderItem`)
> Parses the passed XML file into the document.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.CreateAttribute
**CreateAttribute**(qName As `String`) As `XMLAttribute`
> Creates an attribute node as an `XMLAttribute`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.CreateAttribute
**CreateAttribute**(uri As `String`, qName As `String`) As `XMLAttribute`
> Creates an attribute node as an `XMLAttribute` with a namespace declaration.
>
> After you create an attribute, you have to add it to the XMLDocument using SetAttributeNode.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To add an attribute to the first team node (Seagulls):
>
> ``` Xojo
> Var xml As New XmlDocument(kXml)
>
> ' Create an attribute node and assign it a value
> Var xa As XmlAttribute
> xa = xml.CreateAttribute("TestAttribute")
> xa.Value = "Test"
>
> ' Add the attribute to the XML document
> xml.DocumentElement.FirstChild.SetAttributeNode(xa)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.CreateCDATASection
**CreateCDATASection**(data As `String`) As `XMLCDATASection`
> Creates a CDATA section with the passed *data* and returns it as an `XMLCDATASection`.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To add a CDATA section to the first team in the XML:
>
> ``` Xojo
> Var xml As New XmlDocument(kXml)
>
> ' Create a CDATA section node and assign it a value
> Var data As String = "Hello!
"
> Var xcdata As XmlCDATASection
> xcdata = xml.CreateCDATASection(data)
>
> ' Add the CDATA section to the XML document
> xml.DocumentElement.FirstChild.AppendChild(xcdata)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
> Hello!]]>
>
>
>
>
>
>
>
>
>
>
> ```
forsearch
XMLDocument.CreateComment
**CreateComment**(data As `String`) As `XMLComment`
> Creates an `XMLComment` with the passed *data* and returns it as an `XMLComment`.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To add a comment to the first team node:
>
> ``` Xojo
> Var xml As New XmlDocument(kXml)
>
> ' Create a Comment and assign it a value
> Var xc As XmlComment
> xc = xml.CreateComment("TestComment")
> xc.Value = "This node contains team information."
>
> ' Add the Comment to the XML document
> xml.DocumentElement.FirstChild.AppendChild(xc)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.CreateElement
**CreateElement**(tagName As `String`) As `XMLElement`
> Creates an element as an `XMLElement`. Returns an `XMLElement`.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.CreateElement
**CreateElement**(uri As `String`, tagName As `String`) As `XMLElement`
> Creates an element with a namespace declaration as an `XMLElement`. Returns an `XMLElement`.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To add a new team to the XML:
>
> ``` Xojo
> Var xml As New XmlDocument(kXml)
>
> ' Add a new Team to the XML
> Var xe As XmlElement
> xe = xml.CreateElement("Team")
> xe.SetAttribute("name", "Eagles")
>
> ' Add the Comment to the XML document
> xml.DocumentElement.AppendChild(xe)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.CreateProcessingInstruction
**CreateProcessingInstruction**(target As `String`, data As `String`) As `XMLProcessingInstruction`
> Creates an `XMLProcessingInstruction` with the passed *target* keyword and *data*.
>
> A [processing instruction](http://en.wikipedia.org/wiki/Processing_Instruction) is a node type intended to carry instructions to the application.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To add a processing instruction:
>
> ``` Xojo
> Var xml As New XmlDocument(kXml)
>
> ' Add a new Processing Instruction to the XML
> Var xpi As XmlProcessingInstruction
> xpi = xml.CreateProcessingInstruction("Target", "Data")
>
> ' Add the Processing Instruction to the XML document
> xml.AppendChild(xpi)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.CreateTextNode
**CreateTextNode**(data As `String`) As `XMLTextNode`
> Creates a text node with *data* and returns it as an `XMLTextNode`.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To add a text node to the first team node:
>
> ``` Xojo
> Var xml As New XmlDocument(kXml)
>
> ' Create a Text node and assign it a value
> Var xt As XmlTextNode
> xt = xml.CreateTextNode("Maine")
>
> ' Add the Text node to the XML document
> xml.DocumentElement.FirstChild.AppendChild(xt)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
> Maine
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.GetAttribute
**GetAttribute**(Name As `String`) As `String`
> Gets the value of the attribute specified by *Name*.
>
> Returns "" (empty string) if the attribute does not exist.
**GetAttribute**(URI As `String`, Name As `String`) As `String`
> Gets the value of the attribute specified by *URI* and *Name*.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> This example shows how to walk over the team nodes in the above XML and displays each team name:
>
> ``` Xojo
> Var xml As New XmlDocument(kXML)
> Var n As XmlNode = xml.DocumentElement.FirstChild
>
> While n <> Nil
> MessageBox(n.Name + ": " + n.GetAttribute("name"))
> n = n.NextSibling
> Wend
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.GetAttributeNode
**GetAttributeNode**(Name As `String`) As `XMLAttribute`
> Gets an XML attribute node of the attribute specified by *Index* position. *Index* is zero-based.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> This example shows how to walk over the team nodes in the above XML and displays each team name:
>
> ``` Xojo
> Var xml As New XmlDocument(kXML)
> Var n As XmlNode = xml.DocumentElement.FirstChild
>
> Var an As XmlAttribute
> While n <> Nil
> an = n.GetAttributeNode("name")
> MessageBox(n.Name + ": " + an.Value)
>
> n = n.NextSibling
> Wend
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.ImportNode
**ImportNode**(foreignNode As `XMLNode`, deep As `Boolean`) As `XMLNode`
> Copies a node from another XMLDocument into the current document.
>
> If the parameter *deep* is `True`, ImportNode will import all the child nodes of *foreignNode*. After you import a node, you must then place it somewhere within the XMLDocument.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To copy the first team into a new XML document:
>
> ``` Xojo
> Var xml1 As New XmlDocument(kXml)
> Var xml2 As New XmlDocument
>
> Var root As XmlNode
> root = xml2.AppendChild(xml2.CreateElement("League"))
>
> Var importNode As XmlNode
> importNode = xml2.ImportNode(xml1.DocumentElement.FirstChild, True)
>
> root.AppendChild(importNode)
>
> TextArea1.Text = xml2.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.Insert
**Insert**(newChild As `XMLNode`, before As `XMLNode`) As `XMLNode`
> Inserts *newChild* before the position of *beforeChild*. It optionally returns a reference to the inserted node as an XMLNode.
>
> The children being added must be children of the node/document to which they are being inserted. The example demonstrates this.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> To add a new team before the first team in the XML:
>
> ``` Xojo
> Var xml As New XmlDocument(kXml)
>
> Var n1 As XmlNode = xml.DocumentElement.FirstChild
>
> ' Insert a new team before the first team currently
> ' in the XML
> Var newTeam As XmlNode
> newTeam = xml.DocumentElement.AppendChild(xml.CreateElement("Team"))
> newTeam.SetAttribute("name", "Eagles")
>
> xml.DocumentElement.Insert(newTeam, n1)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.LoadXML
**LoadXML**(doc As `String`)
> Parses the passed XML string into the document.
>
> This example loads the following XML, contained in a constant called `kXml`, into a new \`XMLDocument\`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> ``` Xojo
> ' Load XML
> Var xml As New XmlDocument
> Try
> xml.LoadXml(kXml)
> Catch e As XmlException
> MessageBox("XML error: " + e.Message)
> End Try
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.LoadXML
**LoadXML**(fItem As `FolderItem`)
> Parses the passed XML file into the document.
>
> Always check for an `XMLException` when loading XML from strings or files.
>
> This example prompts the user to choose an XML file to load:
>
> ``` Xojo
> Var xmlFile As FolderItem
> xmlFile = FolderItem.ShowOpenFileDialog("")
>
> If xmlFile <> Nil Then
> Var xml As New XmlDocument
>
> Try
> xml.LoadXml(xmlFile)
> Catch e As XmlException
> MessageBox("XML error: " + e.Message)
> End Try
> End If
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.RemoveAttribute
**RemoveAttribute**(name As `String`)
> Removes the *name* attribute.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.RemoveAttributeNode
**RemoveAttributeNode**(attributeNode As `XMLAttribute`) As `XMLAttribute`
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> Remove the name attribute from the first Team:
>
> ``` Xojo
> Var xml As New XmlDocument(kXML)
> Var n As XmlNode = xml.DocumentElement.FirstChild
> Var an As XmlAttribute
> an = n.GetAttributeNode("name")
> n.RemoveAttributeNode(an)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.RemoveChild
**RemoveChild**(oldChild As `XMLNode`)
> Removes *oldChild* from the XML.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> Remove the "Seagulls" team from the XML:
>
> ``` Xojo
> Var xml As New XmlDocument(kXML)
>
> Var n As XmlNode = xml.DocumentElement.FirstChild
> Call xml.DocumentElement.RemoveChild(n)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.ReplaceChild
**ReplaceChild**(newChild As `XMLNode`, oldChild As `XMLNode`) As `XMLNode`
> Replaces *oldChild* with *newChild*.
>
> ReplaceChild optionally returns a reference to the new child as an XMLNode.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> Replaces the "Seagulls" with a new team "Eagles":
>
> ``` Xojo
> Var xml As New XmlDocument(kXML)
>
> Var n As XmlNode = xml.DocumentElement.FirstChild
>
> Var teamNode As XmlNode
> Var playerNode As XmlNode
>
> ' Create a new team
> teamNode = xml.DocumentElement.AppendChild(xml.CreateElement("Team"))
> teamNode.SetAttribute("name", "Eagles")
>
> playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
> playerNode.SetAttribute("name", "Fred")
> playerNode.SetAttribute("position", "1B")
>
> playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
> playerNode.SetAttribute("name", "Phil")
> playerNode.SetAttribute("position", "2B")
>
> ' Replace the "Seagulls" with the "Eagles"
> xml.DocumentElement.ReplaceChild(teamNode, n)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.SaveXML
**SaveXML**(fItem As `FolderItem`)
> Saves the XML to the passed `FolderItem`.
>
> The following XML, stored in a constant called `kXML`, is saved to a file selected by the user:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> ``` Xojo
> Var saveFile As FolderItem
> saveFile = FolderItem.ShowSaveFileDialog("", "Test.xml")
>
> If saveFile <> Nil Then
> Var xml As New XmlDocument
> Try
> xml.LoadXml(kXml)
> xml.SaveXml(saveFile)
> Catch fileError As IOException
> MessageBox("Save error: " + FileError.Message)
> Catch XMLError As XmlException
> MessageBox("XML error: " + XMLError.Message)
> End Try
> End If
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.SetAttribute
**SetAttribute**(name As `String`, value As `String`)
**SetAttribute**(uri As `String`, name As `String`, value As `String`)
> This syntax sets an attribute and declares a namespace.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> Add a "city" attribute to the first team:
>
> ``` Xojo
> Var xml As New XmlDocument(kXML)
> Var n As XmlNode = xml.DocumentElement.FirstChild
> n.SetAttribute("city", "Boston")
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.SetAttributeNode
**SetAttributeNode**(AttributeNode As `XMLAttribute`) As `XMLAttribute`
**SetAttributeNode**(attributeNode As `XMLAttribute`)
> Sets an attribute node.
>
> SetAttributeNode optionally returns a reference to a node as an XMLAttribute that had the same name and was replaced. The optional parameter *ns* determines whether to use and declare any namespace data found in the passed `XMLAttribute`.
>
> The following XML is stored in a constant called `kXML`:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
>
> Adds a "city" attribute to the first team:
>
> ``` Xojo
> Var xml As New XmlDocument(kXML)
>
> Var n As XmlNode = xml.DocumentElement.FirstChild
>
> Var a As XmlAttribute
> a = xml.CreateAttribute("city")
> a.Value = "Boston"
>
> n.SetAttributeNode(a)
>
> TextArea1.Text = xml.ToString
> ```
>
> The result would then be:
>
> ``` XML
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.Transform
**Transform**(xsl As `String`) As `String`
> Creates a new XML document that is the result of applying an XSLT stylesheet string.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.Transform
**Transform**(xsl As `XMLStyleSheet`, saxHandler As `XMLXsltHandler`) As `String`
> Creates a new XML document that is the result of applying an XSLT stylesheet and register an event handler *saxHandler* to receive SAX style events on the output XML during the transformation.
>
> Versions 1.0 of XSLT and XPath are supported. XSLT is described at: and XPath at .
>
> You can use XMLDocument.Transform to generate pretty-printed XML data using the following XSL.
>
> ``` XML
>
>
>
>
>
>
>
> ```
>
> Save it in a project as a constant named `kPrettyPrintXSL`. Then the following code generates pretty-printed XML data from an XMLDocument object.
>
> ``` Xojo
> Var prettyXML As String = xml.Transform(kPrettyPrintXSL)
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
XMLDocument.XQL
**XQL**(query As `String`) As `XMLNodeList`
**XQL**(query As `String`, map() As `String`) As `XMLNodeList`
> Performs an XPath 1.0 query and returns an `XMLNodeList` of the resulting nodes.
>
> If the *query* has namespace references in it, you must provide declarations for them in the form of a string array, such as:
>
> ``` Xojo
> ```
>
> Var map() As String = Array("ns1","","ns2","")
>
> Xql is also called XPath. Version 1.0 of XPath are supported.
>
> For more information about XPath:
>
> -
> -
>
> The example code below uses this XML. Assign it to a constant called `kXML`:
>
> ``` XML
> ```
>
> \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \
>
> To get all the player names, you can use "//Player" as the query:
>
> ``` Xojo
> ' Load XML
> Var xml As New XmlDocument
> Try
> xml.LoadXml(kXml)
> Catch e As XmlException
> MessageBox("XML error: " + e.Message)
> End Try
>
> ' Display all the Player names
> Var nodes As XmlNodeList
> nodes = xml.XQL("//Player") ' Find all Player nodes in XML
>
> ' Loop through results and display each name attribute
> Var node As XmlNode
> For i As Integer = 0 To nodes.Length - 1
> node = nodes.Item(i)
> MessageBox("Player: " + node.GetAttribute("name"))
> Next
> ```
## Notes
An XMLDocument is an internal data structure that can be converted to a string using the ToString function. An XMLDocument is used for both parsing existing XML data into a DOM document structure or creating a new XML document from scratch.
## Sample code
The following XML:
``` XML
```
Can be created using this code, which displays the XML to a TextArea and prompts you to save it to a file:
``` Xojo
Var xml As New XmlDocument
Var root As XmlNode
root = xml.AppendChild(xml.CreateElement("League"))
Var teamNode As XmlNode
Var playerNode As XmlNode
' Create 1st team and its players
teamNode = root.AppendChild(xml.CreateElement("Team"))
teamNode.SetAttribute("name", "Seagulls")
playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
playerNode.SetAttribute("name", "Bob")
playerNode.SetAttribute("position", "1B")
playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
playerNode.SetAttribute("name", "Tom")
playerNode.SetAttribute("position", "2B")
' Create 2nd team and its players
teamNode = root.AppendChild(xml.CreateElement("Team"))
teamNode.SetAttribute("name", "Pigeons")
playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
playerNode.SetAttribute("name", "Bill")
playerNode.SetAttribute("position", "1B")
playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
playerNode.SetAttribute("name", "Tim")
playerNode.SetAttribute("position", "2B")
' Create 3rd team and its players
teamNode = root.AppendChild(xml.CreateElement("Team"))
teamNode.SetAttribute("name", "Crows")
playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
playerNode.SetAttribute("name", "Ben")
playerNode.SetAttribute("position", "1B")
playerNode = teamNode.AppendChild(xml.CreateElement("Player"))
playerNode.SetAttribute("name", "Ty")
playerNode.SetAttribute("position", "2B")
TextArea1.Text = xml.ToString
DisplayXML(xml)
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
This code iterates through the XML created above and displays it in a ListBox:
``` Xojo
Sub DisplayXML(xml As XmlDocument)
Var root As XmlNode
root = xml.DocumentElement
XMLList.RemoveAllRows
Var teamNode As XmlNode
Var playerNode As XmlNode
For team As Integer = 0 To root.ChildCount - 1
' Add Team name
teamNode = root.Child(team)
XMLList.AddRow(teamNode.GetAttribute("name"))
' Add Players
For player As Integer = 0 To teamNode.ChildCount - 1
playerNode = teamNode.Child(player)
XMLList.AddRow(playerNode.GetAttribute("name"), _
playerNode.GetAttribute("position"))
Next
Next
End Sub
```
## Compatibility
| | |
|-----------------------|-----|
| **Project Types** | All |
| **Operating Systems** | All |
`XMLNode` parent class; `XMLAttribute`, `XMLComment`, `XMLCDATASection`, `XMLDOMException`, `XMLElement`, `XMLException`, `XMLNode`, `XMLNodeList`, `XMLProcessingInstruction`, `XMLTextNode` classes.