| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| #include "precompiled_reportdesign.hxx" |
| #include <com/sun/star/packages/zip/ZipIOException.hpp> |
| #include <com/sun/star/embed/ElementModes.hpp> |
| #include <com/sun/star/beans/NamedValue.hpp> |
| #include <com/sun/star/sdb/XOfficeDatabaseDocument.hpp> |
| #include "xmlfilter.hxx" |
| #include "xmlGroup.hxx" |
| #include "xmlReport.hxx" |
| #include "xmlHelper.hxx" |
| #include <vcl/svapp.hxx> |
| #include <vcl/window.hxx> |
| #include <connectivity/dbtools.hxx> |
| #include <xmloff/xmlnmspe.hxx> |
| #include <xmloff/xmltoken.hxx> |
| #include <xmloff/txtimp.hxx> |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/XMLFontStylesContext.hxx> |
| #include <rtl/logfile.hxx> |
| #include <com/sun/star/xml/sax/InputSource.hpp> |
| #include <com/sun/star/xml/sax/XParser.hpp> |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| |
| #include <comphelper/genericpropertyset.hxx> |
| #include <comphelper/mediadescriptor.hxx> |
| #include <xmloff/ProgressBarHelper.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <com/sun/star/io/XInputStream.hpp> |
| #include <com/sun/star/uno/XNamingService.hpp> |
| #include <tools/urlobj.hxx> |
| #include <xmloff/DocumentSettingsContext.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include <xmloff/xmlmetai.hxx> |
| #include <com/sun/star/util/XModifiable.hpp> |
| #include <vcl/svapp.hxx> |
| #include <vos/mutex.hxx> |
| #include <svtools/sfxecode.hxx> |
| #include "xmlEnums.hxx" |
| #include "xmlStyleImport.hxx" |
| #include "xmlstrings.hrc" |
| #include "xmlPropertyHandler.hxx" |
| #include <xmloff/txtprmap.hxx> |
| #include "ReportDefinition.hxx" |
| |
| |
| #define MAP_LEN(x) x, sizeof(x) - 1 |
| //-------------------------------------------------------------------------- |
| namespace rptxml |
| { |
| using namespace ::com::sun::star::uno; |
| using ::com::sun::star::uno::Reference; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::document; |
| using namespace ::com::sun::star::text; |
| using namespace ::com::sun::star::io; |
| using namespace ::com::sun::star::report; |
| using namespace ::com::sun::star::xml::sax; |
| using namespace xmloff; |
| sal_Char __READONLY_DATA sXML_np__rpt[] = "_report"; |
| sal_Char __READONLY_DATA sXML_np___rpt[] = "__report"; |
| |
| using namespace ::com::sun::star::util; |
| |
| class RptMLMasterStylesContext_Impl : public XMLTextMasterStylesContext |
| { |
| ORptFilter& m_rImport; |
| RptMLMasterStylesContext_Impl(const RptMLMasterStylesContext_Impl&); |
| void operator =(const RptMLMasterStylesContext_Impl&); |
| public: |
| |
| TYPEINFO(); |
| |
| RptMLMasterStylesContext_Impl( |
| ORptFilter& rImport, sal_uInt16 nPrfx, |
| const ::rtl::OUString& rLName , |
| const uno::Reference< xml::sax::XAttributeList > & xAttrList ); |
| virtual ~RptMLMasterStylesContext_Impl(); |
| virtual void EndElement(); |
| }; |
| |
| TYPEINIT1( RptMLMasterStylesContext_Impl, XMLTextMasterStylesContext ); |
| DBG_NAME(rpt_RptMLMasterStylesContext_Impl) |
| RptMLMasterStylesContext_Impl::RptMLMasterStylesContext_Impl( |
| ORptFilter& rImport, sal_uInt16 nPrfx, |
| const ::rtl::OUString& rLName , |
| const uno::Reference< xml::sax::XAttributeList > & xAttrList ) : |
| XMLTextMasterStylesContext( rImport, nPrfx, rLName, xAttrList ) |
| ,m_rImport(rImport) |
| { |
| DBG_CTOR(rpt_RptMLMasterStylesContext_Impl,NULL); |
| } |
| |
| RptMLMasterStylesContext_Impl::~RptMLMasterStylesContext_Impl() |
| { |
| DBG_DTOR(rpt_RptMLMasterStylesContext_Impl,NULL); |
| } |
| |
| void RptMLMasterStylesContext_Impl::EndElement() |
| { |
| FinishStyles( sal_True ); |
| m_rImport.FinishStyles(); |
| } |
| /// read a component (file + filter version) |
| sal_Int32 ReadThroughComponent( |
| const uno::Reference<XInputStream>& xInputStream, |
| const uno::Reference<XComponent>& xModelComponent, |
| const sal_Char* /*pStreamName*/, |
| const uno::Reference<XMultiServiceFactory> & rFactory, |
| const uno::Reference< XDocumentHandler >& _xFilter, |
| sal_Bool /*bEncrypted*/ ) |
| { |
| DBG_ASSERT(xInputStream.is(), "input stream missing"); |
| DBG_ASSERT(xModelComponent.is(), "document missing"); |
| DBG_ASSERT(rFactory.is(), "factory missing"); |
| |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLog, "rptxml", "oj", "ReadThroughComponent" ); |
| |
| // prepare ParserInputSrouce |
| InputSource aParserInput; |
| aParserInput.aInputStream = xInputStream; |
| |
| // get parser |
| uno::Reference< XParser > xParser( |
| rFactory->createInstance( |
| ::rtl::OUString::createFromAscii("com.sun.star.xml.sax.Parser") ), |
| UNO_QUERY ); |
| DBG_ASSERT( xParser.is(), "Can't create parser" ); |
| if( !xParser.is() ) |
| return 1; |
| RTL_LOGFILE_CONTEXT_TRACE( aLog, "parser created" ); |
| |
| // get filter |
| DBG_ASSERT( _xFilter.is(), "Can't instantiate filter component." ); |
| if( !_xFilter.is() ) |
| return 1; |
| |
| // connect parser and filter |
| xParser->setDocumentHandler( _xFilter ); |
| |
| // connect model and filter |
| uno::Reference < XImporter > xImporter( _xFilter, UNO_QUERY ); |
| xImporter->setTargetDocument( xModelComponent ); |
| |
| |
| #ifdef TIMELOG |
| // if we do profiling, we want to know the stream |
| RTL_LOGFILE_TRACE_AUTHOR1( "rptxml", "oj", |
| "ReadThroughComponent : parsing \"%s\"", pStreamName ); |
| #endif |
| |
| // finally, parser the stream |
| try |
| { |
| xParser->parseStream( aParserInput ); |
| } |
| catch( SAXParseException& |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| r |
| #endif |
| ) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| ByteString aError( "SAX parse exception catched while importing:\n" ); |
| aError += ByteString( String( r.Message), RTL_TEXTENCODING_ASCII_US ); |
| aError += ByteString::CreateFromInt32( r.LineNumber ); |
| aError += ','; |
| aError += ByteString::CreateFromInt32( r.ColumnNumber ); |
| |
| DBG_ERROR( aError.GetBuffer() ); |
| #endif |
| return 1; |
| } |
| catch( SAXException& ) |
| { |
| return 1; |
| } |
| catch( packages::zip::ZipIOException& ) |
| { |
| return ERRCODE_IO_BROKENPACKAGE; |
| } |
| catch( IOException& ) |
| { |
| return 1; |
| } |
| catch( Exception& ) |
| { |
| return 1; |
| } |
| |
| // success! |
| return 0; |
| } |
| |
| /// read a component (storage version) |
| sal_Int32 ReadThroughComponent( |
| uno::Reference< embed::XStorage > xStorage, |
| const uno::Reference<XComponent>& xModelComponent, |
| const sal_Char* pStreamName, |
| const sal_Char* pCompatibilityStreamName, |
| const uno::Reference<XMultiServiceFactory> & rFactory, |
| const Reference< document::XGraphicObjectResolver > & _xGraphicObjectResolver, |
| const Reference<document::XEmbeddedObjectResolver>& _xEmbeddedObjectResolver, |
| const ::rtl::OUString& _sFilterName |
| ,const uno::Reference<beans::XPropertySet>& _xProp) |
| { |
| DBG_ASSERT( xStorage.is(), "Need storage!"); |
| DBG_ASSERT(NULL != pStreamName, "Please, please, give me a name!"); |
| |
| if ( xStorage.is() ) |
| { |
| uno::Reference< io::XStream > xDocStream; |
| sal_Bool bEncrypted = sal_False; |
| |
| try |
| { |
| // open stream (and set parser input) |
| ::rtl::OUString sStreamName = ::rtl::OUString::createFromAscii(pStreamName); |
| if ( !xStorage->hasByName( sStreamName ) || !xStorage->isStreamElement( sStreamName ) ) |
| { |
| // stream name not found! Then try the compatibility name. |
| // if no stream can be opened, return immediatly with OK signal |
| |
| // do we even have an alternative name? |
| if ( NULL == pCompatibilityStreamName ) |
| return 0; |
| |
| // if so, does the stream exist? |
| sStreamName = ::rtl::OUString::createFromAscii(pCompatibilityStreamName); |
| if ( !xStorage->hasByName( sStreamName ) || !xStorage->isStreamElement( sStreamName ) ) |
| return 0; |
| } |
| |
| // get input stream |
| xDocStream = xStorage->openStreamElement( sStreamName, embed::ElementModes::READ ); |
| |
| uno::Reference< beans::XPropertySet > xProps( xDocStream, uno::UNO_QUERY_THROW ); |
| xProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Encrypted") ) ) >>= bEncrypted; |
| } |
| catch( packages::WrongPasswordException& ) |
| { |
| return ERRCODE_SFX_WRONGPASSWORD; |
| } |
| catch ( uno::Exception& ) |
| { |
| return 1; // TODO/LATER: error handling |
| } |
| |
| sal_Int32 nArgs = 0; |
| if( _xGraphicObjectResolver.is()) |
| nArgs++; |
| if( _xEmbeddedObjectResolver.is()) |
| nArgs++; |
| if ( _xProp.is() ) |
| nArgs++; |
| |
| uno::Sequence< uno::Any > aFilterCompArgs( nArgs ); |
| |
| nArgs = 0; |
| if( _xGraphicObjectResolver.is()) |
| aFilterCompArgs[nArgs++] <<= _xGraphicObjectResolver; |
| if( _xEmbeddedObjectResolver.is()) |
| aFilterCompArgs[ nArgs++ ] <<= _xEmbeddedObjectResolver; |
| if ( _xProp.is() ) |
| aFilterCompArgs[ nArgs++ ] <<= _xProp; |
| |
| Reference< xml::sax::XDocumentHandler > xDocHandler( |
| rFactory->createInstanceWithArguments( _sFilterName, aFilterCompArgs ), |
| uno::UNO_QUERY_THROW ); |
| uno::Reference< XInputStream > xInputStream = xDocStream->getInputStream(); |
| // read from the stream |
| return ReadThroughComponent( xInputStream |
| ,xModelComponent |
| ,pStreamName |
| ,rFactory |
| ,xDocHandler |
| ,bEncrypted ); |
| } |
| |
| // TODO/LATER: better error handling |
| return 1; |
| } |
| |
| //--------------------------------------------------------------------- |
| uno::Reference< uno::XInterface > ORptImportHelper::create(uno::Reference< uno::XComponentContext > const & xContext) |
| { |
| return static_cast< XServiceInfo* >(new ORptFilter(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY),IMPORT_SETTINGS )); |
| } |
| //--------------------------------------------------------------------- |
| ::rtl::OUString ORptImportHelper::getImplementationName_Static( ) throw (RuntimeException) |
| { |
| return ::rtl::OUString(SERVICE_SETTINGSIMPORTER); |
| } |
| //--------------------------------------------------------------------- |
| Sequence< ::rtl::OUString > ORptImportHelper::getSupportedServiceNames_Static( ) throw(RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aSupported(1); |
| aSupported[0] = SERVICE_IMPORTFILTER; |
| return aSupported; |
| } |
| //--------------------------------------------------------------------- |
| Reference< XInterface > ORptContentImportHelper::create(const Reference< XComponentContext > & xContext) |
| { |
| return static_cast< XServiceInfo* >(new ORptFilter(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY),IMPORT_AUTOSTYLES | IMPORT_CONTENT | IMPORT_SCRIPTS | |
| IMPORT_FONTDECLS )); |
| } |
| //--------------------------------------------------------------------- |
| ::rtl::OUString ORptContentImportHelper::getImplementationName_Static( ) throw (RuntimeException) |
| { |
| return ::rtl::OUString(SERVICE_CONTENTIMPORTER); |
| } |
| //--------------------------------------------------------------------- |
| Sequence< ::rtl::OUString > ORptContentImportHelper::getSupportedServiceNames_Static( ) throw(RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aSupported(1); |
| aSupported[0] = SERVICE_IMPORTFILTER; |
| return aSupported; |
| } |
| |
| //--------------------------------------------------------------------- |
| Reference< XInterface > ORptStylesImportHelper::create(Reference< XComponentContext > const & xContext) |
| { |
| return static_cast< XServiceInfo* >(new ORptFilter(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY), |
| IMPORT_STYLES | IMPORT_MASTERSTYLES | IMPORT_AUTOSTYLES | |
| IMPORT_FONTDECLS )); |
| } |
| //--------------------------------------------------------------------- |
| ::rtl::OUString ORptStylesImportHelper::getImplementationName_Static( ) throw (RuntimeException) |
| { |
| return ::rtl::OUString(SERVICE_STYLESIMPORTER); |
| } |
| //--------------------------------------------------------------------- |
| Sequence< ::rtl::OUString > ORptStylesImportHelper::getSupportedServiceNames_Static( ) throw(RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aSupported(1); |
| aSupported[0] = SERVICE_IMPORTFILTER; |
| return aSupported; |
| } |
| |
| //--------------------------------------------------------------------- |
| Reference< XInterface > ORptMetaImportHelper::create(Reference< XComponentContext > const & xContext) |
| { |
| return static_cast< XServiceInfo* >(new ORptFilter(Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY), |
| IMPORT_META)); |
| } |
| //--------------------------------------------------------------------- |
| ::rtl::OUString ORptMetaImportHelper::getImplementationName_Static( ) throw (RuntimeException) |
| { |
| return ::rtl::OUString(SERVICE_METAIMPORTER); |
| } |
| //--------------------------------------------------------------------- |
| Sequence< ::rtl::OUString > ORptMetaImportHelper::getSupportedServiceNames_Static( ) throw(RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aSupported(1); |
| aSupported[0] = SERVICE_IMPORTFILTER; |
| return aSupported; |
| } |
| |
| // ------------- |
| // - ORptFilter - |
| // ------------- |
| DBG_NAME(rpt_ORptFilter) |
| ORptFilter::ORptFilter( const uno::Reference< XMultiServiceFactory >& _rxMSF,sal_uInt16 nImportFlags ) |
| :SvXMLImport(_rxMSF,nImportFlags) |
| { |
| DBG_CTOR(rpt_ORptFilter,NULL); |
| GetMM100UnitConverter().setCoreMeasureUnit(MAP_100TH_MM); |
| GetMM100UnitConverter().setXMLMeasureUnit(MAP_CM); |
| GetNamespaceMap().Add( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__rpt) ), |
| GetXMLToken(XML_N_RPT), |
| XML_NAMESPACE_REPORT ); |
| |
| GetNamespaceMap().Add( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np___rpt) ), |
| GetXMLToken(XML_N_RPT_OASIS), |
| XML_NAMESPACE_REPORT ); |
| |
| m_xPropHdlFactory = new OXMLRptPropHdlFactory; |
| m_xCellStylesPropertySetMapper = OXMLHelper::GetCellStylePropertyMap(true); |
| m_xColumnStylesPropertySetMapper = new XMLPropertySetMapper(OXMLHelper::GetColumnStyleProps(), m_xPropHdlFactory); |
| m_xRowStylesPropertySetMapper = new XMLPropertySetMapper(OXMLHelper::GetRowStyleProps(), m_xPropHdlFactory); |
| m_xTableStylesPropertySetMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_TABLE_DEFAULTS ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| ORptFilter::~ORptFilter() throw() |
| { |
| DBG_DTOR(rpt_ORptFilter,NULL); |
| } |
| //------------------------------------------------------------------------------ |
| uno::Reference< XInterface > ORptFilter::create(uno::Reference< XComponentContext > const & xContext) |
| { |
| return *(new ORptFilter(uno::Reference< XMultiServiceFactory >(xContext->getServiceManager(),UNO_QUERY))); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| ::rtl::OUString ORptFilter::getImplementationName_Static( ) throw(uno::RuntimeException) |
| { |
| return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.report.OReportFilter")); |
| } |
| |
| //-------------------------------------------------------------------------- |
| ::rtl::OUString SAL_CALL ORptFilter::getImplementationName( ) throw(uno::RuntimeException) |
| { |
| return getImplementationName_Static(); |
| } |
| //-------------------------------------------------------------------------- |
| uno::Sequence< ::rtl::OUString > ORptFilter::getSupportedServiceNames_Static( ) throw(uno::RuntimeException) |
| { |
| uno::Sequence< ::rtl::OUString > aServices(1); |
| aServices.getArray()[0] = SERVICE_IMPORTFILTER; |
| |
| return aServices; |
| } |
| |
| //-------------------------------------------------------------------------- |
| uno::Sequence< ::rtl::OUString > SAL_CALL ORptFilter::getSupportedServiceNames( ) throw(uno::RuntimeException) |
| { |
| return getSupportedServiceNames_Static(); |
| } |
| //------------------------------------------------------------------------------ |
| sal_Bool SAL_CALL ORptFilter::supportsService(const ::rtl::OUString& ServiceName) throw( uno::RuntimeException ) |
| { |
| return ::comphelper::existsValue(ServiceName,getSupportedServiceNames_Static()); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ORptFilter::filter( const Sequence< PropertyValue >& rDescriptor ) |
| throw (RuntimeException) |
| { |
| Window* pFocusWindow = Application::GetFocusWindow(); |
| sal_Bool bRet = sal_False; |
| |
| if( pFocusWindow ) |
| pFocusWindow->EnterWait(); |
| |
| if ( GetModel().is() ) |
| bRet = implImport( rDescriptor ); |
| |
| if ( pFocusWindow ) |
| pFocusWindow->LeaveWait(); |
| |
| return bRet; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORptFilter::implImport( const Sequence< PropertyValue >& rDescriptor ) |
| throw (RuntimeException) |
| { |
| ::rtl::OUString sFileName; |
| uno::Reference< embed::XStorage > xStorage; |
| uno::Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier; |
| |
| const PropertyValue* pIter = rDescriptor.getConstArray(); |
| const PropertyValue* pEnd = pIter + rDescriptor.getLength(); |
| for(;pIter != pEnd;++pIter) |
| { |
| if( pIter->Name.equalsAscii( "FileName" ) ) |
| pIter->Value >>= sFileName; |
| else if( pIter->Name.equalsAscii( "Storage" ) ) |
| pIter->Value >>= xStorage; |
| else if( pIter->Name.equalsAscii( "ComponentData" ) ) |
| { |
| Sequence< PropertyValue > aComponent; |
| pIter->Value >>= aComponent; |
| const PropertyValue* pComponentIter = aComponent.getConstArray(); |
| const PropertyValue* pComponentEnd = pComponentIter + aComponent.getLength(); |
| for(;pComponentIter != pComponentEnd;++pComponentIter) |
| { |
| if( pComponentIter->Name.equalsAscii( "ActiveConnection" ) ) |
| { |
| uno::Reference<sdbc::XConnection> xCon(pComponentIter->Value,uno::UNO_QUERY); |
| xNumberFormatsSupplier = ::dbtools::getNumberFormats(xCon); |
| break; |
| } |
| } |
| } |
| } |
| |
| if ( sFileName.getLength() != 0 ) |
| { |
| uno::Reference<XComponent> xCom(GetModel(),UNO_QUERY); |
| |
| SfxMediumRef pMedium = new SfxMedium( |
| sFileName, ( STREAM_READ | STREAM_NOCREATE ), sal_False, 0 ); |
| |
| if( pMedium ) |
| { |
| try |
| { |
| xStorage = pMedium->GetStorage(); |
| // nError = pMedium->GetError(); |
| } |
| catch(const Exception&) |
| { |
| } |
| } // if( pMedium ) |
| } // if ( bRet = (sFileName.getLength() != 0) ) |
| sal_Bool bRet = xStorage.is(); |
| if ( bRet ) |
| { |
| m_xReportDefinition.set(GetModel(),UNO_QUERY_THROW); |
| OSL_ENSURE(m_xReportDefinition.is(),"ReportDefinition is NULL!"); |
| if ( !m_xReportDefinition.is() ) |
| return sal_False; |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| uno::Reference < container::XNameAccess > xAccess( xStorage, uno::UNO_QUERY ); |
| uno::Sequence< ::rtl::OUString> aSeq = xAccess->getElementNames(); |
| const ::rtl::OUString* pDebugIter = aSeq.getConstArray(); |
| const ::rtl::OUString* pDebugEnd = pDebugIter + aSeq.getLength(); |
| for(;pDebugIter != pDebugEnd;++pDebugIter) |
| { |
| (void)*pDebugIter; |
| } |
| #endif |
| |
| Reference< document::XGraphicObjectResolver > xGraphicObjectResolver; |
| uno::Reference<document::XEmbeddedObjectResolver> xEmbeddedObjectResolver; |
| uno::Reference< lang::XMultiServiceFactory > xServiceFactory( getServiceFactory(), uno::UNO_QUERY); |
| if( xServiceFactory.is()) |
| { |
| uno::Sequence< uno::Any > aArgs(1); |
| aArgs[0] <<= xStorage; |
| xGraphicObjectResolver.set( |
| xServiceFactory->createInstanceWithArguments( |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.Svx.GraphicImportHelper")), aArgs ), uno::UNO_QUERY ); |
| |
| uno::Reference< lang::XMultiServiceFactory > xReportServiceFactory( m_xReportDefinition, uno::UNO_QUERY); |
| aArgs[0] <<= beans::NamedValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Storage")),uno::makeAny(xStorage)); |
| xEmbeddedObjectResolver.set( xReportServiceFactory->createInstanceWithArguments(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ImportEmbeddedObjectResolver")),aArgs) , uno::UNO_QUERY); |
| } |
| |
| static const ::rtl::OUString s_sOld(RTL_CONSTASCII_USTRINGPARAM("OldFormat")); |
| static comphelper::PropertyMapEntry pMap[] = |
| { |
| { MAP_LEN( "OldFormat" ), 1, &::getCppuType((const sal_Bool*)0), beans::PropertyAttribute::BOUND, 0 }, |
| { MAP_LEN( "StreamName"), 0, &::getCppuType( (::rtl::OUString *)0 ), beans::PropertyAttribute::MAYBEVOID, 0 }, |
| { MAP_LEN("PrivateData"), 0, &::getCppuType( (uno::Reference<XInterface> *)0 ), beans::PropertyAttribute::MAYBEVOID, 0 }, |
| { MAP_LEN( "BaseURI"), 0, &::getCppuType( (::rtl::OUString *)0 ), beans::PropertyAttribute::MAYBEVOID, 0 }, |
| { MAP_LEN( "StreamRelPath"), 0, &::getCppuType( (::rtl::OUString *)0 ), beans::PropertyAttribute::MAYBEVOID, 0 }, |
| { NULL, 0, 0, NULL, 0, 0 } |
| }; |
| ::comphelper::MediaDescriptor aDescriptor(rDescriptor); |
| uno::Reference<beans::XPropertySet> xProp = comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(pMap)); |
| const ::rtl::OUString sVal( aDescriptor.getUnpackedValueOrDefault(aDescriptor.PROP_DOCUMENTBASEURL(),::rtl::OUString()) ); |
| xProp->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BaseURI")), uno::makeAny(sVal)); |
| const ::rtl::OUString sHierarchicalDocumentName( aDescriptor.getUnpackedValueOrDefault(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HierarchicalDocumentName")),::rtl::OUString()) ); |
| xProp->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StreamRelPath")), uno::makeAny(sHierarchicalDocumentName)); |
| |
| uno::Reference<XComponent> xModel(GetModel(),UNO_QUERY); |
| static const ::rtl::OUString s_sMeta(RTL_CONSTASCII_USTRINGPARAM("meta.xml")); |
| static const rtl::OUString s_sStreamName(RTL_CONSTASCII_USTRINGPARAM("StreamName")); |
| xProp->setPropertyValue(s_sStreamName, uno::makeAny(s_sMeta)); |
| sal_Int32 nRet = ReadThroughComponent( xStorage |
| ,xModel |
| ,"meta.xml" |
| ,"Meta.xml" |
| ,getServiceFactory() |
| ,xGraphicObjectResolver |
| ,xEmbeddedObjectResolver |
| ,SERVICE_METAIMPORTER |
| ,xProp |
| ); |
| |
| |
| try |
| { |
| xProp->setPropertyValue(s_sOld,uno::makeAny(!(xStorage->hasByName(s_sMeta) || xStorage->isStreamElement( s_sMeta )))); |
| } |
| catch(uno::Exception&) |
| { |
| xProp->setPropertyValue(s_sOld,uno::makeAny(sal_True)); |
| } |
| |
| if ( nRet == 0 ) |
| { |
| xProp->setPropertyValue(s_sStreamName, uno::makeAny(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("settings.xml")))); |
| nRet = ReadThroughComponent( xStorage |
| ,xModel |
| ,"settings.xml" |
| ,"Settings.xml" |
| ,getServiceFactory() |
| ,xGraphicObjectResolver |
| ,xEmbeddedObjectResolver |
| ,SERVICE_SETTINGSIMPORTER |
| ,xProp |
| ); |
| } |
| if ( nRet == 0 ) |
| { |
| xProp->setPropertyValue(s_sStreamName, uno::makeAny(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("styles.xml")))); |
| nRet = ReadThroughComponent(xStorage |
| ,xModel |
| ,"styles.xml" |
| ,"Styles.xml" |
| ,getServiceFactory() |
| ,xGraphicObjectResolver |
| ,xEmbeddedObjectResolver |
| ,SERVICE_STYLESIMPORTER |
| ,xProp); |
| } |
| |
| if ( nRet == 0 ) |
| { |
| xProp->setPropertyValue(s_sStreamName, uno::makeAny(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("content.xml")))); |
| nRet = ReadThroughComponent( xStorage |
| ,xModel |
| ,"content.xml" |
| ,"Content.xml" |
| ,getServiceFactory() |
| ,xGraphicObjectResolver |
| ,xEmbeddedObjectResolver |
| ,SERVICE_CONTENTIMPORTER |
| ,xProp |
| ); |
| } |
| |
| |
| bRet = nRet == 0; |
| |
| if ( bRet ) |
| { |
| m_xReportDefinition->setModified(sal_False); |
| } |
| else |
| { |
| switch( nRet ) |
| { |
| case ERRCODE_IO_BROKENPACKAGE: |
| if( xStorage.is() ) |
| { |
| // TODO/LATER: no way to transport the error outside from the filter! |
| break; |
| } |
| // fall through intented |
| default: |
| { |
| // TODO/LATER: this is completely wrong! Filter code should never call ErrorHandler directly! But for now this is the only way! |
| ErrorHandler::HandleError( nRet ); |
| if( nRet & ERRCODE_WARNING_MASK ) |
| bRet = sal_True; |
| } |
| } |
| } |
| } |
| |
| return bRet; |
| } |
| // ----------------------------------------------------------------------------- |
| SvXMLImportContext* ORptFilter::CreateContext( sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| const uno::Reference< xml::sax::XAttributeList >& xAttrList ) |
| { |
| SvXMLImportContext *pContext = 0; |
| |
| const SvXMLTokenMap& rTokenMap = GetDocElemTokenMap(); |
| switch( rTokenMap.Get( nPrefix, rLocalName ) ) |
| { |
| case XML_TOK_DOC_SETTINGS: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = new XMLDocumentSettingsContext( *this, nPrefix, rLocalName,xAttrList ); |
| break; |
| case XML_TOK_DOC_REPORT: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| { |
| const SvXMLStylesContext* pAutoStyles = GetAutoStyles(); |
| if ( pAutoStyles ) |
| { |
| XMLPropStyleContext* pAutoStyle = PTR_CAST(XMLPropStyleContext,pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_PAGE_MASTER,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("pm1")))); |
| if ( pAutoStyle ) |
| { |
| pAutoStyle->FillPropertySet(getReportDefinition().get()); |
| } |
| } |
| pContext = new OXMLReport( *this, nPrefix, rLocalName,xAttrList,getReportDefinition(),NULL ); |
| } |
| break; |
| case XML_TOK_DOC_STYLES: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = CreateStylesContext( rLocalName, xAttrList, sal_False); |
| break; |
| case XML_TOK_DOC_AUTOSTYLES: |
| // don't use the autostyles from the styles-document for the progress |
| if ( ! IsXMLToken( rLocalName, XML_DOCUMENT_STYLES ) ) |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = CreateStylesContext( rLocalName, xAttrList, sal_True); |
| break; |
| case XML_TOK_DOC_FONTDECLS: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = CreateFontDeclsContext( rLocalName,xAttrList ); |
| break; |
| case XML_TOK_DOC_MASTERSTYLES: |
| { |
| SvXMLStylesContext* pStyleContext = new RptMLMasterStylesContext_Impl(*this, nPrefix, rLocalName,xAttrList);//CreateMasterStylesContext( rLocalName,xAttrList ); |
| pContext = pStyleContext; |
| SetMasterStyles( pStyleContext ); |
| } |
| break; |
| case XML_TOK_DOC_META: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = CreateMetaContext( rLocalName,xAttrList ); |
| break; |
| default: |
| break; |
| } |
| |
| if ( !pContext ) |
| pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList ); |
| |
| return pContext; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetDocElemTokenMap() const |
| { |
| if ( !m_pDocElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_OFFICE, XML_SETTINGS, XML_TOK_DOC_SETTINGS }, |
| //{ XML_NAMESPACE_OOO, XML_SETTINGS, XML_TOK_DOC_SETTINGS }, |
| { XML_NAMESPACE_OFFICE, XML_STYLES, XML_TOK_DOC_STYLES }, |
| //{ XML_NAMESPACE_OOO, XML_STYLES, XML_TOK_DOC_STYLES }, |
| { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES }, |
| //{ XML_NAMESPACE_OOO, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES }, |
| { XML_NAMESPACE_OFFICE, XML_REPORT, XML_TOK_DOC_REPORT }, |
| { XML_NAMESPACE_OOO, XML_REPORT, XML_TOK_DOC_REPORT }, |
| { XML_NAMESPACE_OFFICE, XML_FONT_FACE_DECLS, XML_TOK_DOC_FONTDECLS }, |
| { XML_NAMESPACE_OFFICE, XML_MASTER_STYLES, XML_TOK_DOC_MASTERSTYLES }, |
| { XML_NAMESPACE_OFFICE, XML_DOCUMENT_META, XML_TOK_DOC_META }, |
| //{ XML_NAMESPACE_OOO, XML_FONT_FACE_DECLS, XML_TOK_DOC_FONTDECLS }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pDocElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pDocElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetReportElemTokenMap() const |
| { |
| if ( !m_pReportElemTokenMap.get() ) |
| m_pReportElemTokenMap.reset(OXMLHelper::GetReportElemTokenMap()); |
| return *m_pReportElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetSubDocumentElemTokenMap() const |
| { |
| if ( !m_pSubDocumentElemTokenMap.get() ) |
| m_pSubDocumentElemTokenMap.reset(OXMLHelper::GetSubDocumentElemTokenMap()); |
| return *m_pSubDocumentElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetFunctionElemTokenMap() const |
| { |
| if ( !m_pFunctionElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_REPORT, XML_NAME, XML_TOK_FUNCTION_NAME }, |
| { XML_NAMESPACE_REPORT, XML_FORMULA, XML_TOK_FUNCTION_FORMULA}, |
| { XML_NAMESPACE_REPORT, XML_PRE_EVALUATED, XML_TOK_PRE_EVALUATED }, |
| { XML_NAMESPACE_REPORT, XML_INITIAL_FORMULA,XML_TOK_INITIAL_FORMULA }, |
| { XML_NAMESPACE_REPORT, XML_DEEP_TRAVERSING,XML_TOK_DEEP_TRAVERSING }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pFunctionElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pFunctionElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetFormatElemTokenMap() const |
| { |
| if ( !m_pFormatElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_REPORT, XML_ENABLED , XML_TOK_ENABLED }, |
| { XML_NAMESPACE_REPORT, XML_FORMULA , XML_TOK_FORMULA }, |
| { XML_NAMESPACE_REPORT, XML_STYLE_NAME , XML_TOK_FORMAT_STYLE_NAME }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pFormatElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pFormatElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetGroupElemTokenMap() const |
| { |
| if ( !m_pGroupElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_REPORT, XML_START_NEW_COLUMN , XML_TOK_START_NEW_COLUMN }, |
| { XML_NAMESPACE_REPORT, XML_RESET_PAGE_NUMBER , XML_TOK_RESET_PAGE_NUMBER }, |
| { XML_NAMESPACE_REPORT, XML_PRINT_HEADER_ON_EACH_PAGE , XML_TOK_PRINT_HEADER_ON_EACH_PAGE }, |
| { XML_NAMESPACE_REPORT, XML_RESET_PAGE_NUMBER , XML_TOK_RESET_PAGE_NUMBER }, |
| { XML_NAMESPACE_REPORT, XML_GROUP_EXPRESSION , XML_TOK_GROUP_EXPRESSION }, |
| { XML_NAMESPACE_REPORT, XML_GROUP_HEADER , XML_TOK_GROUP_HEADER }, |
| { XML_NAMESPACE_REPORT, XML_GROUP , XML_TOK_GROUP_GROUP }, |
| { XML_NAMESPACE_REPORT, XML_DETAIL , XML_TOK_GROUP_DETAIL }, |
| { XML_NAMESPACE_REPORT, XML_GROUP_FOOTER , XML_TOK_GROUP_FOOTER }, |
| { XML_NAMESPACE_REPORT, XML_SORT_ASCENDING , XML_TOK_SORT_ASCENDING }, |
| { XML_NAMESPACE_REPORT, XML_KEEP_TOGETHER , XML_TOK_GROUP_KEEP_TOGETHER }, |
| { XML_NAMESPACE_REPORT, XML_FUNCTION , XML_TOK_GROUP_FUNCTION }, |
| //{ XML_NAMESPACE_REPORT, XML_ , XML_TOK_ }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pGroupElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pGroupElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetReportElementElemTokenMap() const |
| { |
| if ( !m_pElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_REPORT, XML_PRINT_REPEATED_VALUES ,XML_TOK_PRINT_REPEATED_VALUES }, |
| { XML_NAMESPACE_REPORT, XML_PRINT_ONLY_WHEN_GROUP_CHANGE,XML_TOK_PRINT_ONLY_WHEN_GROUP_CHANGE }, |
| { XML_NAMESPACE_REPORT, XML_CONDITIONAL_PRINT_EXPRESSION,XML_TOK_REP_CONDITIONAL_PRINT_EXPRESSION }, |
| { XML_NAMESPACE_REPORT, XML_REPORT_COMPONENT ,XML_TOK_COMPONENT }, |
| { XML_NAMESPACE_REPORT, XML_FORMAT_CONDITION ,XML_TOK_FORMATCONDITION }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetControlElemTokenMap() const |
| { |
| if ( !m_pControlElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_FORM, XML_LABEL ,XML_TOK_LABEL }, |
| { XML_NAMESPACE_FORM, XML_PROPERTIES ,XML_TOK_PROPERTIES }, |
| { XML_NAMESPACE_FORM, XML_SIZE ,XML_TOK_SIZE }, |
| { XML_NAMESPACE_FORM, XML_IMAGE_DATA ,XML_TOK_IMAGE_DATA }, |
| { XML_NAMESPACE_REPORT, XML_SCALE ,XML_TOK_SCALE }, |
| { XML_NAMESPACE_REPORT, XML_REPORT_ELEMENT ,XML_TOK_REPORT_ELEMENT }, |
| { XML_NAMESPACE_REPORT, XML_FORMULA ,XML_TOK_DATA_FORMULA }, |
| { XML_NAMESPACE_REPORT, XML_PRESERVE_IRI ,XML_TOK_PRESERVE_IRI }, |
| { XML_NAMESPACE_REPORT, XML_SELECT_PAGE ,XML_TOK_SELECT_PAGE }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pControlElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pControlElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetControlPropertyElemTokenMap() const |
| { |
| if ( !m_pControlElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_FORM, XML_PROPERTY_NAME ,XML_TOK_PROPERTY_NAME }, |
| { XML_NAMESPACE_OOO, XML_VALUE_TYPE ,XML_TOK_VALUE_TYPE }, |
| { XML_NAMESPACE_FORM, XML_LIST_PROPERTY ,XML_TOK_LIST_PROPERTY }, |
| { XML_NAMESPACE_OOO, XML_VALUE ,XML_TOK_VALUE }, |
| { XML_NAMESPACE_OOO, XML_CURRENCY ,XML_TOK_CURRENCY }, |
| { XML_NAMESPACE_OOO, XML_DATE_VALUE ,XML_TOK_DATE_VALUE }, |
| { XML_NAMESPACE_OOO, XML_TIME_VALUE ,XML_TOK_TIME_VALUE }, |
| { XML_NAMESPACE_OOO, XML_STRING_VALUE ,XML_TOK_STRING_VALUE }, |
| { XML_NAMESPACE_OOO, XML_BOOLEAN_VALUE ,XML_TOK_BOOLEAN_VALUE }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pControlElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pControlElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetComponentElemTokenMap() const |
| { |
| if ( !m_pComponentElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DRAW, XML_NAME , XML_TOK_NAME }, |
| { XML_NAMESPACE_DRAW, XML_TEXT_STYLE_NAME , XML_TOK_TEXT_STYLE_NAME }, |
| { XML_NAMESPACE_REPORT, XML_TRANSFORM , XML_TOK_TRANSFORM }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pComponentElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pComponentElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetColumnTokenMap() const |
| { |
| if ( !m_pColumnTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_TABLE, XML_NAME , XML_TOK_NAME }, |
| { XML_NAMESPACE_TABLE, XML_STYLE_NAME , XML_TOK_COLUMN_STYLE_NAME }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_COLUMN , XML_TOK_COLUMN }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_ROW , XML_TOK_ROW }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_CELL , XML_TOK_CELL }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_COLUMNS , XML_TOK_TABLE_COLUMNS }, |
| { XML_NAMESPACE_TABLE, XML_TABLE_ROWS , XML_TOK_TABLE_ROWS }, |
| { XML_NAMESPACE_TABLE, XML_COVERED_TABLE_CELL , XML_TOK_COV_CELL }, |
| { XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED , XML_TOK_NUMBER_COLUMNS_SPANNED }, |
| { XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED , XML_TOK_NUMBER_ROWS_SPANNED }, |
| { XML_NAMESPACE_REPORT, XML_CONDITIONAL_PRINT_EXPRESSION, XML_TOK_CONDITIONAL_PRINT_EXPRESSION}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pColumnTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pColumnTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetSectionElemTokenMap() const |
| { |
| if ( !m_pSectionElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_TABLE, XML_TABLE , XML_TOK_TABLE }, |
| { XML_NAMESPACE_TABLE, XML_NAME , XML_TOK_SECTION_NAME }, |
| { XML_NAMESPACE_REPORT, XML_VISIBLE , XML_TOK_VISIBLE }, |
| { XML_NAMESPACE_REPORT, XML_FORCE_NEW_PAGE , XML_TOK_FORCE_NEW_PAGE }, |
| { XML_NAMESPACE_REPORT, XML_FORCE_NEW_COLUMN , XML_TOK_FORCE_NEW_COLUMN }, |
| { XML_NAMESPACE_REPORT, XML_KEEP_TOGETHER , XML_TOK_KEEP_TOGETHER }, |
| { XML_NAMESPACE_REPORT, XML_REPEAT_SECTION , XML_TOK_REPEAT_SECTION }, |
| { XML_NAMESPACE_TABLE, XML_STYLE_NAME , XML_TOK_SECT_STYLE_NAME }, |
| { XML_NAMESPACE_REPORT, XML_PAGE_PRINT_OPTION , XML_TOK_PAGE_PRINT_OPTION }, |
| |
| XML_TOKEN_MAP_END |
| }; |
| m_pSectionElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pSectionElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ORptFilter::GetCellElemTokenMap() const |
| { |
| if ( !m_pCellElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_TEXT, XML_P , XML_TOK_P }, |
| { XML_NAMESPACE_REPORT, XML_FIXED_CONTENT , XML_TOK_FIXED_CONTENT }, |
| { XML_NAMESPACE_REPORT, XML_FORMATTED_TEXT , XML_TOK_FORMATTED_TEXT }, |
| { XML_NAMESPACE_REPORT, XML_IMAGE , XML_TOK_IMAGE }, |
| { XML_NAMESPACE_REPORT, XML_SUB_DOCUMENT , XML_TOK_SUB_DOCUMENT }, |
| { XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE , XML_TOK_CUSTOM_SHAPE }, |
| { XML_NAMESPACE_DRAW, XML_FRAME , XML_TOK_FRAME }, |
| { XML_NAMESPACE_TEXT, XML_PAGE_NUMBER , XML_TOK_PAGE_NUMBER }, |
| { XML_NAMESPACE_TEXT, XML_PAGE_COUNT , XML_TOK_PAGE_COUNT }, |
| { XML_NAMESPACE_TEXT, XML_TAB , XML_TOK_TEXT_TAB_STOP }, |
| { XML_NAMESPACE_TEXT, XML_LINE_BREAK , XML_TOK_TEXT_LINE_BREAK }, |
| { XML_NAMESPACE_TEXT, XML_S , XML_TOK_TEXT_S }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pCellElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pCellElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| SvXMLImportContext* ORptFilter::CreateStylesContext(const ::rtl::OUString& rLocalName, |
| const uno::Reference< XAttributeList>& xAttrList, sal_Bool bIsAutoStyle ) |
| { |
| SvXMLImportContext* pContext = bIsAutoStyle ? GetAutoStyles() : GetStyles(); |
| if ( !pContext ) |
| { |
| pContext = new OReportStylesContext(*this, XML_NAMESPACE_OFFICE, rLocalName, xAttrList, bIsAutoStyle); |
| if (bIsAutoStyle) |
| //xAutoStyles = pContext; |
| SetAutoStyles((SvXMLStylesContext*)pContext); |
| else |
| //xStyles = pContext; |
| SetStyles((SvXMLStylesContext*)pContext); |
| } |
| return pContext; |
| } |
| // ----------------------------------------------------------------------------- |
| SvXMLImport& ORptFilter::getGlobalContext() |
| { |
| return *this; |
| } |
| // ----------------------------------------------------------------------------- |
| void ORptFilter::enterEventContext() |
| { |
| } |
| // ----------------------------------------------------------------------------- |
| void ORptFilter::leaveEventContext() |
| { |
| } |
| // ----------------------------------------------------------------------------- |
| SvXMLImportContext *ORptFilter::CreateFontDeclsContext( |
| const ::rtl::OUString& rLocalName, |
| const uno::Reference< xml::sax::XAttributeList > & xAttrList ) |
| { |
| XMLFontStylesContext *pFSContext = |
| new XMLFontStylesContext( *this, XML_NAMESPACE_OFFICE, |
| rLocalName, xAttrList, |
| gsl_getSystemTextEncoding() ); |
| SetFontDecls( pFSContext ); |
| return pFSContext; |
| } |
| // ----------------------------------------------------------------------------- |
| XMLShapeImportHelper* ORptFilter::CreateShapeImport() |
| { |
| return new XMLShapeImportHelper( *this,GetModel() ); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORptFilter::FinishStyles() |
| { |
| if( GetStyles() ) |
| GetStyles()->FinishStyles( sal_True ); |
| } |
| // ----------------------------------------------------------------------------- |
| ::rtl::OUString ORptFilter::convertFormula(const ::rtl::OUString& _sFormula) |
| { |
| //sal_Int32 nLen = _sFormula.getLength(); |
| //if ( nLen ) |
| //{ |
| // const static ::rtl::OUString s_sField(RTL_CONSTASCII_USTRINGPARAM("field:[")); |
| // sal_Int32 nPos = _sFormula.indexOf(s_sField); |
| // if ( nPos == -1 ) |
| // nPos = 4; // "rpt:" |
| // else |
| // { |
| // nPos = s_sField.getLength(); |
| // --nLen; // eat "]" |
| // } |
| // return _sFormula.copy(nPos,nLen-nPos); |
| //} |
| return _sFormula; |
| } |
| // ----------------------------------------------------------------------------- |
| void SAL_CALL ORptFilter::startDocument( void ) |
| throw( xml::sax::SAXException, uno::RuntimeException ) |
| { |
| m_xReportDefinition.set(GetModel(),UNO_QUERY_THROW); |
| OSL_ENSURE(m_xReportDefinition.is(),"ReportDefinition is NULL!"); |
| if ( m_xReportDefinition.is() ) |
| { |
| m_pReportModel = reportdesign::OReportDefinition::getSdrModel(m_xReportDefinition); |
| OSL_ENSURE(m_pReportModel,"Report model is NULL!"); |
| |
| SvXMLImport::startDocument(); |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| void ORptFilter::endDocument( void ) |
| throw( xml::sax::SAXException, uno::RuntimeException ) |
| { |
| DBG_ASSERT( GetModel().is(), "model missing; maybe startDocument wasn't called?" ); |
| if( !GetModel().is() ) |
| return; |
| |
| // this method will modify the document directly -> lock SolarMutex |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| // Clear the shape import to sort the shapes (and not in the |
| // destructor that might be called after the import has finished |
| // for Java filters. |
| if( HasShapeImport() ) |
| ClearShapeImport(); |
| |
| // delegate to parent: takes care of error handling |
| SvXMLImport::endDocument(); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORptFilter::removeFunction(const ::rtl::OUString& _sFunctionName) |
| { |
| m_aFunctions.erase(_sFunctionName); |
| } |
| // ----------------------------------------------------------------------------- |
| void ORptFilter::insertFunction(const ::com::sun::star::uno::Reference< ::com::sun::star::report::XFunction > & _xFunction) |
| { |
| m_aFunctions.insert(TGroupFunctionMap::value_type(_xFunction->getName(),_xFunction)); |
| } |
| // ----------------------------------------------------------------------------- |
| SvXMLImportContext* ORptFilter::CreateMetaContext(const ::rtl::OUString& rLocalName,const uno::Reference<xml::sax::XAttributeList>&) |
| { |
| SvXMLImportContext* pContext = NULL; |
| |
| if ( (getImportFlags() & IMPORT_META) ) |
| { |
| uno::Reference<xml::sax::XDocumentHandler> xDocBuilder( |
| getServiceFactory()->createInstance(::rtl::OUString::createFromAscii( |
| "com.sun.star.xml.dom.SAXDocumentBuilder")), |
| uno::UNO_QUERY_THROW); |
| uno::Reference<document::XDocumentPropertiesSupplier> xDPS(GetModel(), uno::UNO_QUERY_THROW); |
| pContext = new SvXMLMetaDocumentContext(*this,XML_NAMESPACE_OFFICE, rLocalName,xDPS->getDocumentProperties(), xDocBuilder); |
| } |
| return pContext; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool ORptFilter::isOldFormat() const |
| { |
| sal_Bool bOldFormat = sal_True; |
| uno::Reference<beans::XPropertySet> xProp = getImportInfo(); |
| if ( xProp.is() ) |
| { |
| const static ::rtl::OUString s_sOld(RTL_CONSTASCII_USTRINGPARAM("OldFormat")); |
| if ( xProp->getPropertySetInfo()->hasPropertyByName(s_sOld)) |
| { |
| xProp->getPropertyValue(s_sOld) >>= bOldFormat; |
| } |
| } // if ( xProp.is() ) |
| return bOldFormat; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| }// rptxml |
| // ----------------------------------------------------------------------------- |
