| /************************************************************** |
| * |
| * 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_dbaccess.hxx" |
| |
| #ifndef _COM_SUN_STAR_PACKAGES_ZIP_ZIPIOEXCEPTION_HPP_ |
| #include <com/sun/star/packages/zip/ZipIOException.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_EMBED_ELEMENTMODES_HPP_ |
| #include <com/sun/star/embed/ElementModes.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDB_XOFFICEDATABASEDOCUMENT_HPP_ |
| #include <com/sun/star/sdb/XOfficeDatabaseDocument.hpp> |
| #endif |
| #ifndef DBA_XMLFILTER_HXX |
| #include "xmlfilter.hxx" |
| #endif |
| #ifndef _FLT_REGHELPER_HXX_ |
| #include "flt_reghelper.hxx" |
| #endif |
| #ifndef _SV_SVAPP_HXX |
| #include <vcl/svapp.hxx> |
| #endif |
| #ifndef _SV_WINDOW_HXX |
| #include <vcl/window.hxx> |
| #endif |
| #ifndef _XMLOFF_XMLNMSPE_HXX |
| #include <xmloff/xmlnmspe.hxx> |
| #endif |
| #ifndef _XMLOFF_XMLSCRIPTI_HXX |
| #include <xmloff/xmlscripti.hxx> |
| #endif |
| #ifndef _XMLOFF_XMLTOKEN_HXX |
| #include <xmloff/xmltoken.hxx> |
| #endif |
| #ifndef _XMLOFF_TEXTIMP_HXX_ |
| #include <xmloff/txtimp.hxx> |
| #endif |
| #ifndef _XMLOFF_NMSPMAP_HXX |
| #include <xmloff/nmspmap.hxx> |
| #endif |
| #ifndef _RTL_LOGFILE_HXX_ |
| #include <rtl/logfile.hxx> |
| #endif |
| #ifndef _COM_SUN_STAR_XML_SAX_INPUTSOURCE_HPP_ |
| #include <com/sun/star/xml/sax/InputSource.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_XML_SAX_XPARSER_HPP_ |
| #include <com/sun/star/xml/sax/XParser.hpp> |
| #endif |
| #ifndef _XMLOFF_PROGRESSBARHELPER_HXX |
| #include <xmloff/ProgressBarHelper.hxx> |
| #endif |
| #ifndef _SFXDOCFILE_HXX //autogen wg. SfxMedium |
| #include <sfx2/docfile.hxx> |
| #endif |
| #ifndef _COM_SUN_STAR_IO_XINPUTSTREAM_HPP_ |
| #include <com/sun/star/io/XInputStream.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UNO_XNAMINGSERVICE_HPP_ |
| #include <com/sun/star/uno/XNamingService.hpp> |
| #endif |
| #ifndef DBA_XMLDATABASE_HXX |
| #include "xmlDatabase.hxx" |
| #endif |
| #ifndef DBA_XMLENUMS_HXX |
| #include "xmlEnums.hxx" |
| #endif |
| #ifndef _URLOBJ_HXX //autogen wg. INetURLObject |
| #include <tools/urlobj.hxx> |
| #endif |
| #ifndef DBACCESS_SHARED_XMLSTRINGS_HRC |
| #include "xmlstrings.hrc" |
| #endif |
| #ifndef _XMLOFF_DOCUMENTSETTINGSCONTEXT_HXX |
| #include <xmloff/DocumentSettingsContext.hxx> |
| #endif |
| #ifndef DBA_XMLSTYLEIMPORT_HXX |
| #include "xmlStyleImport.hxx" |
| #endif |
| #ifndef _XMLOFF_XMLUCONV_HXX |
| #include <xmloff/xmluconv.hxx> |
| #endif |
| #ifndef DBA_XMLHELPER_HXX |
| #include "xmlHelper.hxx" |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_XMODIFIABLE_HPP_ |
| #include <com/sun/star/util/XModifiable.hpp> |
| #endif |
| #include <com/sun/star/frame/XComponentLoader.hpp> |
| #include <com/sun/star/frame/FrameSearchFlag.hpp> |
| #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp> |
| #ifndef _SV_SVAPP_HXX //autogen |
| #include <vcl/svapp.hxx> |
| #endif |
| #ifndef _VOS_MUTEX_HXX_ |
| #include <vos/mutex.hxx> |
| #endif |
| #include <svtools/sfxecode.hxx> |
| #include <unotools/moduleoptions.hxx> |
| #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_ |
| #include <toolkit/helper/vclunohelper.hxx> |
| #endif |
| #include <tools/diagnose_ex.h> |
| #include <comphelper/namedvaluecollection.hxx> |
| #include <comphelper/mimeconfighelper.hxx> |
| #include <comphelper/documentconstants.hxx> |
| #include <comphelper/uno3.hxx> |
| #include <cppuhelper/exc_hlp.hxx> |
| #include <osl/thread.hxx> |
| #include <connectivity/CommonTools.hxx> |
| #include <connectivity/DriversConfig.hxx> |
| #include "dsntypes.hxx" |
| |
| using namespace ::com::sun::star; |
| |
| extern "C" void SAL_CALL createRegistryInfo_ODBFilter( ) |
| { |
| static ::dbaxml::OMultiInstanceAutoRegistration< ::dbaxml::ODBFilter > aAutoRegistration; |
| } |
| //-------------------------------------------------------------------------- |
| namespace dbaxml |
| { |
| namespace |
| { |
| class FastLoader : public ::osl::Thread |
| { |
| public: |
| typedef enum { E_JAVA, E_CALC } StartType; |
| FastLoader(uno::Reference< lang::XMultiServiceFactory > const & _xFactory,StartType _eType) |
| :m_xFactory(_xFactory) |
| ,m_eWhat(_eType) |
| {} |
| |
| protected: |
| virtual ~FastLoader(){} |
| |
| /// Working method which should be overridden. |
| virtual void SAL_CALL run(); |
| virtual void SAL_CALL onTerminated(); |
| private: |
| uno::Reference< lang::XMultiServiceFactory > m_xFactory; |
| StartType m_eWhat; |
| }; |
| |
| void SAL_CALL FastLoader::run() |
| { |
| if ( m_eWhat == E_JAVA ) |
| { |
| static bool s_bFirstTime = true; |
| if ( s_bFirstTime ) |
| { |
| s_bFirstTime = false; |
| try |
| { |
| ::rtl::Reference< jvmaccess::VirtualMachine > xJVM = ::connectivity::getJavaVM(m_xFactory); |
| } |
| catch(uno::Exception& ex) |
| { |
| (void)ex; |
| OSL_ASSERT(0); |
| } |
| } // if ( s_bFirstTime ) |
| } // if ( m_eWhat == E_JAVA ) |
| else if ( m_eWhat == E_CALC ) |
| { |
| static bool s_bFirstTime = true; |
| if ( s_bFirstTime ) |
| { |
| s_bFirstTime = false; |
| try |
| { |
| uno::Reference<frame::XComponentLoader> xFrameLoad( m_xFactory->createInstance( |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.frame.Desktop"))) |
| ,uno::UNO_QUERY); |
| const ::rtl::OUString sTarget(RTL_CONSTASCII_USTRINGPARAM("_blank")); |
| sal_Int32 nFrameSearchFlag = frame::FrameSearchFlag::TASKS | frame::FrameSearchFlag::CREATE; |
| uno::Reference< frame::XFrame> xFrame = uno::Reference< frame::XFrame>(xFrameLoad,uno::UNO_QUERY_THROW)->findFrame(sTarget,nFrameSearchFlag); |
| xFrameLoad.set( xFrame,uno::UNO_QUERY); |
| |
| if ( xFrameLoad.is() ) |
| { |
| uno::Sequence < beans::PropertyValue > aArgs( 3); |
| sal_Int32 nLen = 0; |
| aArgs[nLen].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AsTemplate")); |
| aArgs[nLen++].Value <<= sal_False; |
| |
| aArgs[nLen].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReadOnly")); |
| aArgs[nLen++].Value <<= sal_True; |
| |
| aArgs[nLen].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Hidden")); |
| aArgs[nLen++].Value <<= sal_True; |
| |
| ::comphelper::MimeConfigurationHelper aHelper(m_xFactory); |
| SvtModuleOptions aModuleOptions; |
| uno::Reference< frame::XModel > xModel(xFrameLoad->loadComponentFromURL( |
| aModuleOptions.GetFactoryEmptyDocumentURL( aModuleOptions.ClassifyFactoryByServiceName( aHelper.GetDocServiceNameFromMediaType(MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET) )), |
| ::rtl::OUString(), // empty frame name |
| 0, |
| aArgs |
| ),uno::UNO_QUERY); |
| ::comphelper::disposeComponent(xModel); |
| } |
| } |
| catch(uno::Exception& ex) |
| { |
| (void)ex; |
| OSL_ASSERT(0); |
| } |
| } |
| } |
| } |
| void SAL_CALL FastLoader::onTerminated() |
| { |
| delete this; |
| } |
| |
| class DatasourceURLListener : public ::cppu::WeakImplHelper1< beans::XPropertyChangeListener > |
| { |
| uno::Reference< lang::XMultiServiceFactory > m_xFactory; |
| ::dbaccess::ODsnTypeCollection m_aTypeCollection; |
| DatasourceURLListener(const DatasourceURLListener&); |
| void operator =(const DatasourceURLListener&); |
| protected: |
| virtual ~DatasourceURLListener(){} |
| public: |
| DatasourceURLListener(uno::Reference< lang::XMultiServiceFactory > const & _xFactory) : m_xFactory(_xFactory),m_aTypeCollection(_xFactory){} |
| // XPropertyChangeListener |
| virtual void SAL_CALL propertyChange( const beans::PropertyChangeEvent& _rEvent ) throw (uno::RuntimeException) |
| { |
| ::rtl::OUString sURL; |
| _rEvent.NewValue >>= sURL; |
| FastLoader* pCreatorThread = NULL; |
| |
| if ( m_aTypeCollection.needsJVM(sURL) ) |
| { |
| pCreatorThread = new FastLoader(m_xFactory,FastLoader::E_JAVA); |
| } // if ( m_aTypeCollection.needsJVM(sURL) ) |
| else if ( sURL.matchIgnoreAsciiCaseAsciiL("sdbc:calc:",10,0) ) |
| { |
| pCreatorThread = new FastLoader(m_xFactory,FastLoader::E_CALC); |
| } |
| if ( pCreatorThread ) |
| { |
| pCreatorThread->createSuspended(); |
| pCreatorThread->setPriority(osl_Thread_PriorityBelowNormal); |
| pCreatorThread->resume(); |
| } |
| } |
| // XEventListener |
| virtual void SAL_CALL disposing( const lang::EventObject& /*_rSource*/ ) throw (uno::RuntimeException) |
| { |
| } |
| }; |
| } |
| sal_Char __READONLY_DATA sXML_np__db[] = "_db"; |
| sal_Char __READONLY_DATA sXML_np___db[] = "__db"; |
| |
| using namespace ::com::sun::star::util; |
| /// read a component (file + filter version) |
| sal_Int32 ReadThroughComponent( |
| const uno::Reference<XInputStream>& xInputStream, |
| const uno::Reference<XComponent>& xModelComponent, |
| const uno::Reference<XMultiServiceFactory> & rFactory, |
| const uno::Reference< XDocumentHandler >& _xFilter ) |
| { |
| DBG_ASSERT(xInputStream.is(), "input stream missing"); |
| DBG_ASSERT(xModelComponent.is(), "document missing"); |
| DBG_ASSERT(rFactory.is(), "factory missing"); |
| |
| RTL_LOGFILE_CONTEXT_AUTHOR( aLog, "dbaxml", "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 ); |
| |
| |
| |
| // finally, parser the stream |
| try |
| { |
| xParser->parseStream( aParserInput ); |
| } |
| #if OSL_DEBUG_LEVEL > 1 |
| catch( SAXParseException& r ) |
| { |
| 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() ); |
| return 1; |
| } |
| #else |
| catch( SAXParseException& ) |
| { |
| return 1; |
| } |
| #endif |
| catch( SAXException& ) |
| { |
| return 1; |
| } |
| catch( packages::zip::ZipIOException& ) |
| { |
| return ERRCODE_IO_BROKENPACKAGE; |
| } |
| catch( Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| |
| // 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 uno::Reference< XDocumentHandler >& _xFilter) |
| { |
| 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 ); |
| uno::Any aAny = xProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Encrypted") ) ); |
| aAny >>= bEncrypted; |
| } |
| catch( packages::WrongPasswordException& ) |
| { |
| return ERRCODE_SFX_WRONGPASSWORD; |
| } |
| catch ( uno::Exception& ) |
| { |
| return 1; // TODO/LATER: error handling |
| } |
| |
| #ifdef TIMELOG |
| // if we do profiling, we want to know the stream |
| RTL_LOGFILE_TRACE_AUTHOR1( "dbaxml", "oj", |
| "ReadThroughComponent : parsing \"%s\"", pStreamName ); |
| #endif |
| |
| uno::Reference< XInputStream > xInputStream = xDocStream->getInputStream(); |
| // read from the stream |
| return ReadThroughComponent( xInputStream |
| ,xModelComponent |
| ,rFactory |
| ,_xFilter ); |
| } |
| |
| // TODO/LATER: better error handling |
| return 1; |
| } |
| |
| // ------------- |
| // - ODBFilter - |
| // ------------- |
| DBG_NAME(ODBFilter) |
| |
| ODBFilter::ODBFilter( const uno::Reference< XMultiServiceFactory >& _rxMSF ) |
| :SvXMLImport(_rxMSF) |
| ,m_bNewFormat(false) |
| { |
| DBG_CTOR(ODBFilter,NULL); |
| |
| GetMM100UnitConverter().setCoreMeasureUnit(MAP_10TH_MM); |
| GetMM100UnitConverter().setXMLMeasureUnit(MAP_CM); |
| GetNamespaceMap().Add( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__db) ), |
| GetXMLToken(XML_N_DB), |
| XML_NAMESPACE_DB ); |
| |
| GetNamespaceMap().Add( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np___db) ), |
| GetXMLToken(XML_N_DB_OASIS), |
| XML_NAMESPACE_DB ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| ODBFilter::~ODBFilter() throw() |
| { |
| |
| DBG_DTOR(ODBFilter,NULL); |
| } |
| // ----------------------------------------------------------------------------- |
| IMPLEMENT_SERVICE_INFO1_STATIC( ODBFilter, "com.sun.star.comp.sdb.DBFilter", "com.sun.star.document.ImportFilter") |
| // ----------------------------------------------------------------------------- |
| sal_Bool SAL_CALL ODBFilter::filter( const Sequence< PropertyValue >& rDescriptor ) |
| throw (RuntimeException) |
| { |
| uno::Reference< ::com::sun::star::awt::XWindow > xWindow; |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| Window* pFocusWindow = Application::GetFocusWindow(); |
| xWindow = VCLUnoHelper::GetInterface( pFocusWindow ); |
| if( pFocusWindow ) |
| pFocusWindow->EnterWait(); |
| } |
| sal_Bool bRet = sal_False; |
| |
| if ( GetModel().is() ) |
| bRet = implImport( rDescriptor ); |
| |
| if ( xWindow.is() ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| Window* pFocusWindow = VCLUnoHelper::GetWindow( xWindow ); |
| if ( pFocusWindow ) |
| pFocusWindow->LeaveWait(); |
| } |
| |
| |
| return bRet; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool ODBFilter::implImport( const Sequence< PropertyValue >& rDescriptor ) |
| throw (RuntimeException) |
| { |
| ::rtl::OUString sFileName; |
| ::comphelper::NamedValueCollection aMediaDescriptor( rDescriptor ); |
| if ( aMediaDescriptor.has( "URL" ) ) |
| sFileName = aMediaDescriptor.getOrDefault( "URL", ::rtl::OUString() ); |
| if ( !sFileName.getLength() && aMediaDescriptor.has( "FileName" ) ) |
| sFileName = aMediaDescriptor.getOrDefault( "FileName", sFileName ); |
| |
| OSL_ENSURE( sFileName.getLength(), "ODBFilter::implImport: no URL given!" ); |
| sal_Bool bRet = ( sFileName.getLength() != 0 ); |
| |
| if ( bRet ) |
| { |
| uno::Reference<XComponent> xCom(GetModel(),UNO_QUERY); |
| |
| SfxMediumRef pMedium = new SfxMedium( |
| sFileName, ( STREAM_READ | STREAM_NOCREATE ), sal_False, 0 ); |
| uno::Reference< embed::XStorage > xStorage; |
| try |
| { |
| xStorage.set( pMedium->GetStorage( sal_False ), UNO_QUERY_THROW ); |
| } |
| catch( const Exception& ) |
| { |
| Any aError = ::cppu::getCaughtException(); |
| if ( aError.isExtractableTo( ::cppu::UnoType< RuntimeException >::get() ) ) |
| throw; |
| throw lang::WrappedTargetRuntimeException( ::rtl::OUString(), *this, aError ); |
| } |
| |
| uno::Reference<sdb::XOfficeDatabaseDocument> xOfficeDoc(GetModel(),UNO_QUERY_THROW); |
| m_xDataSource.set(xOfficeDoc->getDataSource(),UNO_QUERY_THROW); |
| uno::Reference<beans::XPropertyChangeListener> xListener = new DatasourceURLListener(getServiceFactory()); |
| m_xDataSource->addPropertyChangeListener(PROPERTY_URL,xListener); |
| uno::Reference< XNumberFormatsSupplier > xNum(m_xDataSource->getPropertyValue(PROPERTY_NUMBERFORMATSSUPPLIER),UNO_QUERY); |
| SetNumberFormatsSupplier(xNum); |
| |
| uno::Reference<XComponent> xModel(GetModel(),UNO_QUERY); |
| sal_Int32 nRet = ReadThroughComponent( xStorage |
| ,xModel |
| ,"settings.xml" |
| ,"Settings.xml" |
| ,getServiceFactory() |
| ,this |
| ); |
| |
| if ( nRet == 0 ) |
| nRet = ReadThroughComponent( xStorage |
| ,xModel |
| ,"content.xml" |
| ,"Content.xml" |
| ,getServiceFactory() |
| ,this |
| ); |
| |
| bRet = nRet == 0; |
| |
| if ( bRet ) |
| { |
| uno::Reference< XModifiable > xModi(GetModel(),UNO_QUERY); |
| if ( xModi.is() ) |
| xModi->setModified(sal_False); |
| } |
| else |
| { |
| switch( nRet ) |
| { |
| case ERRCODE_IO_BROKENPACKAGE: |
| // TODO/LATER: no way to transport the error outside from the filter! |
| break; |
| 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* ODBFilter::CreateContext( sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| const uno::Reference< ::com::sun::star::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_DATABASE: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = new OXMLDatabase( *this, nPrefix, rLocalName ); |
| break; |
| case XML_TOK_DOC_STYLES: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = CreateStylesContext(nPrefix, rLocalName, xAttrList, sal_False); |
| break; |
| case XML_TOK_DOC_AUTOSTYLES: |
| GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP ); |
| pContext = CreateStylesContext(nPrefix, rLocalName, xAttrList, sal_True); |
| break; |
| case XML_TOK_DOC_SCRIPT: |
| pContext = CreateScriptContext( rLocalName ); |
| break; |
| } |
| |
| if ( !pContext ) |
| pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList ); |
| |
| return pContext; |
| } |
| // ----------------------------------------------------------------------------- |
| void ODBFilter::SetViewSettings(const Sequence<PropertyValue>& aViewProps) |
| { |
| const PropertyValue *pIter = aViewProps.getConstArray(); |
| const PropertyValue *pEnd = pIter + aViewProps.getLength(); |
| for (; pIter != pEnd; ++pIter) |
| { |
| if ( pIter->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Queries" ) ) ) |
| { |
| fillPropertyMap(pIter->Value,m_aQuerySettings); |
| } |
| else if ( pIter->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "Tables" ) ) ) |
| { |
| fillPropertyMap(pIter->Value,m_aTablesSettings); |
| } |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| void ODBFilter::SetConfigurationSettings(const Sequence<PropertyValue>& aConfigProps) |
| { |
| const PropertyValue *pIter = aConfigProps.getConstArray(); |
| const PropertyValue *pEnd = pIter + aConfigProps.getLength(); |
| for (; pIter != pEnd; ++pIter) |
| { |
| if ( pIter->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( "layout-settings" ) ) ) |
| { |
| Sequence<PropertyValue> aWindows; |
| pIter->Value >>= aWindows; |
| uno::Reference<XPropertySet> xProp(getDataSource()); |
| if ( xProp.is() ) |
| xProp->setPropertyValue(PROPERTY_LAYOUTINFORMATION,makeAny(aWindows)); |
| } |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| void ODBFilter::fillPropertyMap(const Any& _rValue,TPropertyNameMap& _rMap) |
| { |
| Sequence<PropertyValue> aWindows; |
| _rValue >>= aWindows; |
| const PropertyValue *pIter = aWindows.getConstArray(); |
| const PropertyValue *pEnd = pIter + aWindows.getLength(); |
| for (; pIter != pEnd; ++pIter) |
| { |
| Sequence<PropertyValue> aValue; |
| pIter->Value >>= aValue; |
| _rMap.insert(TPropertyNameMap::value_type(pIter->Name,aValue)); |
| } |
| |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::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_DATABASE, XML_TOK_DOC_DATABASE }, |
| { XML_NAMESPACE_OOO, XML_DATABASE, XML_TOK_DOC_DATABASE }, |
| { XML_NAMESPACE_OFFICE, XML_SCRIPTS, XML_TOK_DOC_SCRIPT }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pDocElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pDocElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetDatabaseElemTokenMap() const |
| { |
| if ( !m_pDatabaseElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_DATASOURCE, XML_TOK_DATASOURCE }, |
| { XML_NAMESPACE_DB, XML_FORMS, XML_TOK_FORMS}, |
| { XML_NAMESPACE_DB, XML_REPORTS, XML_TOK_REPORTS}, |
| { XML_NAMESPACE_DB, XML_QUERIES, XML_TOK_QUERIES}, |
| { XML_NAMESPACE_DB, XML_TABLES, XML_TOK_TABLES}, |
| { XML_NAMESPACE_DB, XML_TABLE_REPRESENTATIONS, XML_TOK_TABLES}, |
| { XML_NAMESPACE_DB, XML_SCHEMA_DEFINITION, XML_TOK_SCHEMA_DEFINITION}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pDatabaseElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pDatabaseElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetDataSourceElemTokenMap() const |
| { |
| if ( !m_pDataSourceElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_CONNECTION_RESOURCE, XML_TOK_CONNECTION_RESOURCE}, |
| { XML_NAMESPACE_DB, XML_SUPPRESS_VERSION_COLUMNS, XML_TOK_SUPPRESS_VERSION_COLUMNS}, |
| { XML_NAMESPACE_DB, XML_JAVA_DRIVER_CLASS, XML_TOK_JAVA_DRIVER_CLASS}, |
| { XML_NAMESPACE_DB, XML_EXTENSION, XML_TOK_EXTENSION}, |
| { XML_NAMESPACE_DB, XML_IS_FIRST_ROW_HEADER_LINE, XML_TOK_IS_FIRST_ROW_HEADER_LINE}, |
| { XML_NAMESPACE_DB, XML_SHOW_DELETED, XML_TOK_SHOW_DELETED}, |
| { XML_NAMESPACE_DB, XML_IS_TABLE_NAME_LENGTH_LIMITED, XML_TOK_IS_TABLE_NAME_LENGTH_LIMITED}, |
| { XML_NAMESPACE_DB, XML_SYSTEM_DRIVER_SETTINGS, XML_TOK_SYSTEM_DRIVER_SETTINGS}, |
| { XML_NAMESPACE_DB, XML_ENABLE_SQL92_CHECK, XML_TOK_ENABLE_SQL92_CHECK}, |
| { XML_NAMESPACE_DB, XML_APPEND_TABLE_ALIAS_NAME, XML_TOK_APPEND_TABLE_ALIAS_NAME}, |
| { XML_NAMESPACE_DB, XML_PARAMETER_NAME_SUBSTITUTION, XML_TOK_PARAMETER_NAME_SUBSTITUTION}, |
| { XML_NAMESPACE_DB, XML_IGNORE_DRIVER_PRIVILEGES, XML_TOK_IGNORE_DRIVER_PRIVILEGES}, |
| { XML_NAMESPACE_DB, XML_BOOLEAN_COMPARISON_MODE, XML_TOK_BOOLEAN_COMPARISON_MODE}, |
| { XML_NAMESPACE_DB, XML_USE_CATALOG, XML_TOK_USE_CATALOG}, |
| { XML_NAMESPACE_DB, XML_BASE_DN, XML_TOK_BASE_DN}, |
| { XML_NAMESPACE_DB, XML_MAX_ROW_COUNT, XML_TOK_MAX_ROW_COUNT}, |
| { XML_NAMESPACE_DB, XML_LOGIN, XML_TOK_LOGIN}, |
| { XML_NAMESPACE_DB, XML_TABLE_FILTER, XML_TOK_TABLE_FILTER}, |
| { XML_NAMESPACE_DB, XML_TABLE_TYPE_FILTER, XML_TOK_TABLE_TYPE_FILTER}, |
| { XML_NAMESPACE_DB, XML_AUTO_INCREMENT, XML_TOK_AUTO_INCREMENT}, |
| { XML_NAMESPACE_DB, XML_DELIMITER, XML_TOK_DELIMITER}, |
| { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTINGS, XML_TOK_DATA_SOURCE_SETTINGS}, |
| { XML_NAMESPACE_DB, XML_FONT_CHARSET, XML_TOK_FONT_CHARSET}, |
| // db odf 12 |
| { XML_NAMESPACE_DB, XML_CONNECTION_DATA, XML_TOK_CONNECTION_DATA}, |
| { XML_NAMESPACE_DB, XML_DATABASE_DESCRIPTION, XML_TOK_DATABASE_DESCRIPTION}, |
| { XML_NAMESPACE_DB, XML_COMPOUND_DATABASE, XML_TOK_COMPOUND_DATABASE}, |
| { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_DB_HREF}, |
| { XML_NAMESPACE_DB, XML_MEDIA_TYPE, XML_TOK_MEDIA_TYPE}, |
| { XML_NAMESPACE_DB, XML_TYPE, XML_TOK_DB_TYPE}, |
| { XML_NAMESPACE_DB, XML_HOSTNAME, XML_TOK_HOSTNAME}, |
| { XML_NAMESPACE_DB, XML_PORT, XML_TOK_PORT}, |
| { XML_NAMESPACE_DB, XML_LOCAL_SOCKET, XML_TOK_LOCAL_SOCKET}, |
| { XML_NAMESPACE_DB, XML_DATABASE_NAME, XML_TOK_DATABASE_NAME}, |
| { XML_NAMESPACE_DB, XML_DRIVER_SETTINGS, XML_TOK_DRIVER_SETTINGS}, |
| { XML_NAMESPACE_DB, XML_JAVA_CLASSPATH, XML_TOK_JAVA_CLASSPATH}, |
| { XML_NAMESPACE_DB, XML_CHARACTER_SET, XML_TOK_CHARACTER_SET}, |
| { XML_NAMESPACE_DB, XML_APPLICATION_CONNECTION_SETTINGS,XML_TOK_APPLICATION_CONNECTION_SETTINGS}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pDataSourceElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pDataSourceElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetLoginElemTokenMap() const |
| { |
| if ( !m_pLoginElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_USER_NAME, XML_TOK_USER_NAME}, |
| { XML_NAMESPACE_DB, XML_IS_PASSWORD_REQUIRED, XML_TOK_IS_PASSWORD_REQUIRED}, |
| { XML_NAMESPACE_DB, XML_USE_SYSTEM_USER, XML_TOK_USE_SYSTEM_USER}, |
| { XML_NAMESPACE_DB, XML_LOGIN_TIMEOUT, XML_TOK_LOGIN_TIMEOUT}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pLoginElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pLoginElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetDatabaseDescriptionElemTokenMap() const |
| { |
| if ( !m_pDatabaseDescriptionElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_FILE_BASED_DATABASE, XML_TOK_FILE_BASED_DATABASE}, |
| { XML_NAMESPACE_DB, XML_SERVER_DATABASE, XML_TOK_SERVER_DATABASE}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pDatabaseDescriptionElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pDatabaseDescriptionElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetDataSourceInfoElemTokenMap() const |
| { |
| if ( !m_pDataSourceInfoElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_ADDITIONAL_COLUMN_STATEMENT,XML_TOK_ADDITIONAL_COLUMN_STATEMENT}, |
| { XML_NAMESPACE_DB, XML_ROW_RETRIEVING_STATEMENT, XML_TOK_ROW_RETRIEVING_STATEMENT}, |
| { XML_NAMESPACE_DB, XML_STRING, XML_TOK_STRING}, |
| { XML_NAMESPACE_DB, XML_FIELD, XML_TOK_FIELD}, |
| { XML_NAMESPACE_DB, XML_DECIMAL, XML_TOK_DECIMAL}, |
| { XML_NAMESPACE_DB, XML_THOUSAND, XML_TOK_THOUSAND}, |
| { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING, XML_TOK_DATA_SOURCE_SETTING}, |
| { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_VALUE, XML_TOK_DATA_SOURCE_SETTING_VALUE}, |
| { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_IS_LIST,XML_TOK_DATA_SOURCE_SETTING_IS_LIST}, |
| { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_TYPE, XML_TOK_DATA_SOURCE_SETTING_TYPE}, |
| { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_NAME, XML_TOK_DATA_SOURCE_SETTING_NAME}, |
| { XML_NAMESPACE_DB, XML_FONT_CHARSET, XML_TOK_FONT_CHARSET}, |
| { XML_NAMESPACE_DB, XML_ENCODING, XML_TOK_ENCODING}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pDataSourceInfoElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pDataSourceInfoElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetDocumentsElemTokenMap() const |
| { |
| if ( !m_pDocumentsElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_COMPONENT, XML_TOK_COMPONENT}, |
| { XML_NAMESPACE_DB, XML_COMPONENT_COLLECTION, XML_TOK_COMPONENT_COLLECTION}, |
| { XML_NAMESPACE_DB, XML_QUERY_COLLECTION, XML_TOK_QUERY_COLLECTION}, |
| { XML_NAMESPACE_DB, XML_QUERY, XML_TOK_QUERY}, |
| { XML_NAMESPACE_DB, XML_TABLE, XML_TOK_TABLE}, |
| { XML_NAMESPACE_DB, XML_TABLE_REPRESENTATION, XML_TOK_TABLE}, |
| { XML_NAMESPACE_DB, XML_COLUMN, XML_TOK_COLUMN}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pDocumentsElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pDocumentsElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetComponentElemTokenMap() const |
| { |
| if ( !m_pComponentElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_HREF }, |
| { XML_NAMESPACE_XLINK, XML_TYPE, XML_TOK_TYPE }, |
| { XML_NAMESPACE_XLINK, XML_SHOW, XML_TOK_SHOW }, |
| { XML_NAMESPACE_XLINK, XML_ACTUATE, XML_TOK_ACTUATE}, |
| { XML_NAMESPACE_DB, XML_AS_TEMPLATE, XML_TOK_AS_TEMPLATE }, |
| { XML_NAMESPACE_DB, XML_NAME, XML_TOK_COMPONENT_NAME }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pComponentElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pComponentElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetQueryElemTokenMap() const |
| { |
| if ( !m_pQueryElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_COMMAND, XML_TOK_COMMAND }, |
| { XML_NAMESPACE_DB, XML_ESCAPE_PROCESSING, XML_TOK_ESCAPE_PROCESSING }, |
| { XML_NAMESPACE_DB, XML_NAME, XML_TOK_QUERY_NAME }, |
| { XML_NAMESPACE_DB, XML_FILTER_STATEMENT, XML_TOK_FILTER_STATEMENT }, |
| { XML_NAMESPACE_DB, XML_ORDER_STATEMENT, XML_TOK_ORDER_STATEMENT }, |
| { XML_NAMESPACE_DB, XML_CATALOG_NAME, XML_TOK_CATALOG_NAME }, |
| { XML_NAMESPACE_DB, XML_SCHEMA_NAME, XML_TOK_SCHEMA_NAME }, |
| { XML_NAMESPACE_DB, XML_STYLE_NAME, XML_TOK_STYLE_NAME}, |
| { XML_NAMESPACE_DB, XML_APPLY_FILTER, XML_TOK_APPLY_FILTER}, |
| { XML_NAMESPACE_DB, XML_APPLY_ORDER, XML_TOK_APPLY_ORDER}, |
| { XML_NAMESPACE_DB, XML_COLUMNS, XML_TOK_COLUMNS}, |
| XML_TOKEN_MAP_END |
| }; |
| m_pQueryElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pQueryElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| const SvXMLTokenMap& ODBFilter::GetColumnElemTokenMap() const |
| { |
| if ( !m_pColumnElemTokenMap.get() ) |
| { |
| static __FAR_DATA SvXMLTokenMapEntry aElemTokenMap[]= |
| { |
| { XML_NAMESPACE_DB, XML_NAME, XML_TOK_COLUMN_NAME }, |
| { XML_NAMESPACE_DB, XML_STYLE_NAME, XML_TOK_COLUMN_STYLE_NAME }, |
| { XML_NAMESPACE_DB, XML_HELP_MESSAGE, XML_TOK_COLUMN_HELP_MESSAGE }, |
| { XML_NAMESPACE_DB, XML_VISIBILITY, XML_TOK_COLUMN_VISIBILITY }, |
| { XML_NAMESPACE_DB, XML_DEFAULT_VALUE, XML_TOK_COLUMN_DEFAULT_VALUE }, |
| { XML_NAMESPACE_DB, XML_TYPE_NAME, XML_TOK_COLUMN_TYPE_NAME }, |
| { XML_NAMESPACE_DB, XML_VISIBLE, XML_TOK_COLUMN_VISIBLE }, |
| { XML_NAMESPACE_DB, XML_DEFAULT_CELL_STYLE_NAME, XML_TOK_DEFAULT_CELL_STYLE_NAME }, |
| XML_TOKEN_MAP_END |
| }; |
| m_pColumnElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap )); |
| } |
| return *m_pColumnElemTokenMap; |
| } |
| // ----------------------------------------------------------------------------- |
| SvXMLImportContext* ODBFilter::CreateStylesContext(sal_uInt16 _nPrefix,const ::rtl::OUString& rLocalName, |
| const uno::Reference< XAttributeList>& xAttrList, sal_Bool bIsAutoStyle ) |
| { |
| SvXMLImportContext *pContext = NULL; |
| if (!pContext) |
| { |
| pContext = new OTableStylesContext(*this, _nPrefix, rLocalName, xAttrList, bIsAutoStyle); |
| if (bIsAutoStyle) |
| //xAutoStyles = pContext; |
| SetAutoStyles((SvXMLStylesContext*)pContext); |
| else |
| //xStyles = pContext; |
| SetStyles((SvXMLStylesContext*)pContext); |
| } |
| return pContext; |
| } |
| // ----------------------------------------------------------------------------- |
| SvXMLImportContext* ODBFilter::CreateScriptContext( const ::rtl::OUString& _rLocalName ) |
| { |
| return new XMLScriptContext( *this, XML_NAMESPACE_OFFICE, _rLocalName, GetModel() ); |
| } |
| // ----------------------------------------------------------------------------- |
| UniReference < XMLPropertySetMapper > ODBFilter::GetTableStylesPropertySetMapper() const |
| { |
| if ( !m_xTableStylesPropertySetMapper.is() ) |
| { |
| m_xTableStylesPropertySetMapper = OXMLHelper::GetTableStylesPropertySetMapper(); |
| } |
| return m_xTableStylesPropertySetMapper; |
| } |
| // ----------------------------------------------------------------------------- |
| UniReference < XMLPropertySetMapper > ODBFilter::GetColumnStylesPropertySetMapper() const |
| { |
| if ( !m_xColumnStylesPropertySetMapper.is() ) |
| { |
| m_xColumnStylesPropertySetMapper = OXMLHelper::GetColumnStylesPropertySetMapper(); |
| } |
| return m_xColumnStylesPropertySetMapper; |
| } |
| // ----------------------------------------------------------------------------- |
| UniReference < XMLPropertySetMapper > ODBFilter::GetCellStylesPropertySetMapper() const |
| { |
| if ( !m_xCellStylesPropertySetMapper.is() ) |
| { |
| m_xCellStylesPropertySetMapper = OXMLHelper::GetCellStylesPropertySetMapper(); |
| } |
| return m_xCellStylesPropertySetMapper; |
| } |
| // ----------------------------------------------------------------------------- |
| void ODBFilter::setPropertyInfo() |
| { |
| Reference<XPropertySet> xDataSource(getDataSource()); |
| if ( !xDataSource.is() ) |
| return; |
| |
| ::connectivity::DriversConfig aDriverConfig(getServiceFactory()); |
| const ::rtl::OUString sURL = ::comphelper::getString(xDataSource->getPropertyValue(PROPERTY_URL)); |
| ::comphelper::NamedValueCollection aDataSourceSettings = aDriverConfig.getProperties( sURL ); |
| |
| Sequence<PropertyValue> aInfo; |
| if ( !m_aInfoSequence.empty() ) |
| aInfo = Sequence<PropertyValue>(&(*m_aInfoSequence.begin()),m_aInfoSequence.size()); |
| aDataSourceSettings.merge( ::comphelper::NamedValueCollection( aInfo ), true ); |
| |
| aDataSourceSettings >>= aInfo; |
| if ( aInfo.getLength() ) |
| { |
| try |
| { |
| xDataSource->setPropertyValue(PROPERTY_INFO,makeAny(aInfo)); |
| } |
| catch(Exception) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| }// dbaxml |
| // ----------------------------------------------------------------------------- |
