Development/Tutorials/QtDOM Tutorial - Revision history

Neverendingo: Text replace - "" to ""

2011-06-29T20:56:15Z

Text replace - "</code>" to "</syntaxhighlight>"

Neverendingo: Text replace - "`" to ""`


2011-06-29T20:45:42Z
Text replace - "<code>" to "<syntaxhighlight lang="text">"

				
				
				
				
			
			← Older revision
			Revision as of 20:45, 29 June 2011
			
Line 382:
Line 382:
    
  So far, we created elements (without namespaces) using the QDomDocument:createElement(...) method. Qt, or rather DOM,  offers a simply way to generate elements with a namespace attached:   So far, we created elements (without namespaces) using the QDomDocument:createElement(...) method. Qt, or rather DOM,  offers a simply way to generate elements with a namespace attached:
− <code> + <syntaxhighlight lang="text">
     QDomDocument::createElementNS( const QString &nsURI, const QString &qName )      QDomDocument::createElementNS( const QString &nsURI, const QString &qName )
  </code>   </code>



Neverendingo: Text replace - "" to ""

2011-06-29T20:33:24Z
Text replace - "<code xml>" to "<syntaxhighlight lang="xml">"

				
				
				
				
			
			← Older revision
			Revision as of 20:33, 29 June 2011
			
Line 9:
Line 9:
    
  As an example, let us assume that you want to store holiday information into a file and use Qt to load or modify it. To get a feeling for how XML looks like, here is one possible format for such a holiday file:   As an example, let us assume that you want to store holiday information into a file and use Qt to load or modify it. To get a feeling for how XML looks like, here is one possible format for such a holiday file:
− <code xml> + <syntaxhighlight lang="xml">
  <?xml version='1.0' encoding='UTF-8'?>   <?xml version='1.0' encoding='UTF-8'?>
  <holidayset country="at">   <holidayset country="at">
Line 344:
Line 344:
    
  So, clearly there should be a way to distinguish these two elements with the same name, but different usages. This can be done via XML namespaces, using prefixes to the elements. A namespace is a unique URI (not necessarily a URL!), e.g. "http://reinhold.kainhofer.com/ns/qtdom-examples" or "urn:kde:developer:tutorials:QtDom:holidays". Rathern than using these long and awkward URIs with each element, you have to define a prefix for each of the namespaces. This is done via an     So, clearly there should be a way to distinguish these two elements with the same name, but different usages. This can be done via XML namespaces, using prefixes to the elements. A namespace is a unique URI (not necessarily a URL!), e.g. "http://reinhold.kainhofer.com/ns/qtdom-examples" or "urn:kde:developer:tutorials:QtDom:holidays". Rathern than using these long and awkward URIs with each element, you have to define a prefix for each of the namespaces. This is done via an  
− <code xml> + <syntaxhighlight lang="xml">
     xmlns:yourprefix="your:namespace:uri"      xmlns:yourprefix="your:namespace:uri"
  </code>   </code>
Line 364:
Line 364:
  Using this new knowledge about namespaces, of course, we want to generate and process holiday files with proper namespaces. For example, we could define all the tags to be in the namespace "urn:kde:developer:tutorials:QtDom:holidays", indicated by the prefix "h". A typical XML file would then look like:   Using this new knowledge about namespaces, of course, we want to generate and process holiday files with proper namespaces. For example, we could define all the tags to be in the namespace "urn:kde:developer:tutorials:QtDom:holidays", indicated by the prefix "h". A typical XML file would then look like:
    
− <code xml> + <syntaxhighlight lang="xml">
  <?xml version='1.0' encoding='UTF-8'?>   <?xml version='1.0' encoding='UTF-8'?>
  <h:holidays xmlns:h="urn:kde:developer:tutorials:QtDom:holidays"   <h:holidays xmlns:h="urn:kde:developer:tutorials:QtDom:holidays"
Line 451:
Line 451:
  === Workaround for broken namespace handling in Qt 4.2.0 and before ===   === Workaround for broken namespace handling in Qt 4.2.0 and before ===
  Unfortunately, the correct way laid out above does not produce valid XML with Qt versions at least up to 4.2.0:   Unfortunately, the correct way laid out above does not produce valid XML with Qt versions at least up to 4.2.0:
− <code xml> + <syntaxhighlight lang="xml">
  <?xml version='1.0' encoding='UTF-8'?>   <?xml version='1.0' encoding='UTF-8'?>
  <h:holidayset xmlns:h="urn:kde:developer:tutorials:QtDom:holidays" h:country="at" xmlns:h="urn:kde:developer:tutorials:QtDom:holidays" >   <h:holidayset xmlns:h="urn:kde:developer:tutorials:QtDom:holidays" h:country="at" xmlns:h="urn:kde:developer:tutorials:QtDom:holidays" >
Line 502:
Line 502:
    
  The output now becomes the correct XML code:   The output now becomes the correct XML code:
− <code xml> + <syntaxhighlight lang="xml">
  <?xml version='1.0' encoding='UTF-8'?>   <?xml version='1.0' encoding='UTF-8'?>
  <h:holidayset xmlns:h="urn:kde:developer:tutorials:QtDom:holidays" h:country="at" >   <h:holidayset xmlns:h="urn:kde:developer:tutorials:QtDom:holidays" h:country="at" >
Line 566:
Line 566:
    
  If you directly create the text with the method above, the XML will have a line   If you directly create the text with the method above, the XML will have a line
− <code xml> + <syntaxhighlight lang="xml">
     <h:name>New Year </h:holiday></h:name>      <h:name>New Year </h:holiday></h:name>
  </code>   </code>
  which is simply malformed XML!   which is simply malformed XML!
  On the opposite, if you use Qt's DOM classes (or any other DOM implementation for that matter), the resulting XML will be     On the opposite, if you use Qt's DOM classes (or any other DOM implementation for that matter), the resulting XML will be  
− <code xml> + <syntaxhighlight lang="xml">
     <h:name>New Year &lt;/h:holiday></h:name>      <h:name>New Year &lt;/h:holiday></h:name>
  </code>   </code>
Line 729:
Line 729:
  As an example, let's say we want to create a nice HTML-formatted list of all holidays in the holiday file. One possible XSLT style sheet for the holiday file would be:   As an example, let's say we want to create a nice HTML-formatted list of all holidays in the holiday file. One possible XSLT style sheet for the holiday file would be:
    
− <code xml> + <syntaxhighlight lang="xml">
  <?xml version="1.0"?>   <?xml version="1.0"?>
  <xsl:stylesheet version="1.0"     <xsl:stylesheet version="1.0"  



Neverendingo: Text replace - "" to ""

2011-06-29T20:32:33Z
Text replace - "<code cppqt n>" to "<syntaxhighlight lang="cpp-qt" line>"

				
				
				
				
			
			← Older revision
			Revision as of 20:32, 29 June 2011
			
Line 93:
Line 93:
  As a line of code says more then a thousand words, let us look at some sample code to generate the DOM tree from the HolidaySet class:   As a line of code says more then a thousand words, let us look at some sample code to generate the DOM tree from the HolidaySet class:
    
− <code cppqt n> + <syntaxhighlight lang="cpp-qt" line>
    
  /* Helper function to generate a DOM Element for the given DOM document     /* Helper function to generate a DOM Element for the given DOM document  
Line 197:
Line 197:
  The usual way to parse an XML document into a DOM tree is to use the method QDomDocument::setContent. If this method is successful, the QDomDocument object contains the DOM tree in the usual DOM structure. If an error occurs, the error message and the exact position of the error is stored into the parameters of the call:   The usual way to parse an XML document into a DOM tree is to use the method QDomDocument::setContent. If this method is successful, the QDomDocument object contains the DOM tree in the usual DOM structure. If an error occurs, the error message and the exact position of the error is stored into the parameters of the call:
    
− <code cppqt n> + <syntaxhighlight lang="cpp-qt" line>
  QFile f( argv[1] );   QFile f( argv[1] );
  QDomDocument doc;   QDomDocument doc;
Line 289:
Line 289:
  This concludes our method for loading the holiday set data from the DOM tree representation into the HolidaySet data structure. The whole parseXMLwithDOM function thus reads:   This concludes our method for loading the holiday set data from the DOM tree representation into the HolidaySet data structure. The whole parseXMLwithDOM function thus reads:
    
− <code cppqt n> + <syntaxhighlight lang="cpp-qt" line>
  HolidaySet parseXMLwithDOM( QDomDocument &domTree )     HolidaySet parseXMLwithDOM( QDomDocument &domTree )  
  {   {
Line 591:
Line 591:
  However, of course we can write such a method ourselves (thanks go to David Faure for the hint!):   However, of course we can write such a method ourselves (thanks go to David Faure for the hint!):
    
− <code cppqt n> + <syntaxhighlight lang="cpp-qt" line>
  QDomElement namedItemNS( const QDomNode& node, const char* nsURI, const char* localName )   QDomElement namedItemNS( const QDomNode& node, const char* nsURI, const char* localName )
  {   {



Neverendingo: Text replace - "" to ""

2011-06-29T20:30:30Z
Text replace - "<code cppqt>" to "<syntaxhighlight lang="cpp-qt">"

				
				
				
				
			
			← Older revision
			Revision as of 20:30, 29 June 2011
			
Line 46:
Line 46:
  We will use the example from above throughout this tutorial. In our application, we want to store the holiday set in the following class:   We will use the example from above throughout this tutorial. In our application, we want to store the holiday set in the following class:
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  class Holiday   class Holiday
  {   {
Line 69:
Line 69:
    
  In production code, you would not make the member variables public and directly access them, but rather add accessors and setter functions:   In production code, you would not make the member variables public and directly access them, but rather add accessors and setter functions:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QDate date() { return mDate; }   QDate date() { return mDate; }
  void setDate( const QDate &date ) { mDate = date; }   void setDate( const QDate &date ) { mDate = date; }
Line 165:
Line 165:
  You can now create the XML file contents simply via   You can now create the XML file contents simply via
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  // Create the data structure   // Create the data structure
  HolidaySet hs("at");   HolidaySet hs("at");
Line 210:
Line 210:
    
  To extract the holiday data from the DOM tree, we write the function parseXMLwithDOM:   To extract the holiday data from the DOM tree, we write the function parseXMLwithDOM:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  HolidaySet parseXMLwithDOM( QDomDocument &domTree )     HolidaySet parseXMLwithDOM( QDomDocument &domTree )  
  {   {
Line 217:
Line 217:
    
  We first obtain the DOM element that represents the <holidayset>...</holidayset> element using the namedItem and toElement methods. If no child node named "holidayset" exists or it is not an element (e.g. because it is a processing instruction or an attribute), a null element is returned:   We first obtain the DOM element that represents the <holidayset>...</holidayset> element using the namedItem and toElement methods. If no child node named "holidayset" exists or it is not an element (e.g. because it is a processing instruction or an attribute), a null element is returned:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
     QDomElement set = domTree.namedItem("holidayset").toElement();      QDomElement set = domTree.namedItem("holidayset").toElement();
     if ( set.isNull() ) {      if ( set.isNull() ) {
Line 228:
Line 228:
  This element possibly has an attribute named "country". This can be checked using the QDomNode::hasAttribute method and the attribute can be obtained using the QDomNode::attribute method:   This element possibly has an attribute named "country". This can be checked using the QDomNode::hasAttribute method and the attribute can be obtained using the QDomNode::attribute method:
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  if ( set.hasAttribute("country") ) {   if ( set.hasAttribute("country") ) {
     hs.mCountry = set.attribute("country");      hs.mCountry = set.attribute("country");
Line 235:
Line 235:
    
  We can also have a <name>...</name> child element, which can be obtained similar to the holidayset element. We retrieve the text of the element between the enclosing tags by a call to QDomElement::text():   We can also have a <name>...</name> child element, which can be obtained similar to the holidayset element. We retrieve the text of the element between the enclosing tags by a call to QDomElement::text():
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  // Search for a given element (only the first matching is returned):   // Search for a given element (only the first matching is returned):
  QDomElement name = set.namedItem("name").toElement();   QDomElement name = set.namedItem("name").toElement();
Line 245:
Line 245:
  The namedItem method will always return the first child that matches the given name. While this might be fine for the <name> child element, we cannot use this for the <holiday>...</holiday> elements, which will appear more than once. For this reason, there are iterator-like calls firstChild() and and nextSibling() to walk through all child nodes and firstChildElement("tagname") and nextSiblingElement("tagname") to walk only through all child elements with the given tag name. If no further child can be found, a null node is returned:   The namedItem method will always return the first child that matches the given name. While this might be fine for the <name> child element, we cannot use this for the <holiday>...</holiday> elements, which will appear more than once. For this reason, there are iterator-like calls firstChild() and and nextSibling() to walk through all child nodes and firstChildElement("tagname") and nextSiblingElement("tagname") to walk only through all child elements with the given tag name. If no further child can be found, a null node is returned:
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  // Way 1: Loop through all child nodes with a given tag name.   // Way 1: Loop through all child nodes with a given tag name.
  QDomElement e = set.firstChildElement( "holiday" );   QDomElement e = set.firstChildElement( "holiday" );
Line 276:
Line 276:
  Now that we have the QDomElement of the <holiday>...</holiday> element, we can easily load its contents into the Holiday structure, using only methods that we have already seen:   Now that we have the QDomElement of the <holiday>...</holiday> element, we can easily load its contents into the Holiday structure, using only methods that we have already seen:
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  Holiday h;   Holiday h;
  QDomElement v = e.namedItem("name").toElement();   QDomElement v = e.namedItem("name").toElement();
Line 386:
Line 386:
  </code>   </code>
  To create an element with a namespace attached, the only difference to the example from the previous sections is that you need to use this method instead of QDomElement::createElement( const QString &tag ). The first parameter is the full URI of the namespace (e.g. "urn:kde:developer:tutorials:QtDom:holidays" in our example XML code), while the second argument is no longer the tag name along (like "holiday"), but rather the full QName, including the namespace prefix. So, to create the holiday element in the namespace with prefix "h", simply replace the call to     To create an element with a namespace attached, the only difference to the example from the previous sections is that you need to use this method instead of QDomElement::createElement( const QString &tag ). The first parameter is the full URI of the namespace (e.g. "urn:kde:developer:tutorials:QtDom:holidays" in our example XML code), while the second argument is no longer the tag name along (like "holiday"), but rather the full QName, including the namespace prefix. So, to create the holiday element in the namespace with prefix "h", simply replace the call to  
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
     doc.createElement( "holiday" );      doc.createElement( "holiday" );
  </code>   </code>
  with     with  
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
     doc.createElementNS( "urn:kde:developer:tutorials:QtDom:holidays", "h:holiday" );      doc.createElementNS( "urn:kde:developer:tutorials:QtDom:holidays", "h:holiday" );
  </code>   </code>
  Again, we can write our own helper method "addElementNS":   Again, we can write our own helper method "addElementNS":
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  /* Helper function to generate a DOM Element for the given DOM document     /* Helper function to generate a DOM Element for the given DOM document  
      and append it to the children of the given node. */       and append it to the children of the given node. */
Line 416:
Line 416:
    
  The whole "holidaySetToXML" method thus becomes:   The whole "holidaySetToXML" method thus becomes:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QString holidaySetToXML( const HolidaySet &hs )   QString holidaySetToXML( const HolidaySet &hs )
  {   {
Line 468:
Line 468:
  Apparently, this XML seems more verbose than we actually want: Qt inserts the xmlns:h attribute into every element that uses the "h" namespace! Even worse, the <h:holidayset> element has this attribute set twice... This is a bug in Qt and has been fixed in the latest versions, but for older versions you'll have to resolve to a quite ugly workaround: Simply don't create the elements with createElementNS, but rather createElement (while still giving the whole qName, including the "h:" prefix!). Consequently, you now also have to create the xmlns:h attribute yourself.   Apparently, this XML seems more verbose than we actually want: Qt inserts the xmlns:h attribute into every element that uses the "h" namespace! Even worse, the <h:holidayset> element has this attribute set twice... This is a bug in Qt and has been fixed in the latest versions, but for older versions you'll have to resolve to a quite ugly workaround: Simply don't create the elements with createElementNS, but rather createElement (while still giving the whole qName, including the "h:" prefix!). Consequently, you now also have to create the xmlns:h attribute yourself.
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QString holidaySetToXML( const HolidaySet &hs )   QString holidaySetToXML( const HolidaySet &hs )
  {   {
Line 520:
Line 520:
    
  Of course, noone forces you to use Qt's DOM classes to generate the XML code. After all, the resulting XML is only a simple text! The most straight-forward approach would thus be to directly generate the text that contains the XML.   Of course, noone forces you to use Qt's DOM classes to generate the XML code. After all, the resulting XML is only a simple text! The most straight-forward approach would thus be to directly generate the text that contains the XML.
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QString holidaySetToXML( const HolidaySet &hs )   QString holidaySetToXML( const HolidaySet &hs )
  {   {
Line 561:
Line 561:
    
  Imagine for example that one holiday would have a name of     Imagine for example that one holiday would have a name of  
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
     h.mName = QString( "New Year </h:holiday>" );      h.mName = QString( "New Year </h:holiday>" );
  </code>   </code>
Line 584:
Line 584:
    
  Unfortunately, Qt -- or rather DOM -- does not offer a method namedItemNS like QDomElement::namedItem to return a child element with a given tag naem from a given namespace. There is a method     Unfortunately, Qt -- or rather DOM -- does not offer a method namedItemNS like QDomElement::namedItem to return a child element with a given tag naem from a given namespace. There is a method  
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QDomNodeList elementsByTagNameNS ( const QString & nsURI, const QString & localName ) const     QDomNodeList elementsByTagNameNS ( const QString & nsURI, const QString & localName ) const  
  </code>   </code>
Line 608:
Line 608:
  Now that we have a method to get the child element with the given prefix and tag name, we might also want to loop over all children with a given tag name from a certain namespace. This can easily be done with the same approach as above. We can simply loop through all child nodes with the wanted tag name, but we also need to make sure the namespace matches:   Now that we have a method to get the child element with the given prefix and tag name, we might also want to loop over all children with a given tag name from a certain namespace. This can easily be done with the same approach as above. We can simply loop through all child nodes with the wanted tag name, but we also need to make sure the namespace matches:
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QDomElement e = parent.firstChildElement( "holiday" );   QDomElement e = parent.firstChildElement( "holiday" );
  while ( !e.isNull() ) {   while ( !e.isNull() ) {
Line 632:
Line 632:
  The SAX parsing happens using the QXmlSimpleReader class, where we first have to register our QXmlDefaultHandler-derived class as the SAX handler. The QXmlSimleReader::parse method finally triggers the XML parsing.   The SAX parsing happens using the QXmlSimpleReader class, where we first have to register our QXmlDefaultHandler-derived class as the SAX handler. The QXmlSimleReader::parse method finally triggers the XML parsing.
    
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  class HolidayHandler : public QXmlDefaultHandler   class HolidayHandler : public QXmlDefaultHandler
  {   {



Reinhold: XSLT Stylesheet, looping over namespaced tags
2007-02-25T23:30:16Z
XSLT Stylesheet, looping over namespaced tags

				
				
				
				
			
			← Older revision
			Revision as of 23:30, 25 February 2007
			
Line 606:
Line 606:
  Notice that we checked the local name and the namespace URI to find the appropriate element. The namespace prefix cannot be used, as it is not fixed. You can use whatever prefix you want for a given namespace URI, although for many often used namespaces there are recommended prefix names. Similarly, you should not check the tag name, as it also contains the prefix (or if you use a default prefix, it is missing all namespace information!).   Notice that we checked the local name and the namespace URI to find the appropriate element. The namespace prefix cannot be used, as it is not fixed. You can use whatever prefix you want for a given namespace URI, although for many often used namespaces there are recommended prefix names. Similarly, you should not check the tag name, as it also contains the prefix (or if you use a default prefix, it is missing all namespace information!).
    
− Now that we have a method to get the child element with the given prefix and tag name, we might also want to loop over all children with   + Now that we have a method to get the child element with the given prefix and tag name, we might also want to loop over all children with a given tag name from a certain namespace. This can easily be done with the same approach as above. We can simply loop through all child nodes with the wanted tag name, but we also need to make sure the namespace matches:
−   + 
− From KODom.h (by dfaure): + 
    
  <code cppqt>   <code cppqt>
− /** + QDomElement e = parent.firstChildElement( "holiday" );
−  * This namespace contains a few convenience functions to simplify code using QDom + while ( !e.isNull() ) {
−  * (when loading OASIS documents, in particular). +   if ( e.namespaceURI() == nsURI ) {
−  * +      // Do whatever we need to do with the holiday
−  * To find the child element with a given name, use KoDom::namedItemNS. +   }
−  * +   e = e.nextSiblingElement( "holiday" );
−  * To find all child elements with a given name, use + }
−  * QDomElement e; + 
−  * forEachElement( e, parent ) + 
−  * { + 
−  *     if ( e.localName() == "..." && e.namespaceURI() == KoXmlNS::... ) + 
−  *     { + 
−  *         ... + 
−  *     } + 
−  * } + 
−  * Note that this means you don't ever need to use QDomNode nor toElement anymore! + 
−  * Also note that localName is the part without the prefix, this is the whole point + 
−  * of namespace-aware methods. + 
−  * + 
−  * To find the attribute with a given name, use QDomElement::attributeNS. + 
−  * + 
−  * Do not use getElementsByTagNameNS, it's recursive (which is never needed in KOffice). + 
−  * Do not use tagName() or nodeName() or prefix(), since the prefix isn't fixed. + 
−  * + 
−  * @author David Faure <faure@kde.org> + 
−  */ + 
  </code>   </code>
  + 
  + Since we now care about namespaces, we need to explicitly check whether the namespace URI matches the required namespace. The firstChilElement and nextSiblingElement methods don't care about namespaces at all and return every node with the given tag name from any namespace.
    
    
Line 743:
Line 724:
    
  However, there is a great W3C-specified way to transform XML files into practically every other format: XSLT.     However, there is a great W3C-specified way to transform XML files into practically every other format: XSLT.  
  + 
  + XSLT is a pattern-based approach to format XML. In an XSL style sheet you define templates, which are applied to all xml elements or nodes that match a given pattern. Inside each template, you simply generate the desired output for that node. As a consequence, XSLT processes is path-independent or state-less. When you process a given tag with a template, you do now know where in the XML tree that element appears -- and you should not need to know for correct XSLT.
  + 
  + As an example, let's say we want to create a nice HTML-formatted list of all holidays in the holiday file. One possible XSLT style sheet for the holiday file would be:
  + 
  + <code xml>
  + <?xml version="1.0"?>
  + <xsl:stylesheet version="1.0" 
  +                 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  +                 xmlns:h="urn:kde:developer:tutorials:QtDom:holidays"
  +                 exclude-result-prefixes='xsl h'
  + >
  + <xsl:output method="html"/>
  + 
  + <xsl:template match="*"><xsl:apply-templates/></xsl:template>
  + 
  + <xsl:template match="h:holidayset">
  +   <html><body>
  +     <xsl:if test="h:name"><h1><xsl:value-of select="h:name"/></h1></xsl:if>
  +     <xsl:if test="@h:country">
  +       <h2>Country: <xsl:value-of select="@h:country"/></h2>
  +     </xsl:if>
  +     <table border="1">
  +       <tr>
  +         <th>Date</th><th>Holiday name</th>
  +       </tr>
  +       <xsl:apply-templates select="h:holiday">
  +         <xsl:sort select="h:date"/>
  +       </xsl:apply-templates>
  +     </table>
  +   </body></html>
  + </xsl:template>
  + 
  + <xsl:template match="h:holiday">
  +   <tr>
  +     <td><xsl:value-of select="h:date"/></td>
  +     <td><xsl:value-of select="h:name"/></td>
  +   </tr>
  + </xsl:template>
  + 
  + </xsl:stylesheet>
  + </code>
    
  ''Initial Author:'' [mailto:reinhold@kainhofer.com Reinhold Kainhofer]   ''Initial Author:'' [mailto:reinhold@kainhofer.com Reinhold Kainhofer]



Reinhold at 19:44, 25 February 2007
2007-02-25T19:44:26Z


				
				
				
				
			
			← Older revision
			Revision as of 19:44, 25 February 2007
			
Line 139:
Line 139:
  </code>   </code>
    
− One thing to notice is that all DOM nodes are passed by value (since some programming languages do not define pointers, the DOM API cannot use any pointer-based functionality!). + One thing to notice is that all DOM nodes are passed by value (since some programming languages do not define pointers, the DOM API cannot use any pointer-based functionality!). The Qt implementation of DOM uses explicit sharing (as explained in the API documentation of {{qt|QDomNode}}), so that whenever you change the QDomNode (or of course any derived class object), all copies are changed (since they point to the same data in memory). To create an independent copy of a given QDomNode, there is the method {{qt|QDomNode::cloneNode}}(bool recursive). The bool argument to cloneNode indicates whether the children of the node shall also be copied independently or whether they shall still be explicitly shared with the original node.
    
  Let us now slowly step through the code:   Let us now slowly step through the code:
Line 574:
Line 574:
     <h:name>New Year &lt;/h:holiday></h:name>      <h:name>New Year &lt;/h:holiday></h:name>
  </code>   </code>
− which is correct XML, as the < is escaped using the &lt; entity. + which is correct XML, as the &lt; is escaped using the &amp;lt; entity. Of course, the same result can also be obtained by manually calling an escape method (like the one provided by Qt) on each and every string that is appended to the text output. Using Qt's XML classes take away the need to think of such issues and always correctly produce the XML.
    
    
Line 581:
Line 581:
  == Loading XML documents with namespaces using Qt ==   == Loading XML documents with namespaces using Qt ==
    
− Now that we have created XML documents with namespaced tags, of course, we also want to be able to load them using Qt's native classes. + Now that we have created XML documents with namespaced tags, of course, we also want to be able to load them using Qt's native classes. The parsing of the XML into a DOM tree works with the same method QDomDocument::setContent as above. This method also loads all the namespace and prefix information into its QDomNode children and deeper descendants. When we didn't use namespaces, we could use a call like QDomNode::namedItem( "tagname" ) to obtain a child element with the given tag name. Since the tag name is now also connected to a namespace, we also have to make sure that the tagname (obtained via QDomNode::localName()) is in that namespace, i.e. we have to make sure that QDomNode::namespaceURI() matches the required namespace URI. 
  +  
  + Unfortunately, Qt -- or rather DOM -- does not offer a method namedItemNS like QDomElement::namedItem to return a child element with a given tag naem from a given namespace. There is a method 
  + <code cppqt>
  + QDomNodeList elementsByTagNameNS ( const QString & nsURI, const QString & localName ) const 
  + </code>
  + but that method is not what we actually want, because it is recursive: It returns a list of all child elements with given tag name and namespace that are found at any depth. Thus it will also return grand- and grand-grand-children etc. of the DOm node. Clearly, we only want immediate children, so this mathod cannot be used.
  +  
  + However, of course we can write such a method ourselves (thanks go to David Faure for the hint!):
    
  <code cppqt n>   <code cppqt n>
− // (Copyright David Faure, put under the GPL) + QDomElement namedItemNS( const QDomNode& node, const char* nsURI, const char* localName )
− KoXmlElement KoDom::namedItemNS( const KoXmlNode& node, const char* nsURI, const char* localName ) + 
  {   {
−     KoXmlNode n = node.firstChild(); +   QDomElement n = node.firstChildElement();
−     for ( ; !n.isNull(); n = n.nextSibling() ) { +   for ( ; !n.isNull(); n = n.nextSiblingElement() ) {
−         if ( n.isElement() && n.localName() == localName && n.namespaceURI() == nsURI ) +     if ( n.localName() == localName && n.namespaceURI() == nsURI ) {
−             return n.toElement(); +       return n;
       }        }
−     return KoXmlElement(); +   }
  +   return QDomElement();
  }   }
  </code>   </code>
  + 
  + Notice that we checked the local name and the namespace URI to find the appropriate element. The namespace prefix cannot be used, as it is not fixed. You can use whatever prefix you want for a given namespace URI, although for many often used namespaces there are recommended prefix names. Similarly, you should not check the tag name, as it also contains the prefix (or if you use a default prefix, it is missing all namespace information!).
  + 
  + Now that we have a method to get the child element with the given prefix and tag name, we might also want to loop over all children with 
    
  From KODom.h (by dfaure):   From KODom.h (by dfaure):



Tampakrap: Some more parts of the DOM tutorial
2007-02-13T20:36:20Z
Some more parts of the DOM tutorial
Show changes


Reinhold: Use the really, really, really ugly mediawiki syntax for tables
2007-02-03T20:20:48Z
Use the really, really, really ugly mediawiki syntax for tables

				
				
				
				
			
			← Older revision
			Revision as of 20:20, 3 February 2007
			
Line 349:
Line 349:
  attribute to the element or any of its parents. This defines the "yourprefix" prefix as a shortcut to the full namespace URI "your:namespace:uri". Usually, the namespace declaration is added to the root element of hte XML file. To use an element from this namespace, you can simply prepend the prefix to the tag name: <yourprefix:tag>. This tag name together with the prefix is called the "qualified name" (or in short qName) or the element. The various parts of the element (which you will find in the Qt DOM API, too), are:   attribute to the element or any of its parents. This defines the "yourprefix" prefix as a shortcut to the full namespace URI "your:namespace:uri". Usually, the namespace declaration is added to the root element of hte XML file. To use an element from this namespace, you can simply prepend the prefix to the tag name: <yourprefix:tag>. This tag name together with the prefix is called the "qualified name" (or in short qName) or the element. The various parts of the element (which you will find in the Qt DOM API, too), are:
    
− | yourprefix:tag     | qualified name (qName) | + {|
− | yourprefix         | prefix                 | + |-
− | tag                | local name | + | yourprefix:tag     || qualified name (qName)  
− | your:namespace:uri | Namespace URI | + |-
  + | yourprefix         || prefix                  
  + |-
  + | tag                || local name  
  + |-
  + | your:namespace:uri || Namespace URI  
  + |}
    
  (As a side note: If an element does not use any namespaces and thus also no prefix, e.g. <tag>, all these parts of the qName are empty and only the "tag name" is set to "tag".)   (As a side note: If an element does not use any namespaces and thus also no prefix, e.g. <tag>, all these parts of the qName are empty and only the "tag name" is set to "tag".)



Reinhold: Explain namespaces
2007-02-03T20:17:05Z
Explain namespaces

				
				
				
				
			
			← Older revision
			Revision as of 20:17, 3 February 2007
			
Line 341:
Line 341:
  == Introduction to XML Namespaces ==   == Introduction to XML Namespaces ==
    
− {{improve|This tutorial is not yet finished. In particular, the sections on namespaces are still missing and the SAX example needs to be dbetter described}} + If you are working with complex XML files, sooner or later you will realize that you are using tags and attributes that can be categorized according to their meaning. Even worse, you might encounter tags with the same named used for completely different things. For example, if you are managing a large document describing books and their authors, you might use a <title> element to denote the title of the book, as well as the job title of the author.
    
  + So, clearly there should be a way to distinguish these two elements with the same name, but different usages. This can be done via XML namespaces, using prefixes to the elements. A namespace is a unique URI (not necessarily a URL!), e.g. "http://reinhold.kainhofer.com/ns/qtdom-examples" or "urn:kde:developer:tutorials:QtDom:holidays". Rathern than using these long and awkward URIs with each element, you have to define a prefix for each of the namespaces. This is done via an 
  + <code xml>
  +   xmlns:yourprefix="your:namespace:uri"
  + </code>
  + attribute to the element or any of its parents. This defines the "yourprefix" prefix as a shortcut to the full namespace URI "your:namespace:uri". Usually, the namespace declaration is added to the root element of hte XML file. To use an element from this namespace, you can simply prepend the prefix to the tag name: <yourprefix:tag>. This tag name together with the prefix is called the "qualified name" (or in short qName) or the element. The various parts of the element (which you will find in the Qt DOM API, too), are:
    
− {{tip|See also the Qt documentation on namespaces (available at the {{qt|QtXML}} page) for a nice example of an xml file where namespaces are useful.}} + | yourprefix:tag     | qualified name (qName) |
  + | yourprefix         | prefix                 |
  + | tag                | local name |
  + | your:namespace:uri | Namespace URI |
    
  + (As a side note: If an element does not use any namespaces and thus also no prefix, e.g. <tag>, all these parts of the qName are empty and only the "tag name" is set to "tag".)
  + 
  + Using this new knowledge about namespaces, of course, we want to generate and process holiday files with proper namespaces. For example, we could define all the tags to be in the namespace "urn:kde:developer:tutorials:QtDom:holidays", indicated by the prefix "h". A typical XML file would then look like:
    
  <code xml>   <code xml>
  <?xml version='1.0' encoding='UTF-8'?>   <?xml version='1.0' encoding='UTF-8'?>
− <h:holidays  xmlns:h="urn:kde:developer:tutorials:QtDom:holidays" h:country="at"> + <h:holidays xmlns:h="urn:kde:developer:tutorials:QtDom:holidays"
  +             h:country="at">
     <h:holiday>      <h:holiday>
       <h:name>New Year's Day</h:name>        <h:name>New Year's Day</h:name>
Line 360:
Line 372:
  </h:holidays>   </h:holidays>
  </code>   </code>
  + 
  + == Generating XML documents with namespaces using Qt ==
  + 
  + So far, we created elements (without namespaces) using the QDomDocument:createElement(...) method.
    
  == Generating XML documents with namespaces using Qt ==   == Generating XML documents with namespaces using Qt ==