CWS-TOOLING: integrate CWS odbmacros3

1 files changed, 1465 insertions, 88 deletions

diff --git a/dbaccess/source/ext/macromigration/migrationengine.cxx b/dbaccess/source/ext/macromigration/migrationengine.cxx
index efd8c86bfdd4..bf147de0b1e4 100644
--- a/dbaccess/source/ext/macromigration/migrationengine.cxx
+++ b/dbaccess/source/ext/macromigration/migrationengine.cxx
@@ -7,7 +7,7 @@
  * OpenOffice.org - a multi-platform office productivity suite
  *
  * $RCSfile: migrationengine.cxx,v $
- * $Revision: 1.4 $
+ * $Revision: 1.4.2.14 $
  *
  * This file is part of OpenOffice.org.
  *
@@ -34,11 +34,13 @@
 #include "dbmm_global.hrc"
 #include "dbmm_module.hxx"
 #include "dbmm_types.hxx"
-#include "docerrorhandling.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>
@@ -48,16 +50,38 @@
 #include <com/sun/star/frame/XComponentLoader.hpp>
 #include <com/sun/star/ucb/XCommandProcessor.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>
 /** === end UNO includes === **/
 
-#include <comphelper/string.hxx>
+#include <comphelper/documentinfo.hxx>
+#include <comphelper/interaction.hxx>
 #include <comphelper/namedvaluecollection.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 <vector>
+#include <set>
 
 #define DEFAULT_DOC_PROGRESS_RANGE  100000
 
@@ -90,19 +114,54 @@ namespace dbmm
     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;
     /** === 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;
-        ::rtl::OUString                   sHierarchicalName;
-        SubDocumentType                   eType;
+        Reference< XCommandProcessor >  xCommandProcessor;
+        Reference< XModel >             xDocument;          // valid only temporarily
+        ::rtl::OUString                 sHierarchicalName;
+        SubDocumentType                 eType;
 
         SubDocument( const Reference< XCommandProcessor >& _rxCommandProcessor, const ::rtl::OUString& _rName, const SubDocumentType _eType )
             :xCommandProcessor( _rxCommandProcessor )
+            ,xDocument()
             ,sHierarchicalName( _rName )
             ,eType( _eType )
         {
@@ -112,6 +171,644 @@ namespace dbmm
     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 );
+        }
+
+        //----------------------------------------------------------------
+        static bool 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& )
+            {
+                _rLogger.logFailure( MigrationError(
+                    ERR_OPENING_SUB_DOCUMENT_FAILED,
+                    lcl_getSubDocumentDescription( _rDocument ),
+                    ::cppu::getCaughtException()
+                ) );
+            }
+            return _rDocument.xDocument.is();
+        }
+
+        //----------------------------------------------------------------
+        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
@@ -132,8 +829,10 @@ namespace dbmm
     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;
@@ -146,14 +845,79 @@ namespace dbmm
         */
         bool    impl_collectSubDocuments_nothrow();
 
-        /** reports the given error (usually an exception caught on the caller's side)
-            to the user, using the document's interaction handler, if any.
-        */
-        void    impl_reportError_nothrow( const Any& _rError ) const;
-
         /** 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;
+
+        /** 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;
     };
 
     //====================================================================
@@ -164,8 +928,10 @@ namespace dbmm
             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 )
@@ -215,6 +981,14 @@ namespace dbmm
             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;
     }
 
@@ -263,141 +1037,744 @@ namespace dbmm
     //--------------------------------------------------------------------
     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
         {
-            ::rtl::OUString sRootLocation;
-
-            Reference< XFormDocumentsSupplier > xSuppForms( m_xDocument, UNO_QUERY_THROW );
-            Reference< XNameAccess > xDocContainer( xSuppForms->getFormDocuments(), UNO_SET_THROW );
-            m_nFormCount = lcl_collectHierarchicalElementNames_throw( xDocContainer, sRootLocation, m_aSubDocs, eForm );
+            Reference< XNameAccess > xDocContainer( m_xDocument->getFormDocuments(), UNO_SET_THROW );
+            m_nFormCount = lcl_collectHierarchicalElementNames_throw( xDocContainer, ::rtl::OUString(), m_aSubDocs, eForm );
 
-            Reference< XReportDocumentsSupplier > xSuppReports( m_xDocument, UNO_QUERY_THROW );
-            xDocContainer.set( xSuppReports->getReportDocuments(), UNO_SET_THROW );
-            m_nReportCount = lcl_collectHierarchicalElementNames_throw( xDocContainer, sRootLocation, m_aSubDocs, eReport );
+            xDocContainer.set( m_xDocument->getReportDocuments(), UNO_SET_THROW );
+            m_nReportCount = lcl_collectHierarchicalElementNames_throw( xDocContainer, ::rtl::OUString(), m_aSubDocs, eReport );
         }
         catch( const Exception& )
         {
-            // TODO: check whether we can handle this error
-            DBG_UNHANDLED_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 );
+        if ( !lcl_loadSubDocument_nothrow( aSubDocument, pStatusIndicator.get(), m_rLogger ) )
+        {
+            pStatusIndicator->dispose();
+            m_rProgress.endObject();
+            m_rLogger.finishedDocument( m_nCurrentDocumentID );
+            m_nCurrentDocumentID = -1;
+            return false;
+        }
+
+        // -----------------
+        // 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 );
+
+        // 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
+        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 void lcl_disposeComponent_nothrow( const Reference< XCommandProcessor >& _rxCommandProc )
+        static ::rtl::OUString lcl_createTargetLibName( const SubDocument& _rDocument,
+            const ::rtl::OUString& _rSourceLibName, const Reference< XNameAccess >& _rxTargetStorage )
         {
-            OSL_PRECOND( _rxCommandProc.is(), "lcl_disposeComponent_nothrow: illegal object!" );
-            if ( !_rxCommandProc.is() )
-                return;
+            // a prefix denoting the type
+            const ::rtl::OUString sPrefix( ::rtl::OUString::createFromAscii( _rDocument.eType == eForm ? "Form_" : "Report_" ) );
 
-            bool bCouldClose = false;
-            try
+            ::rtl::OUStringBuffer aBuffer;
+            aBuffer.append( sPrefix );
+
+            // first try with the base name of the sub document
+            aBuffer.append( _rDocument.sHierarchicalName.copy(
+                _rDocument.sHierarchicalName.lastIndexOf( '/' ) + 1 ) );
+            aBuffer.appendAscii( "_" );
+            aBuffer.append( _rSourceLibName );
+            ::rtl::OUString sTargetName( aBuffer.makeStringAndClear() );
+            if ( !_rxTargetStorage->hasByName( sTargetName ) )
+                return sTargetName;
+
+            // if this name is already used (which is valid, since documents with the same base
+            // name can exist in different logical folders), then use the complete name
+            aBuffer.append( sPrefix );
+            aBuffer.append( ::comphelper::string::searchAndReplaceAllAsciiWithAscii(
+                _rDocument.sHierarchicalName, "/", "_" ) );
+            aBuffer.appendAscii( "_" );
+            aBuffer.append( _rSourceLibName );
+            return aBuffer.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() )
             {
-                Command aCommand;
-                aCommand.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "shutdown" ) );
-                OSL_VERIFY( _rxCommandProc->execute(
-                    aCommand, _rxCommandProc->createCommandIdentifier(), NULL ) >>= bCouldClose );
+                m_rLogger.logFailure( MigrationError(
+                    ERR_UNKNOWN_SCRIPT_FOLDER,
+                    lcl_getSubDocumentDescription( _rDocument ),
+                    *aElementNames.begin()
+                ) );
+                return false;
             }
-            catch( const Exception& )
+        }
+        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 )
+                )
             {
-                DBG_UNHANDLED_EXCEPTION();
+                // no scripts at all, or no scripts of the given type
+                _rProgress.startPhase( _nPhaseID, 1 );
+                _rProgress.endPhase();
+                return !m_rLogger.hadFailure();
             }
-            if ( !bCouldClose )
+
+            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
+                )
             {
-                ;
-                // TODO: can we handle this somehow?
+                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,
+                    lcl_getSubDocumentDescription( _rDocument ),
+                    getScriptTypeDisplayName( _eScriptType )
+                ) );
+                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;
         }
 
-        //................................................................
-        static Reference< XModel > lcl_loadSubDocument_nothrow( const SubDocument& _rDocument,
-            const Reference< XStatusIndicator >& _rxProgress )
+        // log the error, if any
+        if ( !bSuccess )
         {
-            Reference< XModel > xDocument;
+            m_rLogger.logFailure( MigrationError(
+                ERR_GENERAL_SCRIPT_MIGRATION_FAILURE,
+                lcl_getSubDocumentDescription( _rDocument ),
+                getScriptTypeDisplayName( _eScriptType ),
+                aException
+            ) );
+        }
 
-            try
+        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() )
             {
-                ::comphelper::NamedValueCollection aLoadArgs;
-                aLoadArgs.put( "Hidden", (sal_Bool)sal_True );
-                aLoadArgs.put( "StatusIndicator", _rxProgress );
+                bSuccess = true;
+                break;
+            }
 
-                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!" );
+            // 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!" );
+                        xTargetLib->insertByName( *pSourceElementName, aElement );
+                    }
+
+                    // transfer the read-only flag
+                    xTargetLibraries->setLibraryReadOnly(
+                        sNewLibName, xSourceLibraries->isLibraryReadOnly( *pSourceLibName ) );
+                }
 
-                xDocument.set( xDocComponent, UNO_QUERY_THROW );
+                // 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 );
             }
-            catch( const Exception& )
+
+            // 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()
+                )
             {
-                // TODO: how to proceed?
-                DBG_UNHANDLED_EXCEPTION();
+                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;
             }
 
-            return xDocument;
+            // 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_handleDocument_nothrow( const SubDocument& _rDocument ) const
+    bool MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow( ScriptEventDescriptor& _inout_rScriptEvent ) const
     {
-        DocumentID nDocID = m_rLogger.startedDocument( _rDocument.eType, _rDocument.sHierarchicalName );
+        if ( _inout_rScriptEvent.ScriptType.getLength() && _inout_rScriptEvent.ScriptCode.getLength() )
+            return impl_adjustScriptLibrary_nothrow( _inout_rScriptEvent.ScriptType, _inout_rScriptEvent.ScriptCode );
+        return false;
+    }
 
-        // start the progress
-        ::rtl::OUString aProgress;
-        aProgress = String( MacroMigrationResId( _rDocument.eType == eForm ? STR_FORM : STR_REPORT ) );
-        ::comphelper::string::searchAndReplaceAsciiI( aProgress, "$name$", _rDocument.sHierarchicalName );
-        m_rProgress.startObject( aProgress, ::rtl::OUString(), DEFAULT_DOC_PROGRESS_RANGE );
+    //--------------------------------------------------------------------
+    bool MigrationEngine_Impl::impl_adjustScriptLibrary_nothrow( Any& _inout_rScriptDescriptor ) const
+    {
+        ::comphelper::NamedValueCollection aScriptDesc( _inout_rScriptDescriptor );
 
-        // load the document
-        ::rtl::Reference< ProgressCapture > pStatusIndicator( new ProgressCapture( aProgress, m_rProgress ) );
-        Reference< XModel > xDocument( lcl_loadSubDocument_nothrow( _rDocument, pStatusIndicator.get() ) );
-        if ( !xDocument.is() )
+        ::rtl::OUString sScriptType;
+        ::rtl::OUString sScript;
+        try
         {
-            pStatusIndicator->dispose();
-            m_rProgress.endObject();
-            m_rLogger.finishedDocument( nDocID, false );
-                // TODO: log the *reason* for the failure
+            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;
+    }
 
-        // TODO
+    //--------------------------------------------------------------------
+    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() );
 
-        // clean up
-        lcl_disposeComponent_nothrow( _rDocument.xCommandProcessor );
-        pStatusIndicator->dispose();
+            bool bChangedComponentEvents = false;
+            for (   ScriptEventDescriptor* scriptEvent = aEvents.getArray();
+                    scriptEvent != aEvents.getArray() + aEvents.getLength();
+                    ++scriptEvent
+                )
+            {
+                if ( !impl_adjustScriptLibrary_nothrow( *scriptEvent ) )
+                    continue;
 
-        // end the progress, just in case the ProgressCapture didn't receive the XStatusIndicator::end event
-        m_rProgress.endObject();
+                bChangedComponentEvents = true;
+            }
+
+            if ( bChangedComponentEvents )
+                aComponent.setEvents( aEvents );
 
-        m_rLogger.finishedDocument( nDocID, true );
+            // 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;
     }
 
     //--------------------------------------------------------------------
-    void MigrationEngine_Impl::impl_reportError_nothrow( const Any& _rError ) const
+    bool MigrationEngine_Impl::impl_unprotectPasswordLibrary_throw( const Reference< XLibraryContainerPassword >& _rxPasswordManager,
+            const ScriptType _eScriptType, const ::rtl::OUString& _rLibraryName ) const
     {
-        DocumentErrorHandling::reportError( m_aContext, m_xDocument, _rError );
+        // 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;
+        }
+
+        return false;
     }
 
     //====================================================================
     //= MigrationEngine
     //====================================================================
     //--------------------------------------------------------------------
-    MigrationEngine::MigrationEngine( const ::comphelper::ComponentContext& _rContext, const Reference< XOfficeDatabaseDocument >& _rxDocument,
-            IMigrationProgress& _rProgress, MigrationLog& _rLogger )
+    MigrationEngine::MigrationEngine( const ::comphelper::ComponentContext& _rContext,
+            const Reference< XOfficeDatabaseDocument >& _rxDocument, IMigrationProgress& _rProgress,
+            MigrationLog& _rLogger )
         :m_pImpl( new MigrationEngine_Impl( _rContext, _rxDocument, _rProgress, _rLogger ) )
     {
     }