xmloff/source/core/DomExport.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <DomExport.hxx>
  22
  23 #include <xmloff/nmspmap.hxx>
  24 #include <xmloff/xmlexp.hxx>
  25 #include <xmloff/xmlerror.hxx>
  26
  27 #include <com/sun/star/uno/Reference.hxx>
  28 #include <com/sun/star/xml/dom/XAttr.hpp>
  29 #include <com/sun/star/xml/dom/XNode.hpp>
  30 #include <com/sun/star/xml/dom/XElement.hpp>
  31 #include <com/sun/star/xml/dom/NodeType.hpp>
  32 #include <com/sun/star/xml/dom/XNamedNodeMap.hpp>
  33
  34 #include <rtl/ustring.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <sal/log.hxx>
  37 #include <osl/diagnose.h>
  38
  39
  40 #include <vector>
  41
  42
  43 using com::sun::star::uno::Reference;
  44 using com::sun::star::uno::UNO_QUERY_THROW;
  45 using std::vector;
  46
  47 using namespace com::sun::star::xml::dom;
  48
  49
  50 class DomVisitor
  51 {
  52 public:
  53     DomVisitor() {}
  54     virtual ~DomVisitor() {}
  55     virtual void element( const Reference<XElement>& ) {}
  56     virtual void character( const Reference<XCharacterData>& ) {}
  57     virtual void endElement( const Reference<XElement>& ) {}
  58 };
  59
  60 static void visit( DomVisitor&, const Reference<XDocument>& );
  61 static void visit( DomVisitor&, const Reference<XNode>& );
  62
  63
  64 static void visitNode( DomVisitor& rVisitor, const Reference<XNode>& xNode )
  65 {
  66     switch( xNode->getNodeType() )
  67     {
  68     case NodeType_ATTRIBUTE_NODE:
  69         break;
  70     case NodeType_CDATA_SECTION_NODE:
  71         break;
  72     case NodeType_COMMENT_NODE:
  73         break;
  74     case NodeType_DOCUMENT_FRAGMENT_NODE:
  75         break;
  76     case NodeType_DOCUMENT_NODE:
  77         break;
  78     case NodeType_DOCUMENT_TYPE_NODE:
  79         break;
  80     case NodeType_ELEMENT_NODE:
  81         rVisitor.element( Reference<XElement>( xNode, UNO_QUERY_THROW ) );
  82         break;
  83     case NodeType_ENTITY_NODE:
  84         break;
  85     case NodeType_ENTITY_REFERENCE_NODE:
  86         break;
  87     case NodeType_NOTATION_NODE:
  88         break;
  89     case NodeType_PROCESSING_INSTRUCTION_NODE:
  90         break;
  91     case NodeType_TEXT_NODE:
  92         rVisitor.character( Reference<XCharacterData>( xNode, UNO_QUERY_THROW ) );
  93         break;
  94     default:
  95         OSL_FAIL( "unknown DOM node type" );
  96         break;
  97     }
  98 }
  99
 100 void visit( DomVisitor& rVisitor, const Reference<XDocument>& xDocument )
 101 {
 102     visit( rVisitor, Reference<XNode>( xDocument, UNO_QUERY_THROW ) );
 103 }
 104
 105 void visit( DomVisitor& rVisitor, const Reference<XNode>& xNode )
 106 {
 107     visitNode( rVisitor, xNode );
 108     for( Reference<XNode> xChild = xNode->getFirstChild();
 109          xChild.is();
 110          xChild = xChild->getNextSibling() )
 111     {
 112         visit( rVisitor, xChild );
 113     }
 114     if( xNode->getNodeType() == NodeType_ELEMENT_NODE )
 115         rVisitor.endElement( Reference<XElement>( xNode, UNO_QUERY_THROW ) );
 116 }
 117
 118
 119 class DomExport: public DomVisitor
 120 {
 121     SvXMLExport& mrExport;
 122     vector<SvXMLNamespaceMap> maNamespaces;
 123
 124     void pushNamespace();
 125     void addNamespace( const OUString& sPrefix, const OUString& sURI );
 126     OUString qualifiedName( const OUString& sPrefix, const OUString& sURI,
 127                             const OUString& sLocalName );
 128     OUString qualifiedName( const Reference<XElement>&  );
 129     OUString qualifiedName( const Reference<XAttr>&  );
 130     void addAttribute( const Reference<XAttr>& );
 131
 132 public:
 133
 134     explicit DomExport( SvXMLExport& rExport );
 135     virtual ~DomExport() override;
 136
 137     virtual void element( const Reference<XElement>& ) override;
 138     virtual void endElement( const Reference<XElement>& ) override;
 139     virtual void character( const Reference<XCharacterData>& ) override;
 140 };
 141
 142 DomExport::DomExport( SvXMLExport& rExport ) :
 143     mrExport( rExport )
 144 {
 145     maNamespaces.push_back( rExport.GetNamespaceMap() );
 146 }
 147
 148 DomExport::~DomExport()
 149 {
 150     SAL_WARN_IF( maNamespaces.size() != 1, "xmloff", "namespace missing" );
 151     maNamespaces.clear();
 152 }
 153
 154 void DomExport::pushNamespace()
 155 {
 156     SvXMLNamespaceMap const aMap(maNamespaces.back());
 157     maNamespaces.push_back(aMap);
 158 }
 159
 160 void DomExport::addNamespace( const OUString& sPrefix, const OUString& sURI )
 161 {
 162     SvXMLNamespaceMap& rMap = maNamespaces.back();
 163     sal_uInt16 nKey = rMap.GetKeyByPrefix( sPrefix );
 164
 165     // we need to register the namespace, if either the prefix isn't known or
 166     // is used for a different namespace
 167     if( nKey == XML_NAMESPACE_UNKNOWN  ||
 168         rMap.GetNameByKey( nKey ) != sURI )
 169     {
 170         // add prefix to map, and add declaration
 171         rMap.Add( sPrefix, sURI );
 172         mrExport.AddAttribute( "xmlns:" + sPrefix, sURI );
 173     }
 174 }
 175
 176 OUString DomExport::qualifiedName( const OUString& sPrefix,
 177                                    const OUString& sURI,
 178                                    const OUString& sLocalName )
 179 {
 180     OUStringBuffer sBuffer;
 181     if( !sPrefix.isEmpty() && !sURI.isEmpty() )
 182     {
 183         addNamespace( sPrefix, sURI );
 184         sBuffer.append( sPrefix );
 185         sBuffer.append( ':' );
 186     }
 187     sBuffer.append( sLocalName );
 188     return sBuffer.makeStringAndClear();
 189 }
 190
 191 OUString DomExport::qualifiedName( const Reference<XElement>& xElement )
 192 {
 193     return qualifiedName( xElement->getPrefix(), xElement->getNamespaceURI(),
 194                           xElement->getNodeName() );
 195 }
 196
 197 OUString DomExport::qualifiedName( const Reference<XAttr>& xAttr )
 198 {
 199     return qualifiedName( xAttr->getPrefix(), xAttr->getNamespaceURI(),
 200                           xAttr->getNodeName() );
 201 }
 202
 203 void DomExport::addAttribute( const Reference<XAttr>& xAttribute )
 204 {
 205     mrExport.AddAttribute( qualifiedName( xAttribute ),
 206                            xAttribute->getNodeValue() );
 207 }
 208
 209 void DomExport::element( const Reference<XElement>& xElement )
 210 {
 211     pushNamespace();
 212
 213     // write attributes
 214     Reference<XNamedNodeMap> xAttributes = xElement->getAttributes();
 215     sal_Int32 nLength = xAttributes.is() ? xAttributes->getLength() : 0;
 216     for( sal_Int32 n = 0; n < nLength; n++ )
 217     {
 218         addAttribute( Reference<XAttr>( xAttributes->item( n ), UNO_QUERY_THROW ) );
 219     }
 220
 221     // write name
 222     mrExport.StartElement( qualifiedName( xElement ), false );
 223 }
 224
 225 void DomExport::endElement( const Reference<XElement>& xElement )
 226 {
 227     mrExport.EndElement( qualifiedName( xElement ), false );
 228     maNamespaces.pop_back();
 229 }
 230
 231 void DomExport::character( const Reference<XCharacterData>& xChars )
 232 {
 233     mrExport.Characters( xChars->getNodeValue() );
 234 }
 235
 236
 237 void exportDom( SvXMLExport& rExport, const Reference<XDocument>& xDocument )
 238 {
 239     DomExport aDomExport( rExport );
 240     visit( aDomExport, xDocument );
 241 }
 242
 243 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */