| /************************************************************** |
| * |
| * 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" |
| |
| #include "dbmm_global.hrc" |
| #include "dbmm_module.hxx" |
| #include "dbmm_types.hxx" |
| #include "docinteraction.hxx" |
| #include "migrationengine.hxx" |
| #include "migrationerror.hxx" |
| #include "migrationprogress.hxx" |
| #include "migrationlog.hxx" |
| #include "progresscapture.hxx" |
| #include "progressmixer.hxx" |
| |
| /** === begin UNO includes === **/ |
| #include <com/sun/star/sdb/XFormDocumentsSupplier.hpp> |
| #include <com/sun/star/sdb/XReportDocumentsSupplier.hpp> |
| #include <com/sun/star/util/XCloseable.hpp> |
| #include <com/sun/star/frame/XModel.hpp> |
| #include <com/sun/star/frame/XComponentLoader.hpp> |
| #include <com/sun/star/ucb/XCommandProcessor.hpp> |
| #include <com/sun/star/ucb/XContent.hpp> |
| #include <com/sun/star/embed/XComponentSupplier.hpp> |
| #include <com/sun/star/embed/ElementModes.hpp> |
| #include <com/sun/star/document/XStorageBasedDocument.hpp> |
| #include <com/sun/star/embed/XTransactedObject.hpp> |
| #include <com/sun/star/frame/XStorable.hpp> |
| #include <com/sun/star/embed/XEmbedPersist.hpp> |
| #include <com/sun/star/script/DocumentScriptLibraryContainer.hpp> |
| #include <com/sun/star/script/DocumentDialogLibraryContainer.hpp> |
| #include <com/sun/star/document/XEmbeddedScripts.hpp> |
| #include <com/sun/star/document/XEventsSupplier.hpp> |
| #include <com/sun/star/uri/UriReferenceFactory.hpp> |
| #include <com/sun/star/uri/XVndSunStarScriptUrlReference.hpp> |
| #include <com/sun/star/form/XFormsSupplier.hpp> |
| #include <com/sun/star/drawing/XDrawPageSupplier.hpp> |
| #include <com/sun/star/drawing/XDrawPagesSupplier.hpp> |
| #include <com/sun/star/script/XEventAttacherManager.hpp> |
| #include <com/sun/star/script/XLibraryContainerPassword.hpp> |
| #include <com/sun/star/io/WrongFormatException.hpp> |
| #include <com/sun/star/script/XScriptEventsSupplier.hpp> |
| #include <com/sun/star/io/XInputStreamProvider.hpp> |
| /** === end UNO includes === **/ |
| |
| #include <comphelper/documentinfo.hxx> |
| #include <comphelper/interaction.hxx> |
| #include <comphelper/namedvaluecollection.hxx> |
| #include <comphelper/storagehelper.hxx> |
| #include <comphelper/string.hxx> |
| #include <comphelper/types.hxx> |
| #include <cppuhelper/exc_hlp.hxx> |
| #include <tools/string.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/ref.hxx> |
| #include <unotools/sharedunocomponent.hxx> |
| #include <xmlscript/xmldlg_imexp.hxx> |
| |
| #include <vector> |
| #include <set> |
| |
| #define DEFAULT_DOC_PROGRESS_RANGE 100000 |
| |
| //........................................................................ |
| namespace dbmm |
| { |
| //........................................................................ |
| |
| /** === begin UNO using === **/ |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::uno::XInterface; |
| using ::com::sun::star::uno::UNO_QUERY; |
| using ::com::sun::star::uno::UNO_QUERY_THROW; |
| using ::com::sun::star::uno::UNO_SET_THROW; |
| using ::com::sun::star::uno::Exception; |
| using ::com::sun::star::uno::RuntimeException; |
| using ::com::sun::star::uno::Any; |
| using ::com::sun::star::uno::makeAny; |
| using ::com::sun::star::sdb::XOfficeDatabaseDocument; |
| using ::com::sun::star::sdb::XFormDocumentsSupplier; |
| using ::com::sun::star::sdb::XReportDocumentsSupplier; |
| using ::com::sun::star::container::XNameAccess; |
| using ::com::sun::star::uno::Sequence; |
| using ::com::sun::star::util::XCloseable; |
| using ::com::sun::star::util::CloseVetoException; |
| using ::com::sun::star::lang::XComponent; |
| using ::com::sun::star::frame::XModel; |
| using ::com::sun::star::frame::XComponentLoader; |
| using ::com::sun::star::ucb::XCommandProcessor; |
| using ::com::sun::star::ucb::XContent; |
| using ::com::sun::star::ucb::Command; |
| using ::com::sun::star::embed::XComponentSupplier; |
| using ::com::sun::star::task::XStatusIndicator; |
| using ::com::sun::star::embed::XStorage; |
| using ::com::sun::star::document::XStorageBasedDocument; |
| using ::com::sun::star::embed::XTransactedObject; |
| using ::com::sun::star::frame::XStorable; |
| using ::com::sun::star::embed::XEmbedPersist; |
| using ::com::sun::star::script::DocumentDialogLibraryContainer; |
| using ::com::sun::star::script::DocumentScriptLibraryContainer; |
| using ::com::sun::star::script::XStorageBasedLibraryContainer; |
| using ::com::sun::star::document::XEmbeddedScripts; |
| using ::com::sun::star::container::XNameContainer; |
| using ::com::sun::star::document::XEventsSupplier; |
| using ::com::sun::star::container::XNameReplace; |
| using com::sun::star::uri::UriReferenceFactory; |
| using com::sun::star::uri::XUriReferenceFactory; |
| using com::sun::star::uri::XVndSunStarScriptUrlReference; |
| using ::com::sun::star::form::XFormsSupplier; |
| using ::com::sun::star::drawing::XDrawPageSupplier; |
| using ::com::sun::star::drawing::XDrawPagesSupplier; |
| using ::com::sun::star::drawing::XDrawPage; |
| using ::com::sun::star::drawing::XDrawPages; |
| using ::com::sun::star::container::XIndexAccess; |
| using ::com::sun::star::script::XEventAttacherManager; |
| using ::com::sun::star::script::ScriptEventDescriptor; |
| using ::com::sun::star::script::XLibraryContainerPassword; |
| using ::com::sun::star::io::WrongFormatException; |
| using ::com::sun::star::script::XScriptEventsSupplier; |
| using ::com::sun::star::io::XInputStreamProvider; |
| using ::com::sun::star::io::XInputStream; |
| /** === end UNO using === **/ |
| namespace ElementModes = ::com::sun::star::embed::ElementModes; |
| |
| // migration phases whose progresses are to be mixed into one progress |
| #define PHASE_JAVASCRIPT 1 |
| #define PHASE_BEANSHELL 2 |
| #define PHASE_PYTHON 3 |
| #define PHASE_JAVA 4 |
| #define PHASE_BASIC 5 |
| #define PHASE_DIALOGS 6 |
| |
| //==================================================================== |
| //= SubDocument |
| //==================================================================== |
| struct SubDocument |
| { |
| Reference< XCommandProcessor > xCommandProcessor; |
| Reference< XModel > xDocument; // valid only temporarily |
| ::rtl::OUString sHierarchicalName; |
| SubDocumentType eType; |
| size_t nNumber; |
| |
| SubDocument( const Reference< XCommandProcessor >& _rxCommandProcessor, const ::rtl::OUString& _rName, |
| const SubDocumentType _eType, const size_t _nNumber ) |
| :xCommandProcessor( _rxCommandProcessor ) |
| ,xDocument() |
| ,sHierarchicalName( _rName ) |
| ,eType( _eType ) |
| ,nNumber( _nNumber ) |
| { |
| } |
| }; |
| |
| typedef ::std::vector< SubDocument > SubDocuments; |
| |
| //==================================================================== |
| //= helper |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| typedef ::utl::SharedUNOComponent< XStorage > SharedStorage; |
| |
| namespace |
| { |
| //---------------------------------------------------------------- |
| static const ::rtl::OUString& lcl_getScriptsStorageName() |
| { |
| static const ::rtl::OUString s_sScriptsStorageName( RTL_CONSTASCII_USTRINGPARAM( "Scripts" ) ); |
| return s_sScriptsStorageName; |
| } |
| |
| //---------------------------------------------------------------- |
| static const ::rtl::OUString& lcl_getScriptsSubStorageName( const ScriptType _eType ) |
| { |
| static const ::rtl::OUString s_sBeanShell ( RTL_CONSTASCII_USTRINGPARAM( "beanshell" ) ); |
| static const ::rtl::OUString s_sJavaScript( RTL_CONSTASCII_USTRINGPARAM( "javascript" ) ); |
| static const ::rtl::OUString s_sPython ( RTL_CONSTASCII_USTRINGPARAM( "python" ) ); // TODO: is this correct? |
| static const ::rtl::OUString s_sJava ( RTL_CONSTASCII_USTRINGPARAM( "java" ) ); |
| |
| switch ( _eType ) |
| { |
| case eBeanShell: return s_sBeanShell; |
| case eJavaScript: return s_sJavaScript; |
| case ePython: return s_sPython; |
| case eJava: return s_sJava; |
| default: |
| break; |
| } |
| |
| OSL_ENSURE( false, "lcl_getScriptsSubStorageName: illegal type!" ); |
| static ::rtl::OUString s_sEmpty; |
| return s_sEmpty; |
| } |
| |
| //---------------------------------------------------------------- |
| static bool lcl_getScriptTypeFromLanguage( const ::rtl::OUString& _rLanguage, ScriptType& _out_rScriptType ) |
| { |
| struct LanguageMapping |
| { |
| const sal_Char* pAsciiLanguage; |
| const ScriptType eScriptType; |
| |
| LanguageMapping( const sal_Char* _pAsciiLanguage, const ScriptType _eScriptType ) |
| :pAsciiLanguage( _pAsciiLanguage ) |
| ,eScriptType( _eScriptType ) |
| { |
| } |
| } |
| aLanguageMapping[] = |
| { |
| LanguageMapping( "JavaScript", eJavaScript ), |
| LanguageMapping( "BeanShell", eBeanShell ), |
| LanguageMapping( "Java", eJava ), |
| LanguageMapping( "Python", ePython ), // TODO: is this correct? |
| LanguageMapping( "Basic", eBasic ) |
| }; |
| for ( size_t i=0; i < sizeof( aLanguageMapping ) / sizeof( aLanguageMapping[0] ); ++i ) |
| { |
| if ( _rLanguage.equalsAscii( aLanguageMapping[i].pAsciiLanguage ) ) |
| { |
| _out_rScriptType = aLanguageMapping[i].eScriptType; |
| return true; |
| } |
| } |
| OSL_ENSURE( false, "lcl_getScriptTypeFromLanguage: unknown language!" ); |
| return false; |
| } |
| |
| //---------------------------------------------------------------- |
| ::rtl::OUString lcl_getSubDocumentDescription( const SubDocument& _rDocument ) |
| { |
| ::rtl::OUString sObjectName = String( MacroMigrationResId( _rDocument.eType == eForm ? STR_FORM : STR_REPORT ) ); |
| ::comphelper::string::searchAndReplaceAsciiI( sObjectName, "$name$", _rDocument.sHierarchicalName ); |
| return sObjectName; |
| } |
| |
| //---------------------------------------------------------------- |
| static Any lcl_executeCommand_throw( const Reference< XCommandProcessor >& _rxCommandProc, |
| const sal_Char* _pAsciiCommand ) |
| { |
| OSL_PRECOND( _rxCommandProc.is(), "lcl_executeCommand_throw: illegal object!" ); |
| if ( !_rxCommandProc.is() ) |
| return Any(); |
| |
| Command aCommand; |
| aCommand.Name = ::rtl::OUString::createFromAscii( _pAsciiCommand ); |
| return _rxCommandProc->execute( |
| aCommand, _rxCommandProc->createCommandIdentifier(), NULL ); |
| } |
| |
| //---------------------------------------------------------------- |
| ::rtl::OUString lcl_getMimeType_nothrow( const Reference< XCommandProcessor >& _rxContent ) |
| { |
| ::rtl::OUString sMimeType; |
| try |
| { |
| Reference< XContent > xContent( _rxContent, UNO_QUERY_THROW ); |
| sMimeType = xContent->getContentType(); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| return sMimeType; |
| } |
| |
| //---------------------------------------------------------------- |
| enum OpenDocResult |
| { |
| eOpenedDoc, |
| eIgnoreDoc, |
| eFailure |
| }; |
| |
| //---------------------------------------------------------------- |
| static OpenDocResult lcl_loadSubDocument_nothrow( SubDocument& _rDocument, |
| const Reference< XStatusIndicator >& _rxProgress, MigrationLog& _rLogger ) |
| { |
| OSL_PRECOND( !_rDocument.xDocument.is(), "lcl_loadSubDocument_nothrow: already loaded!" ); |
| |
| try |
| { |
| ::comphelper::NamedValueCollection aLoadArgs; |
| aLoadArgs.put( "Hidden", (sal_Bool)sal_True ); |
| aLoadArgs.put( "StatusIndicator", _rxProgress ); |
| |
| Reference< XCommandProcessor > xCommandProcessor( _rDocument.xCommandProcessor, UNO_SET_THROW ); |
| Command aCommand; |
| aCommand.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "openDesign" ) ); |
| aCommand.Argument <<= aLoadArgs.getPropertyValues(); |
| Reference< XComponent > xDocComponent( |
| xCommandProcessor->execute( |
| aCommand, xCommandProcessor->createCommandIdentifier(), NULL |
| ), |
| UNO_QUERY |
| ); |
| OSL_ENSURE( xDocComponent.is(), "lcl_loadSubDocument_nothrow: no component loaded!" ); |
| |
| _rDocument.xDocument.set( xDocComponent, UNO_QUERY_THROW ); |
| } |
| catch( const Exception& ) |
| { |
| Any aError( ::cppu::getCaughtException() ); |
| |
| bool bCausedByNewStyleReport = |
| ( _rDocument.eType == eReport ) |
| && ( aError.isExtractableTo( ::cppu::UnoType< WrongFormatException >::get() ) ) |
| && ( lcl_getMimeType_nothrow( _rDocument.xCommandProcessor ).equalsAscii( "application/vnd.sun.xml.report" ) ); |
| |
| if ( bCausedByNewStyleReport ) |
| { |
| _rLogger.logRecoverable( MigrationError( |
| ERR_NEW_STYLE_REPORT, |
| lcl_getSubDocumentDescription( _rDocument ) |
| ) ); |
| return eIgnoreDoc; |
| } |
| else |
| { |
| _rLogger.logFailure( MigrationError( |
| ERR_OPENING_SUB_DOCUMENT_FAILED, |
| lcl_getSubDocumentDescription( _rDocument ), |
| aError |
| ) ); |
| } |
| } |
| return _rDocument.xDocument.is() ? eOpenedDoc : eFailure; |
| } |
| |
| //---------------------------------------------------------------- |
| static bool lcl_unloadSubDocument_nothrow( SubDocument& _rDocument, MigrationLog& _rLogger ) |
| { |
| bool bSuccess = false; |
| Any aException; |
| try |
| { |
| OSL_VERIFY( lcl_executeCommand_throw( _rDocument.xCommandProcessor, "close" ) >>= bSuccess ); |
| } |
| catch( const Exception& ) |
| { |
| aException = ::cppu::getCaughtException(); |
| } |
| |
| // log the failure, if any |
| if ( !bSuccess ) |
| { |
| _rLogger.logFailure( MigrationError( |
| ERR_CLOSING_SUB_DOCUMENT_FAILED, |
| lcl_getSubDocumentDescription( _rDocument ), |
| aException |
| ) ); |
| } |
| |
| _rDocument.xDocument.clear(); |
| return bSuccess; |
| } |
| |
| //---------------------------------------------------------------- |
| bool lcl_commitStorage_nothrow( const Reference< XStorage >& _rxStorage ) |
| { |
| try |
| { |
| Reference< XTransactedObject > xTrans( _rxStorage, UNO_QUERY_THROW ); |
| xTrans->commit(); |
| } |
| catch( const Exception& ) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| //---------------------------------------------------------------- |
| bool lcl_commitDocumentStorage_nothrow( const Reference< XModel >& _rxDocument, MigrationLog& _rLogger ) |
| { |
| bool bSuccess = false; |
| Any aException; |
| try |
| { |
| Reference< XStorageBasedDocument > xStorageDoc( _rxDocument, UNO_QUERY_THROW ); |
| Reference< XStorage > xDocStorage( xStorageDoc->getDocumentStorage(), UNO_QUERY_THROW ); |
| bSuccess = lcl_commitStorage_nothrow( xDocStorage ); |
| } |
| catch( const Exception& ) |
| { |
| aException = ::cppu::getCaughtException(); |
| } |
| |
| // log the failure, if any |
| if ( !bSuccess ) |
| { |
| _rLogger.logFailure( MigrationError( |
| ERR_STORAGE_COMMIT_FAILED, |
| ::comphelper::DocumentInfo::getDocumentTitle( _rxDocument ), |
| aException |
| ) ); |
| } |
| return bSuccess; |
| } |
| |
| //---------------------------------------------------------------- |
| bool lcl_storeDocument_nothrow( const Reference< XModel >& _rxDocument, MigrationLog& _rLogger ) |
| { |
| bool bSuccess = false; |
| Any aException; |
| try |
| { |
| Reference< XStorable > xStorable( _rxDocument, UNO_QUERY_THROW ); |
| xStorable->store(); |
| bSuccess = true; |
| } |
| catch( const Exception& ) |
| { |
| aException = ::cppu::getCaughtException(); |
| } |
| |
| // log the failure, if any |
| if ( !bSuccess ) |
| { |
| _rLogger.logFailure( MigrationError( |
| ERR_STORING_DATABASEDOC_FAILED, |
| aException |
| ) ); |
| } |
| return bSuccess; |
| } |
| |
| //---------------------------------------------------------------- |
| bool lcl_storeEmbeddedDocument_nothrow( const SubDocument& _rDocument ) |
| { |
| try |
| { |
| lcl_executeCommand_throw( _rDocument.xCommandProcessor, "store" ); |
| } |
| catch( const Exception& ) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| return false; |
| } |
| return true; |
| } |
| } |
| |
| //==================================================================== |
| //= DrawPageIterator |
| //==================================================================== |
| class DrawPageIterator |
| { |
| public: |
| DrawPageIterator( const Reference< XModel >& _rxDocument ) |
| :m_xDocument( _rxDocument ) |
| ,m_nPageCount( 0 ) |
| ,m_nCurrentPage( 0 ) |
| { |
| Reference< XDrawPageSupplier > xSingle( _rxDocument, UNO_QUERY ); |
| Reference< XDrawPagesSupplier > xMulti( _rxDocument, UNO_QUERY ); |
| if ( xSingle.is() ) |
| { |
| m_xSinglePage.set( xSingle->getDrawPage(), UNO_SET_THROW ); |
| m_nPageCount = 1; |
| } |
| else if ( xMulti.is() ) |
| { |
| m_xMultiPages.set( xMulti->getDrawPages(), UNO_SET_THROW ); |
| m_nPageCount = m_xMultiPages->getCount(); |
| } |
| } |
| |
| bool hasMore() const |
| { |
| return m_nCurrentPage < m_nPageCount; |
| } |
| |
| Reference< XDrawPage > next() |
| { |
| Reference< XDrawPage > xNextPage; |
| |
| if ( m_xSinglePage.is() ) |
| { |
| xNextPage = m_xSinglePage; |
| } |
| else if ( m_xMultiPages.is() ) |
| { |
| xNextPage.set( m_xMultiPages->getByIndex( m_nCurrentPage ), UNO_QUERY_THROW ); |
| } |
| ++m_nCurrentPage; |
| return xNextPage; |
| } |
| |
| private: |
| const Reference< XModel > m_xDocument; |
| Reference< XDrawPage > m_xSinglePage; |
| Reference< XDrawPages > m_xMultiPages; |
| sal_Int32 m_nPageCount; |
| sal_Int32 m_nCurrentPage; |
| }; |
| |
| //==================================================================== |
| //= FormComponentScripts |
| //==================================================================== |
| class FormComponentScripts |
| { |
| public: |
| FormComponentScripts( |
| const Reference< XInterface >& _rxComponent, |
| const Reference< XEventAttacherManager >& _rxManager, |
| const sal_Int32 _nIndex |
| ) |
| :m_xComponent( _rxComponent, UNO_SET_THROW ) |
| ,m_xManager( _rxManager, UNO_SET_THROW ) |
| ,m_nIndex( _nIndex ) |
| { |
| } |
| |
| Sequence< ScriptEventDescriptor > getEvents() const |
| { |
| return m_xManager->getScriptEvents( m_nIndex ); |
| } |
| |
| void setEvents( const Sequence< ScriptEventDescriptor >& _rEvents ) const |
| { |
| m_xManager->registerScriptEvents( m_nIndex, _rEvents ); |
| } |
| |
| const Reference< XInterface >& getComponent() const |
| { |
| return m_xComponent; |
| } |
| |
| private: |
| const Reference< XInterface > m_xComponent; |
| const Reference< XEventAttacherManager > m_xManager; |
| const sal_Int32 m_nIndex; |
| }; |
| |
| //==================================================================== |
| //= FormComponentIterator |
| //==================================================================== |
| class FormComponentIterator |
| { |
| public: |
| FormComponentIterator( const Reference< XIndexAccess >& _rxContainer ) |
| :m_xContainer( _rxContainer, UNO_SET_THROW ) |
| ,m_xEventManager( _rxContainer, UNO_QUERY_THROW ) |
| ,m_nElementCount( _rxContainer->getCount() ) |
| ,m_nCurrentElement( 0 ) |
| { |
| } |
| |
| bool hasMore() const |
| { |
| return m_nCurrentElement < m_nElementCount; |
| } |
| |
| FormComponentScripts next() |
| { |
| FormComponentScripts aComponent( |
| Reference< XInterface >( m_xContainer->getByIndex( m_nCurrentElement ), UNO_QUERY_THROW ), |
| m_xEventManager, |
| m_nCurrentElement |
| ); |
| ++m_nCurrentElement; |
| return aComponent; |
| } |
| |
| private: |
| const Reference< XIndexAccess > m_xContainer; |
| const Reference< XEventAttacherManager > m_xEventManager; |
| const sal_Int32 m_nElementCount; |
| sal_Int32 m_nCurrentElement; |
| |
| }; |
| |
| //==================================================================== |
| //= ScriptsStorage - declaration |
| //==================================================================== |
| /** a helper class which encapsulates access to the storages for Java/Script, BeanShell, and Python scripts, |
| i.e. all script types which can be manipulated on storage level. |
| */ |
| class ScriptsStorage |
| { |
| public: |
| ScriptsStorage( MigrationLog& _rLogger ); |
| ScriptsStorage( const Reference< XModel >& _rxDocument, MigrationLog& _rLogger ); |
| ~ScriptsStorage(); |
| |
| /** determines whether the instance is valid, i.e. refers to a valid root storage |
| for reading/storing scripts |
| */ |
| inline bool isValid() const { return m_xScriptsStorage.is(); } |
| |
| /** binds the instance to a new document. Only to be called when the instance is not yet |
| bound (i.e. isValid returns <FALSE/>). |
| */ |
| void bind( const Reference< XModel >& _rxDocument ); |
| |
| /// determines whether scripts of the given type are present |
| bool hasScripts( const ScriptType _eType ) const; |
| |
| /// returns the root storage for the scripts of the given type |
| SharedStorage |
| getScriptsRoot( const ScriptType _eType ) const; |
| |
| /** returns the names of the elements in the "Scripts" storage |
| */ |
| ::std::set< ::rtl::OUString > |
| getElementNames() const; |
| |
| /** removes the sub storage for a given script type |
| @precond |
| the respective storage is empty |
| @precond |
| the ScriptsStorage instance was opened for writing |
| */ |
| void removeScriptTypeStorage( const ScriptType _eType ) const; |
| |
| /** commits the changes at our XStorage object |
| */ |
| bool commit(); |
| |
| /** removes the "Scripts" sub storage from the given document's root storage |
| @precond |
| the "Scripts" storage is empty |
| */ |
| static bool |
| removeFromDocument( const Reference< XModel >& _rxDocument, MigrationLog& _rLogger ); |
| |
| private: |
| MigrationLog& m_rLogger; |
| SharedStorage m_xScriptsStorage; |
| }; |
| |
| //==================================================================== |
| //= ScriptsStorage - implementation |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| ScriptsStorage::ScriptsStorage( MigrationLog& _rLogger ) |
| :m_rLogger( _rLogger ) |
| ,m_xScriptsStorage() |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| ScriptsStorage::ScriptsStorage( const Reference< XModel >& _rxDocument, MigrationLog& _rLogger ) |
| :m_rLogger( _rLogger ) |
| ,m_xScriptsStorage() |
| { |
| bind( _rxDocument ); |
| } |
| |
| //-------------------------------------------------------------------- |
| ScriptsStorage::~ScriptsStorage() |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| bool ScriptsStorage::commit() |
| { |
| return lcl_commitStorage_nothrow( m_xScriptsStorage ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void ScriptsStorage::bind( const Reference< XModel >& _rxDocument ) |
| { |
| OSL_PRECOND( !isValid(), "ScriptsStorage:bind: did not bother, yet, to check whether this is allowed!" ); |
| try |
| { |
| Reference< XStorageBasedDocument > xStorageDoc( _rxDocument, UNO_QUERY_THROW ); |
| Reference< XStorage > xDocStorage( xStorageDoc->getDocumentStorage(), UNO_QUERY_THROW ); |
| |
| // the the "Scripts" storage exist, or if it does not (yet) exist and we are in write mode |
| // => open the storage |
| if ( ( xDocStorage->hasByName( lcl_getScriptsStorageName() ) |
| && xDocStorage->isStorageElement( lcl_getScriptsStorageName() ) |
| ) |
| || !xDocStorage->hasByName( lcl_getScriptsStorageName() ) |
| ) |
| { |
| m_xScriptsStorage.set( |
| xDocStorage->openStorageElement( |
| lcl_getScriptsStorageName(), ElementModes::READWRITE |
| ), |
| UNO_QUERY_THROW |
| ); |
| } |
| } |
| catch( const Exception& ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_BIND_SCRIPT_STORAGE_FAILED, |
| ::comphelper::DocumentInfo::getDocumentTitle( _rxDocument ), |
| ::cppu::getCaughtException() |
| ) ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| bool ScriptsStorage::hasScripts( const ScriptType _eType ) const |
| { |
| OSL_PRECOND( isValid(), "ScriptsStorage::hasScripts: illegal call!" ); |
| if ( !isValid() ) |
| return false; |
| |
| const ::rtl::OUString& rSubStorageName( lcl_getScriptsSubStorageName( _eType ) ); |
| return m_xScriptsStorage->hasByName( rSubStorageName ) |
| && m_xScriptsStorage->isStorageElement( rSubStorageName ); |
| } |
| |
| //-------------------------------------------------------------------- |
| SharedStorage ScriptsStorage::getScriptsRoot( const ScriptType _eType ) const |
| { |
| SharedStorage xStorage; |
| if ( isValid() ) |
| { |
| xStorage.reset( m_xScriptsStorage->openStorageElement( |
| lcl_getScriptsSubStorageName( _eType ), ElementModes::READWRITE |
| ) ); |
| } |
| return xStorage; |
| } |
| |
| //-------------------------------------------------------------------- |
| ::std::set< ::rtl::OUString > ScriptsStorage::getElementNames() const |
| { |
| Sequence< ::rtl::OUString > aElementNames; |
| if ( isValid() ) |
| aElementNames = m_xScriptsStorage->getElementNames(); |
| |
| ::std::set< ::rtl::OUString > aNames; |
| ::std::copy( |
| aElementNames.getConstArray(), |
| aElementNames.getConstArray() + aElementNames.getLength(), |
| ::std::insert_iterator< ::std::set< ::rtl::OUString > >( aNames, aNames.end() ) |
| ); |
| return aNames; |
| } |
| |
| //-------------------------------------------------------------------- |
| void ScriptsStorage::removeScriptTypeStorage( const ScriptType _eType ) const |
| { |
| ::rtl::OUString sSubStorageName( lcl_getScriptsSubStorageName( _eType ) ); |
| if ( m_xScriptsStorage->hasByName( sSubStorageName ) ) |
| m_xScriptsStorage->removeElement( sSubStorageName ); |
| } |
| |
| //-------------------------------------------------------------------- |
| bool ScriptsStorage::removeFromDocument( const Reference< XModel >& _rxDocument, MigrationLog& _rLogger ) |
| { |
| try |
| { |
| Reference< XStorageBasedDocument > xStorageDoc( _rxDocument, UNO_QUERY_THROW ); |
| Reference< XStorage > xDocStorage( xStorageDoc->getDocumentStorage(), UNO_QUERY_THROW ); |
| xDocStorage->removeElement( lcl_getScriptsStorageName() ); |
| } |
| catch( const Exception& ) |
| { |
| _rLogger.logFailure( MigrationError( |
| ERR_REMOVE_SCRIPTS_STORAGE_FAILED, |
| ::comphelper::DocumentInfo::getDocumentTitle( _rxDocument ), |
| ::cppu::getCaughtException() |
| ) ) ; |
| return false; |
| } |
| return true; |
| } |
| |
| //==================================================================== |
| //= ProgressDelegator |
| //==================================================================== |
| class ProgressDelegator : public IProgressConsumer |
| { |
| public: |
| ProgressDelegator( IMigrationProgress& _rDelegator, |
| const ::rtl::OUString& _rObjectName, |
| const ::rtl::OUString& _rAction |
| ) |
| :m_rDelegator( _rDelegator ) |
| ,m_sObjectName( _rObjectName ) |
| ,m_sAction( _rAction ) |
| { |
| } |
| virtual ~ProgressDelegator() |
| { |
| } |
| |
| // IProgressConsumer |
| virtual void start( sal_uInt32 _nRange ) |
| { |
| m_rDelegator.startObject( m_sObjectName, m_sAction, _nRange ); |
| } |
| virtual void advance( sal_uInt32 _nValue ) |
| { |
| m_rDelegator.setObjectProgressValue( _nValue ); |
| } |
| virtual void end() |
| { |
| m_rDelegator.endObject(); |
| } |
| |
| private: |
| IMigrationProgress& m_rDelegator; |
| ::rtl::OUString m_sObjectName; |
| ::rtl::OUString m_sAction; |
| }; |
| |
| //==================================================================== |
| //= PhaseGuard |
| //==================================================================== |
| class PhaseGuard |
| { |
| public: |
| PhaseGuard( ProgressMixer& _rMixer ) |
| :m_rMixer( _rMixer ) |
| { |
| } |
| |
| PhaseGuard( ProgressMixer& _rMixer, const PhaseID _nID, const sal_uInt32 _nPhaseRange ) |
| :m_rMixer( _rMixer ) |
| { |
| start( _nID, _nPhaseRange ); |
| } |
| |
| ~PhaseGuard() |
| { |
| m_rMixer.endPhase(); |
| } |
| |
| void start( const PhaseID _nID, const sal_uInt32 _nPhaseRange ) |
| { |
| m_rMixer.startPhase( _nID, _nPhaseRange ); |
| } |
| |
| private: |
| ProgressMixer& m_rMixer; |
| }; |
| |
| //==================================================================== |
| //= MigrationEngine_Impl - declaration |
| //==================================================================== |
| class MigrationEngine_Impl |
| { |
| public: |
| MigrationEngine_Impl( |
| const ::comphelper::ComponentContext& _rContext, |
| const Reference< XOfficeDatabaseDocument >& _rxDocument, |
| IMigrationProgress& _rProgress, |
| MigrationLog& _rLogger |
| ); |
| ~MigrationEngine_Impl(); |
| |
| inline size_t getFormCount() const { return m_nFormCount; } |
| inline size_t getReportCount()const { return m_nReportCount; } |
| bool migrateAll(); |
| |
| private: |
| ::comphelper::ComponentContext m_aContext; |
| const Reference< XOfficeDatabaseDocument > m_xDocument; |
| const Reference< XModel > m_xDocumentModel; |
| IMigrationProgress& m_rProgress; |
| MigrationLog& m_rLogger; |
| mutable DocumentID m_nCurrentDocumentID; |
| SubDocuments m_aSubDocs; |
| size_t m_nFormCount; |
| size_t m_nReportCount; |
| |
| private: |
| /** collects a description of all sub documents of our database document |
| |
| @return |
| <TRUE/> if and only if collecting the documents was successful |
| */ |
| bool impl_collectSubDocuments_nothrow(); |
| |
| /** migrates the macros/scripts of the given sub document |
| */ |
| bool impl_handleDocument_nothrow( const SubDocument& _rDocument ) const; |
| |
| /** checks the structure of the 'Scripts' folder of a sub document |
| for unknown elements |
| |
| @return |
| <TRUE/> if and only if the 'Scripts' folder contains known elements only. |
| */ |
| bool impl_checkScriptStorageStructure_nothrow( const SubDocument& _rDocument ) const; |
| |
| /** migrates the scripts of the given "storage-based" script type |
| */ |
| bool impl_migrateScriptStorage_nothrow( |
| const SubDocument& _rDocument, |
| const ScriptType _eScriptType, |
| ProgressMixer& _rProgress, |
| const PhaseID _nPhaseID |
| ) const; |
| |
| /** migrates the content of the given "container based" libraries (Basic/Dialogs) |
| */ |
| bool impl_migrateContainerLibraries_nothrow( |
| const SubDocument& _rDocument, |
| const ScriptType _eScriptType, |
| ProgressMixer& _rProgress, |
| const PhaseID _nPhaseID |
| ) const; |
| |
| /** adjusts the events for the given dialog/element, taking into account the new names |
| of the moved libraries |
| */ |
| void impl_adjustDialogElementEvents_throw( |
| const Reference< XInterface >& _rxElement |
| ) const; |
| |
| /** adjusts the events in the given dialog, and its controls, taking into account the new names |
| of the moved libraries |
| */ |
| bool impl_adjustDialogEvents_nothrow( |
| Any& _inout_rDialogLibraryElement, |
| const ::rtl::OUString& _rDocName, |
| const ::rtl::OUString& _rDialogLibName, |
| const ::rtl::OUString& _rDialogName |
| ) const; |
| |
| /** adjust the document-events which refer to macros/scripts in the document, taking into |
| account the new names of the moved libraries |
| */ |
| bool impl_adjustDocumentEvents_nothrow( |
| const SubDocument& _rDocument |
| ) const; |
| |
| /** adjusts the script references bound to form component events |
| */ |
| bool impl_adjustFormComponentEvents_nothrow( |
| const SubDocument& _rDocument |
| ) const; |
| |
| /** adjusts the script references for the elements of the given form component container |
| */ |
| void impl_adjustFormComponentEvents_throw( |
| const Reference< XIndexAccess >& _rxComponentContainer |
| ) const; |
| |
| /** adjusts the library name in the given script URL, so that it reflects |
| the new name of the library |
| |
| @return <TRUE/> |
| if and only if adjustments to the script code have been made |
| */ |
| bool impl_adjustScriptLibrary_nothrow( |
| const ::rtl::OUString& _rScriptType, |
| ::rtl::OUString& _inout_rScriptCode |
| ) const; |
| |
| bool impl_adjustScriptLibrary_nothrow( Any& _inout_rScriptDescriptor ) const; |
| bool impl_adjustScriptLibrary_nothrow( ScriptEventDescriptor& _inout_rScriptEvent ) const; |
| |
| /** asks the user for a password for the given library, and unprotects the library |
| |
| @return <TRUE/> |
| if and only if the library could be successfully unprotected |
| */ |
| bool impl_unprotectPasswordLibrary_throw( |
| const Reference< XLibraryContainerPassword >& _rxPasswordManager, |
| const ScriptType _eScriptType, |
| const ::rtl::OUString& _rLibraryName |
| ) const; |
| }; |
| |
| //==================================================================== |
| //= MigrationEngine_Impl - implementation |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| MigrationEngine_Impl::MigrationEngine_Impl( const ::comphelper::ComponentContext& _rContext, |
| const Reference< XOfficeDatabaseDocument >& _rxDocument, IMigrationProgress& _rProgress, MigrationLog& _rLogger ) |
| :m_aContext( _rContext ) |
| ,m_xDocument( _rxDocument ) |
| ,m_xDocumentModel( _rxDocument, UNO_QUERY_THROW ) |
| ,m_rProgress( _rProgress ) |
| ,m_rLogger( _rLogger ) |
| ,m_nCurrentDocumentID( - 1 ) |
| ,m_aSubDocs() |
| ,m_nFormCount( 0 ) |
| ,m_nReportCount( 0 ) |
| { |
| OSL_VERIFY( impl_collectSubDocuments_nothrow() ); |
| } |
| |
| //-------------------------------------------------------------------- |
| MigrationEngine_Impl::~MigrationEngine_Impl() |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::migrateAll() |
| { |
| if ( m_aSubDocs.empty() ) |
| { |
| OSL_ENSURE( false, "MigrationEngine_Impl::migrateAll: no forms/reports found!" ); |
| // The whole migration wizard is not expected to be called when there are no forms/reports |
| // with macros, not to mention when there are no forms/reports at all. |
| return false; |
| } |
| |
| // initialize global progress |
| sal_Int32 nOverallRange( m_aSubDocs.size() ); |
| String sProgressSkeleton = String( MacroMigrationResId( STR_OVERALL_PROGRESS ) ); |
| sProgressSkeleton.SearchAndReplaceAscii( "$overall$", String::CreateFromInt32( nOverallRange ) ); |
| |
| m_rProgress.start( nOverallRange ); |
| |
| for ( SubDocuments::const_iterator doc = m_aSubDocs.begin(); |
| doc != m_aSubDocs.end(); |
| ++doc |
| ) |
| { |
| sal_Int32 nOverallProgressValue( doc - m_aSubDocs.begin() + 1 ); |
| // update overall progress text |
| ::rtl::OUString sOverallProgress( sProgressSkeleton ); |
| ::comphelper::string::searchAndReplaceAsciiI( sOverallProgress, "$current$", ::rtl::OUString::valueOf( nOverallProgressValue ) ); |
| m_rProgress.setOverallProgressText( sOverallProgress ); |
| |
| // migrate document |
| if ( !impl_handleDocument_nothrow( *doc ) ) |
| return false; |
| |
| // update overall progress vallue |
| m_rProgress.setOverallProgressValue( nOverallProgressValue ); |
| } |
| |
| // commit the root storage of the database document, for all changes made so far to take effect |
| if ( !lcl_commitDocumentStorage_nothrow( m_xDocumentModel, m_rLogger ) ) |
| return false; |
| |
| // save the document |
| if ( !lcl_storeDocument_nothrow( m_xDocumentModel, m_rLogger ) ) |
| return false; |
| |
| return true; |
| } |
| |
| //-------------------------------------------------------------------- |
| namespace |
| { |
| void lcl_collectHierarchicalElementNames_throw( |
| const Reference< XNameAccess >& _rxContainer, const ::rtl::OUString& _rContainerLoc, |
| SubDocuments& _out_rDocs, const SubDocumentType _eType, size_t& _io_counter ) |
| { |
| const ::rtl::OUString sHierarhicalBase( |
| _rContainerLoc.getLength() ? ::rtl::OUStringBuffer( _rContainerLoc ).appendAscii( "/" ).makeStringAndClear() |
| : ::rtl::OUString() ); |
| |
| Sequence< ::rtl::OUString > aElementNames( _rxContainer->getElementNames() ); |
| for ( const ::rtl::OUString* elementName = aElementNames.getConstArray(); |
| elementName != aElementNames.getConstArray() + aElementNames.getLength(); |
| ++elementName |
| ) |
| { |
| Any aElement( _rxContainer->getByName( *elementName ) ); |
| ::rtl::OUString sElementName( ::rtl::OUStringBuffer( sHierarhicalBase ).append( *elementName ) ); |
| |
| Reference< XNameAccess > xSubContainer( aElement, UNO_QUERY ); |
| if ( xSubContainer.is() ) |
| { |
| lcl_collectHierarchicalElementNames_throw( xSubContainer, sElementName, _out_rDocs, _eType, _io_counter ); |
| } |
| else |
| { |
| Reference< XCommandProcessor > xCommandProcessor( aElement, UNO_QUERY ); |
| OSL_ENSURE( xCommandProcessor.is(), "lcl_collectHierarchicalElementNames_throw: no container, and no comand processor? What *is* it, then?!" ); |
| if ( xCommandProcessor.is() ) |
| { |
| _out_rDocs.push_back( SubDocument( xCommandProcessor, sElementName, _eType, ++_io_counter ) ); |
| } |
| } |
| } |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_collectSubDocuments_nothrow() |
| { |
| OSL_PRECOND( m_xDocument.is(), "MigrationEngine_Impl::impl_collectSubDocuments_nothrow: invalid document!" ); |
| if ( !m_xDocument.is() ) |
| return false; |
| |
| try |
| { |
| Reference< XNameAccess > xDocContainer( m_xDocument->getFormDocuments(), UNO_SET_THROW ); |
| m_nFormCount = 0; |
| lcl_collectHierarchicalElementNames_throw( xDocContainer, ::rtl::OUString(), m_aSubDocs, eForm, m_nFormCount ); |
| |
| xDocContainer.set( m_xDocument->getReportDocuments(), UNO_SET_THROW ); |
| m_nReportCount = 0; |
| lcl_collectHierarchicalElementNames_throw( xDocContainer, ::rtl::OUString(), m_aSubDocs, eReport, m_nReportCount ); |
| } |
| catch( const Exception& ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_COLLECTING_DOCUMENTS_FAILED, |
| ::cppu::getCaughtException() |
| ) ); |
| return false; |
| } |
| return true; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_handleDocument_nothrow( const SubDocument& _rDocument ) const |
| { |
| OSL_ENSURE( m_nCurrentDocumentID == -1, |
| "MigrationEngine_Impl::impl_handleDocument_nothrow: there already is a current document!"); |
| m_nCurrentDocumentID = m_rLogger.startedDocument( _rDocument.eType, _rDocument.sHierarchicalName ); |
| |
| // start the progress |
| ::rtl::OUString sObjectName( lcl_getSubDocumentDescription( _rDocument ) ); |
| m_rProgress.startObject( sObjectName, ::rtl::OUString(), DEFAULT_DOC_PROGRESS_RANGE ); |
| |
| // ----------------- |
| // load the document |
| ::rtl::Reference< ProgressCapture > pStatusIndicator( new ProgressCapture( sObjectName, m_rProgress ) ); |
| SubDocument aSubDocument( _rDocument ); |
| OpenDocResult eResult = lcl_loadSubDocument_nothrow( aSubDocument, pStatusIndicator.get(), m_rLogger ); |
| if ( eResult != eOpenedDoc ) |
| { |
| pStatusIndicator->dispose(); |
| m_rProgress.endObject(); |
| m_rLogger.finishedDocument( m_nCurrentDocumentID ); |
| m_nCurrentDocumentID = -1; |
| return ( eResult == eIgnoreDoc ); |
| } |
| |
| // ----------------- |
| // migrate the libraries |
| ProgressDelegator aDelegator( m_rProgress, sObjectName, String( MacroMigrationResId( STR_MIGRATING_LIBS ) ) ); |
| ProgressMixer aProgressMixer( aDelegator ); |
| aProgressMixer.registerPhase( PHASE_JAVASCRIPT, 1 ); |
| aProgressMixer.registerPhase( PHASE_BEANSHELL, 1 ); |
| aProgressMixer.registerPhase( PHASE_PYTHON, 1 ); |
| aProgressMixer.registerPhase( PHASE_JAVA, 1 ); |
| aProgressMixer.registerPhase( PHASE_BASIC, 5 ); |
| // more weight than then others, assuming that usually, there are much more Basic macros than any other scripts |
| aProgressMixer.registerPhase( PHASE_DIALOGS, 1 ); |
| |
| bool bSuccess = impl_checkScriptStorageStructure_nothrow( aSubDocument ); |
| |
| // migrate storage-based script libraries (which can be handled by mere storage operations) |
| bSuccess = bSuccess |
| && impl_migrateScriptStorage_nothrow( aSubDocument, eJavaScript, aProgressMixer, PHASE_JAVASCRIPT ) |
| && impl_migrateScriptStorage_nothrow( aSubDocument, eBeanShell, aProgressMixer, PHASE_BEANSHELL ) |
| && impl_migrateScriptStorage_nothrow( aSubDocument, ePython, aProgressMixer, PHASE_PYTHON ) |
| && impl_migrateScriptStorage_nothrow( aSubDocument, eJava, aProgressMixer, PHASE_JAVA ); |
| |
| // migrate Basic and dialog libraries |
| bSuccess = bSuccess |
| && impl_migrateContainerLibraries_nothrow( aSubDocument, eBasic, aProgressMixer, PHASE_BASIC ) |
| && impl_migrateContainerLibraries_nothrow( aSubDocument, eDialog, aProgressMixer, PHASE_DIALOGS ); |
| // order matters: First Basic scripts, then dialogs. So we can adjust references from the latter |
| // to the former |
| |
| // adjust the events in the document |
| // (note that errors are ignored here - failure to convert a script reference |
| // is not considered a critical error) |
| if ( bSuccess ) |
| { |
| impl_adjustDocumentEvents_nothrow( aSubDocument ); |
| impl_adjustFormComponentEvents_nothrow( aSubDocument ); |
| } |
| |
| // ----------------- |
| // clean up |
| // store the sub document, including removal of the (now obsolete) "Scripts" sub folder |
| if ( m_rLogger.movedAnyLibrary( m_nCurrentDocumentID ) ) |
| { |
| bSuccess = bSuccess |
| && ScriptsStorage::removeFromDocument( aSubDocument.xDocument, m_rLogger ) |
| && lcl_commitDocumentStorage_nothrow( aSubDocument.xDocument, m_rLogger ) |
| && lcl_storeEmbeddedDocument_nothrow( aSubDocument ); |
| } |
| |
| // unload in any case, even if we were not successful |
| bSuccess = lcl_unloadSubDocument_nothrow( aSubDocument, m_rLogger ) |
| && bSuccess; |
| |
| pStatusIndicator->dispose(); |
| |
| // end the progress, just in case the ProgressCapture didn't receive the XStatusIndicator::end event |
| m_rProgress.endObject(); |
| |
| m_rLogger.finishedDocument( m_nCurrentDocumentID ); |
| m_nCurrentDocumentID = -1; |
| return bSuccess; |
| } |
| |
| //-------------------------------------------------------------------- |
| namespace |
| { |
| static ::rtl::OUString lcl_createTargetLibName( const SubDocument& _rDocument, |
| const ::rtl::OUString& _rSourceLibName, const Reference< XNameAccess >& _rxTargetContainer ) |
| { |
| // The new library name is composed from the prefix, the base name, and the old library name. |
| const ::rtl::OUString sPrefix( ::rtl::OUString::createFromAscii( _rDocument.eType == eForm ? "Form_" : "Report_" ) ); |
| |
| ::rtl::OUString sBaseName( _rDocument.sHierarchicalName.copy( |
| _rDocument.sHierarchicalName.lastIndexOf( '/' ) + 1 ) ); |
| // Normalize this name. In our current storage implementation (and script containers in a document |
| // are finally mapped to sub storages of the document storage), not all characters are allowed. |
| // The bug requesting to change this is #i95409#. |
| // Unfortunately, the storage implementation does not complain if you use invalid characters/names, but instead |
| // it silently accepts them, and produces garbage in the file (#i95408). |
| // So, until especially the former is fixed, we need to strip the name from all invalid characters. |
| // #i95865# / 2008-11-06 / frank.schoenheit@sun.com |
| |
| // The general idea is to replace invalid characters with '_'. However, since "valid" essentially means |
| // ASCII only, this implies that for a lot of languages, we would simply replace everything with '_', |
| // which of course is not desired. |
| // So, we use a heuristics: If the name contains at most 3 invalid characters, and as many valid as invalid |
| // characters, then we use the replacement. Otherwise, we just use a unambiguous number for the sub document. |
| sal_Int32 nValid=0, nInvalid=0; |
| const sal_Unicode* pBaseName = sBaseName.getStr(); |
| const sal_Int32 nBaseNameLen = sBaseName.getLength(); |
| for ( sal_Int32 i=0; i<nBaseNameLen; ++i ) |
| { |
| if ( ::comphelper::OStorageHelper::IsValidZipEntryFileName( pBaseName + i, 1, sal_False ) ) |
| ++nValid; |
| else |
| ++nInvalid; |
| } |
| if ( ( nInvalid <= 3 ) && ( nInvalid * 2 <= nValid ) ) |
| { // not "too many" invalid => replace them |
| ::rtl::OUStringBuffer aReplacement; |
| aReplacement.ensureCapacity( nBaseNameLen ); |
| aReplacement.append( sBaseName ); |
| const sal_Unicode* pReplacement = aReplacement.getStr(); |
| for ( sal_Int32 i=0; i<nBaseNameLen; ++i ) |
| { |
| if ( !::comphelper::OStorageHelper::IsValidZipEntryFileName( pReplacement + i, 1, sal_False ) ) |
| aReplacement.setCharAt( i, '_' ); |
| } |
| sBaseName = aReplacement.makeStringAndClear(); |
| |
| ::rtl::OUStringBuffer aNewLibNameAttempt; |
| aNewLibNameAttempt.append( sPrefix ); |
| aNewLibNameAttempt.append( sBaseName ); |
| aNewLibNameAttempt.appendAscii( "_" ); |
| aNewLibNameAttempt.append( _rSourceLibName ); |
| ::rtl::OUString sTargetName( aNewLibNameAttempt.makeStringAndClear() ); |
| if ( !_rxTargetContainer->hasByName( sTargetName ) ) |
| return sTargetName; |
| } |
| |
| // "too many" invalid characters, or the name composed with the base name was already used. |
| // (The latter is valid, since there can be multiple sub documents with the same base name, |
| // in different levels in the hierarchy.) |
| // In this case, just use the umambiguous sub document number. |
| ::rtl::OUStringBuffer aNewLibName; |
| aNewLibName.append( sPrefix ); |
| aNewLibName.append( ::rtl::OUString::valueOf( sal_Int64( _rDocument.nNumber ) ) ); |
| aNewLibName.appendAscii( "_" ); |
| aNewLibName.append( _rSourceLibName ); |
| return aNewLibName.makeStringAndClear(); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_checkScriptStorageStructure_nothrow( const SubDocument& _rDocument ) const |
| { |
| OSL_PRECOND( _rDocument.xDocument.is(), "MigrationEngine_Impl::impl_checkScriptStorageStructure_nothrow: invalid document!" ); |
| if ( !_rDocument.xDocument.is() ) |
| return false; |
| |
| try |
| { |
| // the root storage of the document whose scripts are to be migrated |
| ScriptsStorage aDocStorage( _rDocument.xDocument, m_rLogger ); |
| if ( !aDocStorage.isValid() ) |
| { // no scripts at all, or no scripts of the given type |
| return !m_rLogger.hadFailure(); |
| } |
| ::std::set< ::rtl::OUString > aElementNames( aDocStorage.getElementNames() ); |
| |
| ScriptType aKnownStorageBasedTypes[] = { |
| eBeanShell, eJavaScript, ePython, eJava |
| }; |
| for ( size_t i=0; i<sizeof( aKnownStorageBasedTypes ) / sizeof( aKnownStorageBasedTypes[0] ); ++i ) |
| aElementNames.erase( lcl_getScriptsSubStorageName( aKnownStorageBasedTypes[i] ) ); |
| |
| if ( !aElementNames.empty() ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_UNKNOWN_SCRIPT_FOLDER, |
| lcl_getSubDocumentDescription( _rDocument ), |
| *aElementNames.begin() |
| ) ); |
| return false; |
| } |
| } |
| catch( const Exception& ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_EXAMINING_SCRIPTS_FOLDER_FAILED, |
| lcl_getSubDocumentDescription( _rDocument ), |
| ::cppu::getCaughtException() |
| ) ); |
| return false; |
| } |
| return true; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_migrateScriptStorage_nothrow( const SubDocument& _rDocument, |
| const ScriptType _eScriptType, ProgressMixer& _rProgress, const PhaseID _nPhaseID ) const |
| { |
| OSL_PRECOND( _rDocument.xDocument.is(), "MigrationEngine_Impl::impl_migrateScriptStorage_nothrow: invalid document!" ); |
| if ( !_rDocument.xDocument.is() ) |
| return false; |
| |
| ScriptsStorage aDatabaseScripts( m_rLogger ); |
| // the scripts of our complete database document - created on demand only |
| SharedStorage xTargetStorage; |
| // the target for moving the scripts storages - created on demand only |
| |
| PhaseGuard aPhase( _rProgress ); |
| bool bSuccess = false; |
| Any aException; |
| try |
| { |
| // the root storage of the document whose scripts are to be migrated |
| ScriptsStorage aDocStorage( _rDocument.xDocument, m_rLogger ); |
| if ( !aDocStorage.isValid() |
| || !aDocStorage.hasScripts( _eScriptType ) |
| ) |
| { |
| // no scripts at all, or no scripts of the given type |
| _rProgress.startPhase( _nPhaseID, 1 ); |
| _rProgress.endPhase(); |
| return !m_rLogger.hadFailure(); |
| } |
| |
| SharedStorage xScriptsRoot( aDocStorage.getScriptsRoot( _eScriptType ) ); |
| if ( !xScriptsRoot.is() ) |
| throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "internal error" ) ), NULL ); |
| |
| // loop through the script libraries |
| Sequence< ::rtl::OUString > aStorageElements( xScriptsRoot->getElementNames() ); |
| aPhase.start( _nPhaseID, aStorageElements.getLength() ); |
| |
| for ( const ::rtl::OUString* element = aStorageElements.getConstArray(); |
| element != aStorageElements.getConstArray() + aStorageElements.getLength(); |
| ++element |
| ) |
| { |
| bool bIsScriptLibrary = xScriptsRoot->isStorageElement( *element ); |
| OSL_ENSURE( bIsScriptLibrary, |
| "MigrationEngine_Impl::impl_migrateScriptStorage_nothrow: warning: unknown scripts storage structure!" ); |
| // we cannot handle this. We would need to copy this stream to the respective scripts storage |
| // of the database document, but we cannot guarantee that the name is not used, yet, and we cannot |
| // simply rename the thing. |
| if ( !bIsScriptLibrary ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_UNEXPECTED_LIBSTORAGE_ELEMENT, |
| lcl_getSubDocumentDescription( _rDocument ), |
| getScriptTypeDisplayName( _eScriptType ), |
| *element |
| ) ); |
| return false; |
| } |
| |
| // ensure we have access to the DBDoc's scripts storage |
| if ( !aDatabaseScripts.isValid() ) |
| { // not needed 'til now |
| aDatabaseScripts.bind( m_xDocumentModel ); |
| if ( aDatabaseScripts.isValid() ) |
| xTargetStorage = aDatabaseScripts.getScriptsRoot( _eScriptType ); |
| |
| if ( !xTargetStorage.is() ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_CREATING_DBDOC_SCRIPT_STORAGE_FAILED, |
| getScriptTypeDisplayName( _eScriptType ) |
| ) ); |
| return false; |
| } |
| } |
| |
| // move the library to the DBDoc's scripts library, under the new name |
| ::rtl::OUString sNewLibName( lcl_createTargetLibName( _rDocument, *element, xTargetStorage.getTyped().get() ) ); |
| xScriptsRoot->moveElementTo( *element, xTargetStorage, sNewLibName ); |
| |
| // log the fact that we moved the library |
| m_rLogger.movedLibrary( m_nCurrentDocumentID, _eScriptType, *element, sNewLibName ); |
| |
| // progress |
| _rProgress.advancePhase( element - aStorageElements.getConstArray() ); |
| } |
| |
| // commit the storages, so the changes we made persist |
| if ( !lcl_commitStorage_nothrow( xScriptsRoot ) |
| || ( xTargetStorage.is() && !lcl_commitStorage_nothrow( xTargetStorage ) ) |
| ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_COMMITTING_SCRIPT_STORAGES_FAILED, |
| getScriptTypeDisplayName( _eScriptType ), |
| lcl_getSubDocumentDescription( _rDocument ) |
| ) ); |
| return false; |
| } |
| |
| // now that the concrete scripts storage does not have any elements anymore, |
| // remove it |
| xScriptsRoot.reset( NULL ); // need to reset the storage to be allowed to remove it |
| aDocStorage.removeScriptTypeStorage( _eScriptType ); |
| |
| // done so far |
| bSuccess = aDocStorage.commit() |
| && aDatabaseScripts.commit(); |
| } |
| catch( const Exception& ) |
| { |
| aException = ::cppu::getCaughtException(); |
| bSuccess = false; |
| } |
| |
| // log the error, if any |
| if ( !bSuccess ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_GENERAL_SCRIPT_MIGRATION_FAILURE, |
| getScriptTypeDisplayName( _eScriptType ), |
| lcl_getSubDocumentDescription( _rDocument ), |
| aException |
| ) ); |
| } |
| |
| return bSuccess; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_migrateContainerLibraries_nothrow( const SubDocument& _rDocument, |
| const ScriptType _eScriptType, ProgressMixer& _rProgress, const PhaseID _nPhaseID ) const |
| { |
| OSL_PRECOND( ( _eScriptType == eBasic ) || ( _eScriptType == eDialog ), |
| "MigrationEngine_Impl::impl_migrateContainerLibraries_nothrow: illegal script type!" ); |
| |
| bool bSuccess = false; |
| PhaseGuard aPhase( _rProgress ); |
| Any aException; |
| do // artificial loop for flow control only |
| { |
| try |
| { |
| // access library container of the sub document |
| Reference< XEmbeddedScripts > xSubDocScripts( _rDocument.xDocument, UNO_QUERY ); |
| if ( !xSubDocScripts.is() ) |
| { // no script support in the sub document -> nothing to migrate |
| // (though ... this is suspicious, at least ...) |
| bSuccess = true; |
| break; |
| } |
| |
| Reference< XStorageBasedLibraryContainer > xSourceLibraries( |
| _eScriptType == eBasic ? xSubDocScripts->getBasicLibraries() : xSubDocScripts->getDialogLibraries(), |
| UNO_QUERY_THROW |
| ); |
| Reference< XLibraryContainerPassword > xSourcePasswords( xSourceLibraries, UNO_QUERY ); |
| OSL_ENSURE( xSourcePasswords.is(), |
| "MigrationEngine_Impl::impl_migrateContainerLibraries_nothrow: suspicious: no password management for the source libraries!" ); |
| |
| Sequence< ::rtl::OUString > aSourceLibNames( xSourceLibraries->getElementNames() ); |
| aPhase.start( _nPhaseID, aSourceLibNames.getLength() ); |
| |
| if ( !xSourceLibraries->hasElements() ) |
| { |
| bSuccess = true; |
| break; |
| } |
| |
| // create library containers for the document - those will be the target for the migration |
| Reference< XStorageBasedDocument > xStorageDoc( m_xDocument, UNO_QUERY_THROW ); |
| Reference< XStorageBasedLibraryContainer > xTargetLibraries; |
| if ( _eScriptType == eBasic ) |
| { |
| xTargetLibraries.set( DocumentScriptLibraryContainer::create( |
| m_aContext.getUNOContext(), xStorageDoc ), UNO_QUERY_THROW ); |
| } |
| else |
| { |
| xTargetLibraries.set( DocumentDialogLibraryContainer::create( |
| m_aContext.getUNOContext(), xStorageDoc ), UNO_QUERY_THROW ); |
| } |
| |
| // copy all libs to the target, with potentially renaming them |
| const ::rtl::OUString* pSourceLibBegin = aSourceLibNames.getConstArray(); |
| const ::rtl::OUString* pSourceLibEnd = pSourceLibBegin + aSourceLibNames.getLength(); |
| for ( const ::rtl::OUString* pSourceLibName = pSourceLibBegin; |
| pSourceLibName != pSourceLibEnd; |
| ++pSourceLibName |
| ) |
| { |
| // if the library is password-protected, ask the user to unprotect it |
| if ( xSourcePasswords.is() |
| && xSourcePasswords->isLibraryPasswordProtected( *pSourceLibName ) |
| && !xSourcePasswords->isLibraryPasswordVerified( *pSourceLibName ) |
| ) |
| { |
| if ( !impl_unprotectPasswordLibrary_throw( xSourcePasswords, _eScriptType, *pSourceLibName ) ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_PASSWORD_VERIFICATION_FAILED, |
| _rDocument.sHierarchicalName, |
| getScriptTypeDisplayName( _eScriptType ), |
| *pSourceLibName |
| ) ); |
| return false; |
| } |
| } |
| |
| ::rtl::OUString sNewLibName( lcl_createTargetLibName( _rDocument, *pSourceLibName, xTargetLibraries.get() ) ); |
| |
| if ( xSourceLibraries->isLibraryLink( *pSourceLibName ) ) |
| { |
| // just re-create the link in the target library |
| xTargetLibraries->createLibraryLink( |
| sNewLibName, |
| xSourceLibraries->getLibraryLinkURL( *pSourceLibName ), |
| xSourceLibraries->isLibraryReadOnly( *pSourceLibName ) |
| ); |
| } |
| else |
| { |
| if ( !xSourceLibraries->isLibraryLoaded( *pSourceLibName ) ) |
| xSourceLibraries->loadLibrary( *pSourceLibName ); |
| |
| // copy the content of this particular libary |
| Reference< XNameAccess > xSourceLib( xSourceLibraries->getByName( *pSourceLibName ), UNO_QUERY_THROW ); |
| Reference< XNameContainer > xTargetLib( xTargetLibraries->createLibrary( sNewLibName ), UNO_QUERY_THROW ); |
| |
| Sequence< ::rtl::OUString > aLibElementNames( xSourceLib->getElementNames() ); |
| for ( const ::rtl::OUString* pSourceElementName = aLibElementNames.getConstArray(); |
| pSourceElementName != aLibElementNames.getConstArray() + aLibElementNames.getLength(); |
| ++pSourceElementName |
| ) |
| { |
| Any aElement = xSourceLib->getByName( *pSourceElementName ); |
| OSL_ENSURE( aElement.hasValue(), |
| "MigrationEngine_Impl::impl_migrateContainerLibraries_nothrow: invalid (empty) lib element!" ); |
| |
| // if this is a dialog, adjust the references to scripts |
| if ( _eScriptType == eDialog ) |
| { |
| impl_adjustDialogEvents_nothrow( aElement, lcl_getSubDocumentDescription( _rDocument ), |
| *pSourceLibName, *pSourceElementName ); |
| } |
| |
| xTargetLib->insertByName( *pSourceElementName, aElement ); |
| } |
| |
| // transfer the read-only flag |
| xTargetLibraries->setLibraryReadOnly( |
| sNewLibName, xSourceLibraries->isLibraryReadOnly( *pSourceLibName ) ); |
| } |
| |
| // remove the source lib |
| xSourceLibraries->removeLibrary( *pSourceLibName ); |
| |
| // tell the logger |
| m_rLogger.movedLibrary( m_nCurrentDocumentID, _eScriptType, *pSourceLibName, sNewLibName ); |
| |
| // tell the progress |
| _rProgress.advancePhase( pSourceLibName - pSourceLibBegin ); |
| } |
| |
| // clean up |
| xSourceLibraries->storeLibraries(); |
| |
| xTargetLibraries->storeLibraries(); |
| Reference< XStorage > xTargetRoot( xTargetLibraries->getRootLocation(), UNO_QUERY_THROW ); |
| bSuccess = lcl_commitStorage_nothrow( xTargetRoot ); |
| } |
| catch( const Exception& ) |
| { |
| aException = ::cppu::getCaughtException(); |
| bSuccess = false; |
| } |
| } while ( false ); |
| |
| // log the error, if any |
| if ( !bSuccess ) |
| { |
| m_rLogger.logFailure( MigrationError( |
| ERR_GENERAL_MACRO_MIGRATION_FAILURE, |
| lcl_getSubDocumentDescription( _rDocument ), |
| aException |
| ) ); |
| } |
| |
| return bSuccess; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow( const ::rtl::OUString& _rScriptType, |
| ::rtl::OUString& _inout_rScriptCode ) const |
| { |
| OSL_PRECOND( _inout_rScriptCode.getLength(), "MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow: invalid script!" ); |
| if ( !_inout_rScriptCode.getLength() ) |
| return false; |
| |
| bool bSuccess = false; |
| Any aException; |
| try |
| { |
| if ( !_rScriptType.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Script" ) ) |
| || !_rScriptType.getLength() |
| ) |
| { |
| OSL_ENSURE( false, |
| "MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow: no or unknown script type!" ); |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_UNKNOWN_SCRIPT_TYPE, |
| _rScriptType |
| ) ); |
| return false; |
| } |
| |
| // analyze the script URI |
| Reference< XUriReferenceFactory > xUriRefFac = UriReferenceFactory::create( m_aContext.getUNOContext() ); |
| Reference< XVndSunStarScriptUrlReference > xUri( xUriRefFac->parse( _inout_rScriptCode ), UNO_QUERY_THROW ); |
| |
| ::rtl::OUString sScriptLanguage = xUri->getParameter( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "language" ) ) ); |
| ScriptType eScriptType = eBasic; |
| if ( !lcl_getScriptTypeFromLanguage( sScriptLanguage, eScriptType ) ) |
| { |
| OSL_ENSURE( false, |
| "MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow: unknown script language!" ); |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_UNKNOWN_SCRIPT_LANGUAGE, |
| sScriptLanguage |
| ) ); |
| return false; |
| } |
| |
| ::rtl::OUString sLocation = xUri->getParameter( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "location" ) ) ); |
| if ( !sLocation.equalsAscii( "document" ) ) |
| { |
| // only document libraries must be migrated, of course |
| return false; |
| } |
| |
| ::rtl::OUString sScriptName = xUri->getName(); |
| sal_Int32 nLibModuleSeparator = sScriptName.indexOf( '.' ); |
| if ( nLibModuleSeparator < 0 ) |
| { |
| OSL_ENSURE( false, |
| "MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow: invalid/unknown location format!" ); |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_UNKNOWN_SCRIPT_NAME_FORMAT, |
| sScriptName |
| ) ); |
| return false; |
| } |
| |
| // replace the library name |
| ::rtl::OUString sLibrary = sScriptName.copy( 0, nLibModuleSeparator ); |
| ::rtl::OUString sNewLibName = m_rLogger.getNewLibraryName( |
| m_nCurrentDocumentID, eScriptType, sLibrary ); |
| OSL_ENSURE( sLibrary != sNewLibName, |
| "MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow: a library which has not been migrated?" ); |
| |
| ::rtl::OUStringBuffer aNewLocation; |
| aNewLocation.append( sNewLibName ); |
| aNewLocation.append( sScriptName.copy( nLibModuleSeparator ) ); |
| xUri->setName( aNewLocation.makeStringAndClear() ); |
| |
| // update the new script URL |
| _inout_rScriptCode = xUri->getUriReference(); |
| bSuccess = true; |
| } |
| catch( const Exception& ) |
| { |
| aException = ::cppu::getCaughtException(); |
| bSuccess = false; |
| } |
| |
| // log the failure, if any |
| if ( !bSuccess ) |
| { |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_SCRIPT_TRANSLATION_FAILURE, |
| _rScriptType, |
| _inout_rScriptCode, |
| aException |
| ) ); |
| } |
| |
| return bSuccess; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow( ScriptEventDescriptor& _inout_rScriptEvent ) const |
| { |
| if ( _inout_rScriptEvent.ScriptType.getLength() && _inout_rScriptEvent.ScriptCode.getLength() ) |
| return impl_adjustScriptLibrary_nothrow( _inout_rScriptEvent.ScriptType, _inout_rScriptEvent.ScriptCode ); |
| return false; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow( Any& _inout_rScriptDescriptor ) const |
| { |
| ::comphelper::NamedValueCollection aScriptDesc( _inout_rScriptDescriptor ); |
| |
| ::rtl::OUString sScriptType; |
| ::rtl::OUString sScript; |
| try |
| { |
| OSL_VERIFY( aScriptDesc.get_ensureType( "EventType", sScriptType ) ); |
| OSL_VERIFY( aScriptDesc.get_ensureType( "Script", sScript ) ); |
| } |
| catch( const Exception& ) |
| { |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_INVALID_SCRIPT_DESCRIPTOR_FORMAT, |
| ::cppu::getCaughtException() |
| ) ); |
| } |
| |
| if ( sScriptType.getLength() && sScript.getLength() ) |
| if ( !impl_adjustScriptLibrary_nothrow( sScriptType, sScript ) ) |
| return false; |
| |
| aScriptDesc.put( "Script", sScript ); |
| _inout_rScriptDescriptor <<= aScriptDesc.getPropertyValues(); |
| return true; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_adjustDocumentEvents_nothrow( const SubDocument& _rDocument ) const |
| { |
| try |
| { |
| Reference< XEventsSupplier > xSuppEvents( _rDocument.xDocument, UNO_QUERY ); |
| if ( !xSuppEvents.is() ) |
| // this is allowed. E.g. new-style reports currently do not support this |
| return true; |
| |
| Reference< XNameReplace > xEvents( xSuppEvents->getEvents(), UNO_SET_THROW ); |
| Sequence< ::rtl::OUString > aEventNames = xEvents->getElementNames(); |
| |
| Any aEvent; |
| for ( const ::rtl::OUString* eventName = aEventNames.getConstArray(); |
| eventName != aEventNames.getConstArray() + aEventNames.getLength(); |
| ++eventName |
| ) |
| { |
| aEvent = xEvents->getByName( *eventName ); |
| if ( !aEvent.hasValue() ) |
| continue; |
| |
| // translate |
| if ( !impl_adjustScriptLibrary_nothrow( aEvent ) ) |
| continue; |
| |
| // put back |
| xEvents->replaceByName( *eventName, aEvent ); |
| } |
| } |
| catch( const Exception& ) |
| { |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_ADJUSTING_DOCUMENT_EVENTS_FAILED, |
| lcl_getSubDocumentDescription( _rDocument ), |
| ::cppu::getCaughtException() |
| ) ); |
| return false; |
| } |
| return true; |
| } |
| |
| //-------------------------------------------------------------------- |
| void MigrationEngine_Impl::impl_adjustDialogElementEvents_throw( const Reference< XInterface >& _rxElement ) const |
| { |
| Reference< XScriptEventsSupplier > xEventsSupplier( _rxElement, UNO_QUERY_THROW ); |
| Reference< XNameReplace > xEvents( xEventsSupplier->getEvents(), UNO_QUERY_THROW ); |
| Sequence< ::rtl::OUString > aEventNames( xEvents->getElementNames() ); |
| |
| const ::rtl::OUString* eventName = aEventNames.getArray(); |
| const ::rtl::OUString* eventNamesEnd = eventName + aEventNames.getLength(); |
| |
| ScriptEventDescriptor aScriptEvent; |
| for ( ; eventName != eventNamesEnd; ++eventName ) |
| { |
| OSL_VERIFY( xEvents->getByName( *eventName ) >>= aScriptEvent ); |
| |
| if ( !impl_adjustScriptLibrary_nothrow( aScriptEvent ) ) |
| continue; |
| |
| xEvents->replaceByName( *eventName, makeAny( aScriptEvent ) ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_adjustDialogEvents_nothrow( Any& _inout_rDialogLibraryElement, |
| const ::rtl::OUString& _rDocName, const ::rtl::OUString& _rDialogLibName, const ::rtl::OUString& _rDialogName ) const |
| { |
| try |
| { |
| // load a dialog model from the stream describing it |
| Reference< XInputStreamProvider > xISP( _inout_rDialogLibraryElement, UNO_QUERY_THROW ); |
| Reference< XInputStream > xInput( xISP->createInputStream(), UNO_QUERY_THROW ); |
| |
| Reference< XNameContainer > xDialogModel( m_aContext.createComponent( "com.sun.star.awt.UnoControlDialogModel" ), UNO_QUERY_THROW ); |
| ::xmlscript::importDialogModel( xInput, xDialogModel, m_aContext.getUNOContext() ); |
| |
| // adjust the events of the dialog |
| impl_adjustDialogElementEvents_throw( xDialogModel ); |
| |
| // adjust the events of the controls |
| Sequence< ::rtl::OUString > aControlNames( xDialogModel->getElementNames() ); |
| const ::rtl::OUString* controlName = aControlNames.getConstArray(); |
| const ::rtl::OUString* controlNamesEnd = controlName + aControlNames.getLength(); |
| for ( ; controlName != controlNamesEnd; ++controlName ) |
| { |
| impl_adjustDialogElementEvents_throw( Reference< XInterface >( xDialogModel->getByName( *controlName ), UNO_QUERY ) ); |
| } |
| |
| // export dialog model |
| xISP = ::xmlscript::exportDialogModel( xDialogModel, m_aContext.getUNOContext() ); |
| _inout_rDialogLibraryElement <<= xISP; |
| } |
| catch( const Exception& ) |
| { |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_ADJUSTING_DIALOG_EVENTS_FAILED, |
| _rDocName, |
| _rDialogLibName, |
| _rDialogName, |
| ::cppu::getCaughtException() |
| ) ); |
| return false; |
| } |
| return true; |
| } |
| |
| //-------------------------------------------------------------------- |
| void MigrationEngine_Impl::impl_adjustFormComponentEvents_throw( const Reference< XIndexAccess >& _rxComponentContainer ) const |
| { |
| FormComponentIterator aCompIter( _rxComponentContainer ); |
| while ( aCompIter.hasMore() ) |
| { |
| // 1. adjust the component's scripts of the current component |
| FormComponentScripts aComponent( aCompIter.next() ); |
| Sequence< ScriptEventDescriptor > aEvents( aComponent.getEvents() ); |
| |
| bool bChangedComponentEvents = false; |
| for ( ScriptEventDescriptor* scriptEvent = aEvents.getArray(); |
| scriptEvent != aEvents.getArray() + aEvents.getLength(); |
| ++scriptEvent |
| ) |
| { |
| if ( !impl_adjustScriptLibrary_nothrow( *scriptEvent ) ) |
| continue; |
| |
| bChangedComponentEvents = true; |
| } |
| |
| if ( bChangedComponentEvents ) |
| aComponent.setEvents( aEvents ); |
| |
| // 2. step down if the component is a container itself |
| Reference< XIndexAccess > xContainer( aComponent.getComponent(), UNO_QUERY ); |
| if ( xContainer.is() ) |
| impl_adjustFormComponentEvents_throw( xContainer ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_adjustFormComponentEvents_nothrow( const SubDocument& _rDocument ) const |
| { |
| try |
| { |
| DrawPageIterator aPageIter( _rDocument.xDocument ); |
| while ( aPageIter.hasMore() ) |
| { |
| Reference< XFormsSupplier > xSuppForms( aPageIter.next(), UNO_QUERY_THROW ); |
| Reference< XIndexAccess > xForms( xSuppForms->getForms(), UNO_QUERY_THROW ); |
| impl_adjustFormComponentEvents_throw( xForms ); |
| } |
| } |
| catch( const Exception& ) |
| { |
| m_rLogger.logRecoverable( MigrationError( |
| ERR_ADJUSTING_FORMCOMP_EVENTS_FAILED, |
| lcl_getSubDocumentDescription( _rDocument ), |
| ::cppu::getCaughtException() |
| ) ); |
| return false; |
| } |
| return true; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine_Impl::impl_unprotectPasswordLibrary_throw( const Reference< XLibraryContainerPassword >& _rxPasswordManager, |
| const ScriptType _eScriptType, const ::rtl::OUString& _rLibraryName ) const |
| { |
| // a human-readable description of the affected library |
| ::rtl::OUString sLibraryDescription( String( |
| MacroMigrationResId( STR_LIBRARY_TYPE_AND_NAME ) ) ); |
| ::comphelper::string::searchAndReplaceAsciiI( sLibraryDescription, "$type$", |
| getScriptTypeDisplayName( _eScriptType ) ); |
| ::comphelper::string::searchAndReplaceAsciiI( sLibraryDescription, "$library$", |
| _rLibraryName ); |
| |
| InteractionHandler aHandler( m_aContext, m_xDocumentModel ); |
| ::rtl::OUString sPassword; |
| while ( true ) |
| { |
| if ( !aHandler.requestDocumentPassword( sLibraryDescription, sPassword ) ) |
| // aborted by the user |
| return false; |
| |
| bool bSuccessVerification = _rxPasswordManager->verifyLibraryPassword( _rLibraryName, sPassword ); |
| if ( bSuccessVerification ) |
| return true; |
| } |
| |
| } |
| |
| //==================================================================== |
| //= MigrationEngine |
| //==================================================================== |
| //-------------------------------------------------------------------- |
| MigrationEngine::MigrationEngine( const ::comphelper::ComponentContext& _rContext, |
| const Reference< XOfficeDatabaseDocument >& _rxDocument, IMigrationProgress& _rProgress, |
| MigrationLog& _rLogger ) |
| :m_pImpl( new MigrationEngine_Impl( _rContext, _rxDocument, _rProgress, _rLogger ) ) |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| MigrationEngine::~MigrationEngine() |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_Int32 MigrationEngine::getFormCount() const |
| { |
| return m_pImpl->getFormCount(); |
| } |
| |
| //-------------------------------------------------------------------- |
| sal_Int32 MigrationEngine::getReportCount() const |
| { |
| return m_pImpl->getReportCount(); |
| } |
| |
| //-------------------------------------------------------------------- |
| bool MigrationEngine::migrateAll() |
| { |
| return m_pImpl->migrateAll(); |
| } |
| |
| //........................................................................ |
| } // namespace dbmm |
| //........................................................................ |
