| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_xmloff.hxx" |
| |
| #include "DomExport.hxx" |
| |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/xmlexp.hxx> |
| #include "xmloff/xmlerror.hxx" |
| |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/uno/Reference.hxx> |
| #include <com/sun/star/uno/Sequence.hxx> |
| #include <com/sun/star/xml/dom/XAttr.hpp> |
| #include <com/sun/star/xml/dom/XDocumentBuilder.hpp> |
| #include <com/sun/star/xml/dom/XNode.hpp> |
| #include <com/sun/star/xml/dom/XElement.hpp> |
| #include <com/sun/star/xml/dom/XEntity.hpp> |
| #include <com/sun/star/xml/dom/XNotation.hpp> |
| #include <com/sun/star/xml/sax/XAttributeList.hpp> |
| #include <com/sun/star/xml/dom/NodeType.hpp> |
| #include <com/sun/star/xml/dom/XNamedNodeMap.hpp> |
| |
| #include <rtl/ustring.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <tools/debug.hxx> |
| |
| #include <unotools/processfactory.hxx> |
| |
| #include <vector> |
| |
| |
| using com::sun::star::lang::XMultiServiceFactory; |
| using com::sun::star::uno::Reference; |
| using com::sun::star::uno::Sequence; |
| using com::sun::star::uno::UNO_QUERY; |
| using com::sun::star::uno::UNO_QUERY_THROW; |
| using std::vector; |
| |
| using namespace com::sun::star::xml::dom; |
| |
| using rtl::OUString; |
| using rtl::OUStringBuffer; |
| |
| |
| class DomVisitor |
| { |
| public: |
| DomVisitor() {} |
| virtual ~DomVisitor() {} |
| virtual void element( const Reference<XElement>& ) {} |
| virtual void character( const Reference<XCharacterData>& ) {} |
| virtual void attribute( const Reference<XAttr>& ) {} |
| virtual void cdata( const Reference<XCDATASection>& ) {} |
| virtual void comment( const Reference<XComment>& ) {} |
| virtual void documentFragment( const Reference<XDocumentFragment>& ) {} |
| virtual void document( const Reference<XDocument>& ) {} |
| virtual void documentType( const Reference<XDocumentType>& ) {} |
| virtual void entity( const Reference<XEntity>& ) {} |
| virtual void entityReference( const Reference<XEntityReference>& ) {} |
| virtual void notation( const Reference<XNotation>& ) {} |
| virtual void processingInstruction( const Reference<XProcessingInstruction>& ) {} |
| virtual void endElement( const Reference<XElement>& ) {} |
| }; |
| |
| void visit( DomVisitor&, const Reference<XDocument>& ); |
| void visit( DomVisitor&, const Reference<XNode>& ); |
| |
| |
| |
| void visitNode( DomVisitor& rVisitor, const Reference<XNode>& xNode ) |
| { |
| switch( xNode->getNodeType() ) |
| { |
| case NodeType_ATTRIBUTE_NODE: |
| rVisitor.attribute( Reference<XAttr>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_CDATA_SECTION_NODE: |
| rVisitor.cdata( Reference<XCDATASection>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_COMMENT_NODE: |
| rVisitor.comment( Reference<XComment>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_DOCUMENT_FRAGMENT_NODE: |
| rVisitor.documentFragment( Reference<XDocumentFragment>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_DOCUMENT_NODE: |
| rVisitor.document( Reference<XDocument>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_DOCUMENT_TYPE_NODE: |
| rVisitor.documentType( Reference<XDocumentType>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_ELEMENT_NODE: |
| rVisitor.element( Reference<XElement>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_ENTITY_NODE: |
| rVisitor.entity( Reference<XEntity>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_ENTITY_REFERENCE_NODE: |
| rVisitor.entityReference( Reference<XEntityReference>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_NOTATION_NODE: |
| rVisitor.notation( Reference<XNotation>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_PROCESSING_INSTRUCTION_NODE: |
| rVisitor.processingInstruction( Reference<XProcessingInstruction>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| case NodeType_TEXT_NODE: |
| rVisitor.character( Reference<XCharacterData>( xNode, UNO_QUERY_THROW ) ); |
| break; |
| default: |
| DBG_ERROR( "unknown DOM node type" ); |
| break; |
| } |
| } |
| |
| void visit( DomVisitor& rVisitor, const Reference<XDocument>& xDocument ) |
| { |
| visit( rVisitor, Reference<XNode>( xDocument, UNO_QUERY_THROW ) ); |
| } |
| |
| void visit( DomVisitor& rVisitor, const Reference<XNode>& xNode ) |
| { |
| visitNode( rVisitor, xNode ); |
| for( Reference<XNode> xChild = xNode->getFirstChild(); |
| xChild.is(); |
| xChild = xChild->getNextSibling() ) |
| { |
| visit( rVisitor, xChild ); |
| } |
| if( xNode->getNodeType() == NodeType_ELEMENT_NODE ) |
| rVisitor.endElement( Reference<XElement>( xNode, UNO_QUERY_THROW ) ); |
| } |
| |
| |
| |
| class DomExport: public DomVisitor |
| { |
| SvXMLExport& mrExport; |
| vector<SvXMLNamespaceMap> maNamespaces; |
| |
| void pushNamespace(); |
| void popNamespace(); |
| void addNamespace( const OUString& sPrefix, const OUString& sURI ); |
| OUString qualifiedName( const OUString& sPrefix, const OUString& sURI, |
| const OUString& sLocalName ); |
| OUString qualifiedName( const Reference<XNode>& ); |
| OUString qualifiedName( const Reference<XElement>& ); |
| OUString qualifiedName( const Reference<XAttr>& ); |
| void addAttribute( const Reference<XAttr>& ); |
| |
| public: |
| |
| DomExport( SvXMLExport& rExport ); |
| virtual ~DomExport(); |
| |
| virtual void element( const Reference<XElement>& ); |
| virtual void endElement( const Reference<XElement>& ); |
| virtual void character( const Reference<XCharacterData>& ); |
| }; |
| |
| DomExport::DomExport( SvXMLExport& rExport ) : |
| mrExport( rExport ) |
| { |
| maNamespaces.push_back( rExport.GetNamespaceMap() ); |
| } |
| |
| DomExport::~DomExport() |
| { |
| DBG_ASSERT( maNamespaces.size() == 1, "namespace missing" ); |
| maNamespaces.clear(); |
| } |
| |
| void DomExport::pushNamespace() |
| { |
| maNamespaces.push_back( maNamespaces.back() ); |
| } |
| |
| void DomExport::popNamespace() |
| { |
| maNamespaces.pop_back(); |
| } |
| |
| void DomExport::addNamespace( const OUString& sPrefix, const OUString& sURI ) |
| { |
| SvXMLNamespaceMap& rMap = maNamespaces.back(); |
| sal_uInt16 nKey = rMap.GetKeyByPrefix( sPrefix ); |
| |
| // we need to register the namespace, if either the prefix isn't known or |
| // is used for a different namespace |
| if( nKey == XML_NAMESPACE_UNKNOWN || |
| rMap.GetNameByKey( nKey ) != sURI ) |
| { |
| // add prefix to map, and add declaration |
| rMap.Add( sPrefix, sURI ); |
| mrExport.AddAttribute( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( "xmlns:" ) ) + sPrefix, |
| sURI ); |
| } |
| } |
| |
| OUString DomExport::qualifiedName( const OUString& sPrefix, |
| const OUString& sURI, |
| const OUString& sLocalName ) |
| { |
| OUStringBuffer sBuffer; |
| if( ( sPrefix.getLength() > 0 ) && ( sURI.getLength() > 0 ) ) |
| { |
| addNamespace( sPrefix, sURI ); |
| sBuffer.append( sPrefix ); |
| sBuffer.append( sal_Unicode( ':' ) ); |
| } |
| sBuffer.append( sLocalName ); |
| return sBuffer.makeStringAndClear(); |
| } |
| |
| OUString DomExport::qualifiedName( const Reference<XNode>& xNode ) |
| { |
| return qualifiedName( xNode->getPrefix(), xNode->getNamespaceURI(), |
| xNode->getNodeName() ); |
| } |
| |
| OUString DomExport::qualifiedName( const Reference<XElement>& xElement ) |
| { |
| return qualifiedName( xElement->getPrefix(), xElement->getNamespaceURI(), |
| xElement->getNodeName() ); |
| } |
| |
| OUString DomExport::qualifiedName( const Reference<XAttr>& xAttr ) |
| { |
| return qualifiedName( xAttr->getPrefix(), xAttr->getNamespaceURI(), |
| xAttr->getNodeName() ); |
| } |
| |
| void DomExport::addAttribute( const Reference<XAttr>& xAttribute ) |
| { |
| mrExport.AddAttribute( qualifiedName( xAttribute ), |
| xAttribute->getNodeValue() ); |
| } |
| |
| void DomExport::element( const Reference<XElement>& xElement ) |
| { |
| pushNamespace(); |
| |
| // write attributes |
| Reference<XNamedNodeMap> xAttributes = xElement->getAttributes(); |
| sal_Int32 nLength = xAttributes.is() ? xAttributes->getLength() : 0; |
| for( sal_Int32 n = 0; n < nLength; n++ ) |
| { |
| addAttribute( Reference<XAttr>( xAttributes->item( n ), UNO_QUERY_THROW ) ); |
| } |
| |
| // write name |
| mrExport.StartElement( qualifiedName( xElement ), sal_False ); |
| } |
| |
| void DomExport::endElement( const Reference<XElement>& xElement ) |
| { |
| mrExport.EndElement( qualifiedName( xElement ), sal_False ); |
| popNamespace(); |
| } |
| |
| void DomExport::character( const Reference<XCharacterData>& xChars ) |
| { |
| mrExport.Characters( xChars->getNodeValue() ); |
| } |
| |
| |
| void exportDom( SvXMLExport& rExport, const Reference<XDocument>& xDocument ) |
| { |
| DomExport aDomExport( rExport ); |
| visit( aDomExport, xDocument ); |
| } |
| |
| void exportDom( SvXMLExport& rExport, const Reference<XNode>& xNode ) |
| { |
| DomExport aDomExport( rExport ); |
| visit( aDomExport, xNode ); |
| } |