| /************************************************************** |
| * |
| * 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_svx.hxx" |
| #include <tools/debug.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <com/sun/star/xml/sax/InputSource.hpp> |
| #include <com/sun/star/xml/sax/XParser.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/xml/sax/XDocumentHandler.hpp> |
| #include <com/sun/star/lang/XComponent.hpp> |
| #include <com/sun/star/io/XActiveDataSource.hpp> |
| #include <com/sun/star/xml/sax/SAXParseException.hpp> |
| #include <com/sun/star/io/XOutputStream.hpp> |
| #include <com/sun/star/document/XFilter.hpp> |
| #include <com/sun/star/document/XExporter.hpp> |
| #include <com/sun/star/document/XImporter.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <unotools/streamwrap.hxx> |
| #include <sot/storage.hxx> |
| #include <svx/svdmodel.hxx> |
| #include <svx/xmleohlp.hxx> |
| #include <svx/xmlgrhlp.hxx> |
| |
| #include <svx/unomodel.hxx> |
| |
| using ::rtl::OUString; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| |
| sal_Bool SvxDrawingLayerExport( SdrModel* pModel, const uno::Reference<io::XOutputStream>& xOut, const Reference< lang::XComponent >& xComponent ) |
| { |
| return SvxDrawingLayerExport( pModel, xOut, xComponent, "com.sun.star.comp.DrawingLayer.XMLExporter" ); |
| } |
| |
| sal_Bool SvxDrawingLayerExport( SdrModel* pModel, const uno::Reference<io::XOutputStream>& xOut, const Reference< lang::XComponent >& xComponent, const char* pExportService ) |
| { |
| sal_Bool bDocRet = xOut.is(); |
| |
| Reference< document::XGraphicObjectResolver > xGraphicResolver; |
| SvXMLGraphicHelper *pGraphicHelper = 0; |
| |
| Reference< document::XEmbeddedObjectResolver > xObjectResolver; |
| SvXMLEmbeddedObjectHelper *pObjectHelper = 0; |
| |
| Reference< lang::XComponent > xSourceDoc( xComponent ); |
| try |
| { |
| if( !xSourceDoc.is() ) |
| { |
| xSourceDoc = new SvxUnoDrawingModel( pModel ); |
| pModel->setUnoModel( Reference< XInterface >::query( xSourceDoc ) ); |
| } |
| |
| uno::Reference< lang::XMultiServiceFactory> xServiceFactory( ::comphelper::getProcessServiceFactory() ); |
| if( !xServiceFactory.is() ) |
| { |
| DBG_ERROR( "got no service manager" ); |
| bDocRet = sal_False; |
| } |
| |
| if( bDocRet ) |
| { |
| uno::Reference< uno::XInterface > xWriter( xServiceFactory->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer" ) ) ) ); |
| if( !xWriter.is() ) |
| { |
| DBG_ERROR( "com.sun.star.xml.sax.Writer service missing" ); |
| bDocRet = sal_False; |
| } |
| |
| ::comphelper::IEmbeddedHelper *pPersist = pModel->GetPersist(); |
| if( pPersist ) |
| { |
| pObjectHelper = SvXMLEmbeddedObjectHelper::Create( *pPersist, EMBEDDEDOBJECTHELPER_MODE_WRITE ); |
| xObjectResolver = pObjectHelper; |
| } |
| |
| pGraphicHelper = SvXMLGraphicHelper::Create( GRAPHICHELPER_MODE_WRITE ); |
| xGraphicResolver = pGraphicHelper; |
| |
| if( bDocRet ) |
| { |
| uno::Reference<xml::sax::XDocumentHandler> xHandler( xWriter, uno::UNO_QUERY ); |
| |
| // doc export |
| uno::Reference< io::XActiveDataSource > xDocSrc( xWriter, uno::UNO_QUERY ); |
| xDocSrc->setOutputStream( xOut ); |
| |
| uno::Sequence< uno::Any > aArgs( xObjectResolver.is() ? 3 : 2 ); |
| aArgs[0] <<= xHandler; |
| aArgs[1] <<= xGraphicResolver; |
| if( xObjectResolver.is() ) |
| aArgs[2] <<= xObjectResolver; |
| |
| uno::Reference< document::XFilter > xFilter( xServiceFactory->createInstanceWithArguments( OUString::createFromAscii( pExportService ), aArgs ), uno::UNO_QUERY ); |
| if( !xFilter.is() ) |
| { |
| DBG_ERROR( "com.sun.star.comp.Draw.XMLExporter service missing" ); |
| bDocRet = sal_False; |
| } |
| |
| if( bDocRet ) |
| { |
| uno::Reference< document::XExporter > xExporter( xFilter, uno::UNO_QUERY ); |
| if( xExporter.is() ) |
| { |
| xExporter->setSourceDocument( xSourceDoc ); |
| |
| uno::Sequence< beans::PropertyValue > aDescriptor( 0 ); |
| bDocRet = xFilter->filter( aDescriptor ); |
| } |
| } |
| } |
| } |
| } |
| catch(uno::Exception e) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| bDocRet = sal_False; |
| } |
| |
| if( pGraphicHelper ) |
| SvXMLGraphicHelper::Destroy( pGraphicHelper ); |
| xGraphicResolver = 0; |
| |
| if( pObjectHelper ) |
| SvXMLEmbeddedObjectHelper::Destroy( pObjectHelper ); |
| xObjectResolver = 0; |
| |
| return bDocRet; |
| } |
| |
| sal_Bool SvxDrawingLayerExport( SdrModel* pModel, const uno::Reference<io::XOutputStream>& xOut ) |
| { |
| Reference< lang::XComponent > xComponent; |
| return SvxDrawingLayerExport( pModel, xOut, xComponent ); |
| } |
| |
| //-//////////////////////////////////////////////////////////////////// |
| |
| sal_Bool SvxDrawingLayerImport( SdrModel* pModel, const uno::Reference<io::XInputStream>& xInputStream, const Reference< lang::XComponent >& xComponent ) |
| { |
| return SvxDrawingLayerImport( pModel, xInputStream, xComponent, "com.sun.star.comp.Draw.XMLOasisImporter" ); |
| } |
| |
| sal_Bool SvxDrawingLayerImport( SdrModel* pModel, const uno::Reference<io::XInputStream>& xInputStream, const Reference< lang::XComponent >& xComponent, const char* pImportService ) |
| { |
| sal_uInt32 nRet = 0; |
| |
| Reference< document::XGraphicObjectResolver > xGraphicResolver; |
| SvXMLGraphicHelper *pGraphicHelper = 0; |
| |
| Reference< document::XEmbeddedObjectResolver > xObjectResolver; |
| SvXMLEmbeddedObjectHelper *pObjectHelper = 0; |
| |
| Reference< lang::XComponent > xTargetDocument( xComponent ); |
| if( !xTargetDocument.is() ) |
| { |
| xTargetDocument = new SvxUnoDrawingModel( pModel ); |
| pModel->setUnoModel( Reference< XInterface >::query( xTargetDocument ) ); |
| } |
| |
| Reference< frame::XModel > xTargetModel( xTargetDocument, UNO_QUERY ); |
| |
| try |
| { |
| // Get service factory |
| Reference< lang::XMultiServiceFactory > xServiceFactory = comphelper::getProcessServiceFactory(); |
| DBG_ASSERT( xServiceFactory.is(), "XMLReader::Read: got no service manager" ); |
| |
| if( !xServiceFactory.is() ) |
| nRet = 1; |
| |
| if( 0 == nRet ) |
| { |
| if ( xTargetModel.is() ) |
| xTargetModel->lockControllers(); |
| |
| // ------------------------------------- |
| |
| pGraphicHelper = SvXMLGraphicHelper::Create( GRAPHICHELPER_MODE_READ ); |
| xGraphicResolver = pGraphicHelper; |
| |
| ::comphelper::IEmbeddedHelper *pPersist = pModel->GetPersist(); |
| if( pPersist ) |
| { |
| pObjectHelper = SvXMLEmbeddedObjectHelper::Create( |
| *pPersist, |
| EMBEDDEDOBJECTHELPER_MODE_READ ); |
| xObjectResolver = pObjectHelper; |
| } |
| } |
| |
| // ------------------------------------- |
| |
| if( 0 == nRet ) |
| { |
| |
| // parse |
| // prepare ParserInputSrouce |
| xml::sax::InputSource aParserInput; |
| aParserInput.aInputStream = xInputStream; |
| |
| // get parser |
| Reference< xml::sax::XParser > xParser( xServiceFactory->createInstance( OUString::createFromAscii("com.sun.star.xml.sax.Parser") ), UNO_QUERY ); |
| DBG_ASSERT( xParser.is(), "Can't create parser" ); |
| |
| // prepare filter arguments |
| Sequence<Any> aFilterArgs( 2 ); |
| Any *pArgs = aFilterArgs.getArray(); |
| *pArgs++ <<= xGraphicResolver; |
| *pArgs++ <<= xObjectResolver; |
| |
| // get filter |
| Reference< xml::sax::XDocumentHandler > xFilter( xServiceFactory->createInstanceWithArguments( OUString::createFromAscii( pImportService ), aFilterArgs), UNO_QUERY ); |
| DBG_ASSERT( xFilter.is(), "Can't instantiate filter component." ); |
| |
| nRet = 1; |
| if( xParser.is() && xFilter.is() ) |
| { |
| // connect parser and filter |
| xParser->setDocumentHandler( xFilter ); |
| |
| // connect model and filter |
| uno::Reference < document::XImporter > xImporter( xFilter, UNO_QUERY ); |
| xImporter->setTargetDocument( xTargetDocument ); |
| |
| // finally, parser the stream |
| xParser->parseStream( aParserInput ); |
| |
| nRet = 0; |
| } |
| } |
| } |
| catch( uno::Exception& r ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| if( pGraphicHelper ) |
| SvXMLGraphicHelper::Destroy( pGraphicHelper ); |
| xGraphicResolver = 0; |
| |
| if( pObjectHelper ) |
| SvXMLEmbeddedObjectHelper::Destroy( pObjectHelper ); |
| xObjectResolver = 0; |
| |
| if ( xTargetModel.is() ) |
| xTargetModel->unlockControllers(); |
| |
| return nRet == 0; |
| } |
| |
| sal_Bool SvxDrawingLayerImport( SdrModel* pModel, const uno::Reference<io::XInputStream>& xInputStream ) |
| { |
| Reference< lang::XComponent > xComponent; |
| return SvxDrawingLayerImport( pModel, xInputStream, xComponent ); |
| } |