dbaccess/source/core/dataaccess/ModelImpl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "commandcontainer.hxx"
  21 #include "connection.hxx"
  22 #include "core_resource.hrc"
  23 #include "core_resource.hxx"
  24 #include "databasecontext.hxx"
  25 #include "databasedocument.hxx"
  26 #include "datasource.hxx"
  27 #include "dbastrings.hrc"
  28 #include "ModelImpl.hxx"
  29 #include "userinformation.hxx"
  30 #include "sdbcoretools.hxx"
  31
  32 #include <com/sun/star/beans/PropertyBag.hpp>
  33 #include <com/sun/star/container/XSet.hpp>
  34 #include <com/sun/star/document/MacroExecMode.hpp>
  35 #include <com/sun/star/embed/XTransactedObject.hpp>
  36 #include <com/sun/star/embed/XTransactionBroadcaster.hpp>
  37 #include <com/sun/star/embed/StorageFactory.hpp>
  38 #include <com/sun/star/form/XLoadable.hpp>
  39 #include <com/sun/star/frame/theGlobalEventBroadcaster.hpp>
  40 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  41 #include <com/sun/star/sdb/BooleanComparisonMode.hpp>
  42 #include <com/sun/star/script/DocumentScriptLibraryContainer.hpp>
  43 #include <com/sun/star/script/DocumentDialogLibraryContainer.hpp>
  44 #include <com/sun/star/util/NumberFormatsSupplier.hpp>
  45
  46 #include <comphelper/interaction.hxx>
  47 #include <comphelper/seqstream.hxx>
  48 #include <comphelper/sequence.hxx>
  49 #include <connectivity/dbexception.hxx>
  50 #include <cppuhelper/exc_hlp.hxx>
  51 #include <cppuhelper/implbase.hxx>
  52 #include <cppuhelper/typeprovider.hxx>
  53 #include <rtl/digest.h>
  54 #include <sfx2/signaturestate.hxx>
  55 #include <tools/debug.hxx>
  56 #include <tools/diagnose_ex.h>
  57 #include <osl/diagnose.h>
  58 #include <sal/log.hxx>
  59 #include <tools/errcode.hxx>
  60 #include <tools/urlobj.hxx>
  61 #include <unotools/sharedunocomponent.hxx>
  62
  63 #include <algorithm>
  64
  65 using namespace ::com::sun::star::document;
  66 using namespace ::com::sun::star::sdbc;
  67 using namespace ::com::sun::star::sdbcx;
  68 using namespace ::com::sun::star::sdb;
  69 using namespace ::com::sun::star::beans;
  70 using namespace ::com::sun::star::uno;
  71 using namespace ::com::sun::star::lang;
  72 using namespace ::com::sun::star::embed;
  73 using namespace ::com::sun::star::container;
  74 using namespace ::com::sun::star::util;
  75 using namespace ::com::sun::star::io;
  76 using namespace ::com::sun::star::ucb;
  77 using namespace ::com::sun::star::frame;
  78 using namespace ::com::sun::star::view;
  79 using namespace ::com::sun::star::task;
  80 using namespace ::com::sun::star::reflection;
  81 using namespace ::com::sun::star::script;
  82 using namespace ::cppu;
  83 using namespace ::osl;
  84 using namespace ::dbtools;
  85 using namespace ::comphelper;
  86
  87 namespace dbaccess
  88 {
  89
  90 // VosMutexFacade
  91 VosMutexFacade::VosMutexFacade( ::osl::Mutex& _rMutex )
  92     :m_rMutex( _rMutex )
  93 {
  94 }
  95
  96 void VosMutexFacade::acquire()
  97 {
  98     m_rMutex.acquire();
  99 }
 100
 101 void VosMutexFacade::release()
 102 {
 103     m_rMutex.release();
 104 }
 105
 106 bool VosMutexFacade::tryToAcquire()
 107 {
 108     return m_rMutex.tryToAcquire();
 109 }
 110
 111 // DocumentStorageAccess
 112 class DocumentStorageAccess : public ::cppu::WeakImplHelper<   XDocumentSubStorageSupplier
 113                                                            ,   XTransactionListener >
 114 {
 115     typedef ::std::map< OUString, Reference< XStorage > >    NamedStorages;
 116
 117     ::osl::Mutex        m_aMutex;
 118     /// all sub storages which we ever gave to the outer world
 119     NamedStorages       m_aExposedStorages;
 120     ODatabaseModelImpl* m_pModelImplementation;
 121     bool                m_bPropagateCommitToRoot;
 122     bool                m_bDisposingSubStorages;
 123
 124 public:
 125     explicit DocumentStorageAccess( ODatabaseModelImpl& _rModelImplementation )
 126         :m_pModelImplementation( &_rModelImplementation )
 127         ,m_bPropagateCommitToRoot( true )
 128         ,m_bDisposingSubStorages( false )
 129     {
 130     }
 131
 132 protected:
 133     virtual ~DocumentStorageAccess() override
 134     {
 135     }
 136
 137 public:
 138     void dispose();
 139
 140     // XDocumentSubStorageSupplier
 141     virtual Reference< XStorage > SAL_CALL getDocumentSubStorage( const OUString& aStorageName, ::sal_Int32 _nMode ) throw (RuntimeException, std::exception) override;
 142     virtual Sequence< OUString > SAL_CALL getDocumentSubStoragesNames(  ) throw (IOException, RuntimeException, std::exception) override;
 143
 144     // XTransactionListener
 145     virtual void SAL_CALL preCommit( const css::lang::EventObject& aEvent ) throw (css::uno::Exception, css::uno::RuntimeException, std::exception) override;
 146     virtual void SAL_CALL commited( const css::lang::EventObject& aEvent ) throw (css::uno::RuntimeException, std::exception) override;
 147     virtual void SAL_CALL preRevert( const css::lang::EventObject& aEvent ) throw (css::uno::Exception, css::uno::RuntimeException, std::exception) override;
 148     virtual void SAL_CALL reverted( const css::lang::EventObject& aEvent ) throw (css::uno::RuntimeException, std::exception) override;
 149
 150     // XEventListener
 151     virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) throw (css::uno::RuntimeException, std::exception) override;
 152
 153     /// disposes all storages managed by this instance
 154     void disposeStorages();
 155
 156     /// disposes all known sub storages
 157     void commitStorages();
 158
 159     /// commits the dedicated "database" storage
 160     bool commitEmbeddedStorage( bool _bPreventRootCommits );
 161
 162 private:
 163     /** opens the sub storage with the given name, in the given mode
 164     */
 165     Reference< XStorage > impl_openSubStorage_nothrow( const OUString& _rStorageName, sal_Int32 _nMode );
 166
 167     void impl_suspendCommitPropagation()
 168     {
 169         OSL_ENSURE( m_bPropagateCommitToRoot, "DocumentStorageAccess::impl_suspendCommitPropagation: already suspended" );
 170         m_bPropagateCommitToRoot = false;
 171     }
 172     void impl_resumeCommitPropagation()
 173     {
 174         OSL_ENSURE( !m_bPropagateCommitToRoot, "DocumentStorageAccess::impl_resumeCommitPropagation: not suspended" );
 175         m_bPropagateCommitToRoot = true;
 176     }
 177
 178 };
 179
 180 void DocumentStorageAccess::dispose()
 181 {
 182     ::osl::MutexGuard aGuard( m_aMutex );
 183
 184     for (   NamedStorages::const_iterator loop = m_aExposedStorages.begin();
 185             loop != m_aExposedStorages.end();
 186             ++loop
 187         )
 188     {
 189         try
 190         {
 191             Reference< XTransactionBroadcaster > xBroadcaster( loop->second, UNO_QUERY );
 192             if ( xBroadcaster.is() )
 193                 xBroadcaster->removeTransactionListener( this );
 194         }
 195         catch( const Exception& )
 196         {
 197             DBG_UNHANDLED_EXCEPTION();
 198         }
 199     }
 200
 201     m_aExposedStorages.clear();
 202
 203     m_pModelImplementation = nullptr;
 204 }
 205
 206 Reference< XStorage > DocumentStorageAccess::impl_openSubStorage_nothrow( const OUString& _rStorageName, sal_Int32 _nDesiredMode )
 207 {
 208     OSL_ENSURE( !_rStorageName.isEmpty(),"ODatabaseModelImpl::impl_openSubStorage_nothrow: Invalid storage name!" );
 209
 210     Reference< XStorage > xStorage;
 211     try
 212     {
 213         Reference< XStorage > xRootStorage( m_pModelImplementation->getOrCreateRootStorage() );
 214         if ( xRootStorage.is() )
 215         {
 216             sal_Int32 nRealMode = m_pModelImplementation->m_bDocumentReadOnly ? ElementModes::READ : _nDesiredMode;
 217             if ( nRealMode == ElementModes::READ )
 218             {
 219                 if ( xRootStorage.is() && !xRootStorage->hasByName( _rStorageName ) )
 220                     return xStorage;
 221             }
 222
 223             xStorage = xRootStorage->openStorageElement( _rStorageName, nRealMode );
 224
 225             Reference< XTransactionBroadcaster > xBroad( xStorage, UNO_QUERY );
 226             if ( xBroad.is() )
 227                 xBroad->addTransactionListener( this );
 228         }
 229     }
 230     catch( const Exception& )
 231     {
 232         DBG_UNHANDLED_EXCEPTION();
 233     }
 234
 235     return xStorage;
 236 }
 237
 238 void DocumentStorageAccess::disposeStorages()
 239 {
 240     m_bDisposingSubStorages = true;
 241
 242     NamedStorages::const_iterator aEnd = m_aExposedStorages.end();
 243     for (   NamedStorages::iterator aIter = m_aExposedStorages.begin();
 244             aIter != aEnd ;
 245             ++aIter
 246         )
 247     {
 248         try
 249         {
 250             ::comphelper::disposeComponent( aIter->second );
 251         }
 252         catch( const Exception& )
 253         {
 254             DBG_UNHANDLED_EXCEPTION();
 255         }
 256     }
 257     m_aExposedStorages.clear();
 258
 259     m_bDisposingSubStorages = false;
 260 }
 261
 262 void DocumentStorageAccess::commitStorages()
 263 {
 264     try
 265     {
 266         for (   NamedStorages::const_iterator aIter = m_aExposedStorages.begin();
 267                 aIter != m_aExposedStorages.end();
 268                 ++aIter
 269             )
 270         {
 271             tools::stor::commitStorageIfWriteable( aIter->second );
 272         }
 273     }
 274     catch(const WrappedTargetException&)
 275     {
 276         // WrappedTargetException not allowed to leave
 277         throw IOException();
 278     }
 279 }
 280
 281 bool DocumentStorageAccess::commitEmbeddedStorage( bool _bPreventRootCommits )
 282 {
 283     if ( _bPreventRootCommits )
 284         impl_suspendCommitPropagation();
 285
 286     bool bSuccess = false;
 287     try
 288     {
 289         NamedStorages::const_iterator pos = m_aExposedStorages.find( "database" );
 290         if ( pos != m_aExposedStorages.end() )
 291             bSuccess = tools::stor::commitStorageIfWriteable( pos->second );
 292     }
 293     catch( Exception& )
 294     {
 295         DBG_UNHANDLED_EXCEPTION();
 296     }
 297
 298     if ( _bPreventRootCommits )
 299         impl_resumeCommitPropagation();
 300
 301     return bSuccess;
 302
 303 }
 304
 305 Reference< XStorage > SAL_CALL DocumentStorageAccess::getDocumentSubStorage( const OUString& aStorageName, ::sal_Int32 _nDesiredMode ) throw (RuntimeException, std::exception)
 306 {
 307     ::osl::MutexGuard aGuard( m_aMutex );
 308     NamedStorages::const_iterator pos = m_aExposedStorages.find( aStorageName );
 309     if ( pos == m_aExposedStorages.end() )
 310     {
 311         Reference< XStorage > xResult = impl_openSubStorage_nothrow( aStorageName, _nDesiredMode );
 312         pos = m_aExposedStorages.insert( NamedStorages::value_type( aStorageName, xResult ) ).first;
 313     }
 314
 315     return pos->second;
 316 }
 317
 318 Sequence< OUString > SAL_CALL DocumentStorageAccess::getDocumentSubStoragesNames(  ) throw (IOException, RuntimeException, std::exception)
 319 {
 320     Reference< XStorage > xRootStor( m_pModelImplementation->getRootStorage() );
 321     if ( !xRootStor.is() )
 322         return Sequence< OUString >();
 323
 324     ::std::vector< OUString > aNames;
 325
 326     Sequence< OUString > aElementNames( xRootStor->getElementNames() );
 327     for ( sal_Int32 i=0; i<aElementNames.getLength(); ++i )
 328     {
 329         if ( xRootStor->isStorageElement( aElementNames[i] ) )
 330             aNames.push_back( aElementNames[i] );
 331     }
 332     return aNames.empty()
 333         ?  Sequence< OUString >()
 334         :  Sequence< OUString >( &aNames[0], aNames.size() );
 335 }
 336
 337 void SAL_CALL DocumentStorageAccess::preCommit( const css::lang::EventObject& /*aEvent*/ ) throw (Exception, RuntimeException, std::exception)
 338 {
 339     // not interested in
 340 }
 341
 342 void SAL_CALL DocumentStorageAccess::commited( const css::lang::EventObject& aEvent ) throw (RuntimeException, std::exception)
 343 {
 344     ::osl::MutexGuard aGuard( m_aMutex );
 345
 346     if ( m_pModelImplementation )
 347         m_pModelImplementation->setModified( true );
 348
 349     if ( m_pModelImplementation && m_bPropagateCommitToRoot )
 350     {
 351         Reference< XStorage > xStorage( aEvent.Source, UNO_QUERY );
 352
 353         // check if this is the dedicated "database" sub storage
 354         NamedStorages::const_iterator pos = m_aExposedStorages.find( "database" );
 355         if  (   ( pos != m_aExposedStorages.end() )
 356             &&  ( pos->second == xStorage )
 357             )
 358         {
 359             // if so, also commit the root storage
 360             m_pModelImplementation->commitRootStorage();
 361         }
 362     }
 363 }
 364
 365 void SAL_CALL DocumentStorageAccess::preRevert( const css::lang::EventObject& /*aEvent*/ ) throw (Exception, RuntimeException, std::exception)
 366 {
 367     // not interested in
 368 }
 369
 370 void SAL_CALL DocumentStorageAccess::reverted( const css::lang::EventObject& /*aEvent*/ ) throw (RuntimeException, std::exception)
 371 {
 372     // not interested in
 373 }
 374
 375 void SAL_CALL DocumentStorageAccess::disposing( const css::lang::EventObject& Source ) throw ( RuntimeException, std::exception )
 376 {
 377     OSL_ENSURE( Reference< XStorage >( Source.Source, UNO_QUERY ).is(), "DocumentStorageAccess::disposing: No storage? What's this?" );
 378
 379     if ( m_bDisposingSubStorages )
 380         return;
 381
 382     for (   NamedStorages::const_iterator find = m_aExposedStorages.begin();
 383             find != m_aExposedStorages.end();
 384             ++find
 385         )
 386         if ( find->second == Source.Source )
 387         {
 388             m_aExposedStorages.erase( find );
 389             break;
 390         }
 391 }
 392
 393 // ODatabaseModelImpl
 394
 395 ODatabaseModelImpl::ODatabaseModelImpl( const Reference< XComponentContext >& _rxContext, ODatabaseContext& _rDBContext )
 396             :m_xModel()
 397             ,m_xDataSource()
 398             ,m_aMutex()
 399             ,m_aMutexFacade( m_aMutex )
 400             ,m_aContainer(4)
 401             ,m_aMacroMode( *this )
 402             ,m_nImposedMacroExecMode( MacroExecMode::NEVER_EXECUTE )
 403             ,m_rDBContext( _rDBContext )
 404             ,m_refCount(0)
 405             ,m_aEmbeddedMacros()
 406             ,m_bModificationLock( false )
 407             ,m_bDocumentInitialized( false )
 408             ,m_aContext( _rxContext )
 409             ,m_nLoginTimeout(0)
 410             ,m_bReadOnly(false)
 411             ,m_bPasswordRequired(false)
 412             ,m_bSuppressVersionColumns(true)
 413             ,m_bModified(false)
 414             ,m_bDocumentReadOnly(false)
 415             ,m_pSharedConnectionManager(nullptr)
 416             ,m_nControllerLockCount(0)
 417 {
 418     // some kind of default
 419     m_sConnectURL = "jdbc:";
 420     m_aTableFilter.realloc(1);
 421     m_aTableFilter[0] = "%";
 422     impl_construct_nothrow();
 423 }
 424
 425 ODatabaseModelImpl::ODatabaseModelImpl(
 426                     const OUString& _rRegistrationName,
 427                     const Reference< XComponentContext >& _rxContext,
 428                     ODatabaseContext& _rDBContext
 429                     )
 430             :m_xModel()
 431             ,m_xDataSource()
 432             ,m_aMutex()
 433             ,m_aMutexFacade( m_aMutex )
 434             ,m_aContainer(4)
 435             ,m_aMacroMode( *this )
 436             ,m_nImposedMacroExecMode( MacroExecMode::NEVER_EXECUTE )
 437             ,m_rDBContext( _rDBContext )
 438             ,m_refCount(0)
 439             ,m_aEmbeddedMacros()
 440             ,m_bModificationLock( false )
 441             ,m_bDocumentInitialized( false )
 442             ,m_aContext( _rxContext )
 443             ,m_sName(_rRegistrationName)
 444             ,m_nLoginTimeout(0)
 445             ,m_bReadOnly(false)
 446             ,m_bPasswordRequired(false)
 447             ,m_bSuppressVersionColumns(true)
 448             ,m_bModified(false)
 449             ,m_bDocumentReadOnly(false)
 450             ,m_pSharedConnectionManager(nullptr)
 451             ,m_nControllerLockCount(0)
 452 {
 453     impl_construct_nothrow();
 454 }
 455
 456 ODatabaseModelImpl::~ODatabaseModelImpl()
 457 {
 458 }
 459
 460 void ODatabaseModelImpl::impl_construct_nothrow()
 461 {
 462     // create the property bag to hold the settings (also known as "Info" property)
 463     try
 464     {
 465         // the set of property value types in the bag is limited:
 466         Sequence< Type > aAllowedTypes(6);
 467         Type* pAllowedType = aAllowedTypes.getArray();
 468         *pAllowedType++ = ::cppu::UnoType<sal_Bool>::get();
 469         *pAllowedType++ = ::cppu::UnoType<double>::get();
 470         *pAllowedType++ = ::cppu::UnoType<OUString>::get();
 471         *pAllowedType++ = ::cppu::UnoType<sal_Int32>::get();
 472         *pAllowedType++ = ::cppu::UnoType<sal_Int16>::get();
 473         *pAllowedType++ = cppu::UnoType<Sequence< Any >>::get();
 474
 475         m_xSettings = PropertyBag::createWithTypes( m_aContext, aAllowedTypes, false/*AllowEmptyPropertyName*/, true/*AutomaticAddition*/ );
 476
 477         // insert the default settings
 478         Reference< XPropertyContainer > xContainer( m_xSettings, UNO_QUERY_THROW );
 479         Reference< XSet > xSettingsSet( m_xSettings, UNO_QUERY_THROW );
 480         const AsciiPropertyValue* pSettings = getDefaultDataSourceSettings();
 481         for ( ; pSettings->AsciiName; ++pSettings )
 482         {
 483             if ( !pSettings->DefaultValue.hasValue() )
 484             {
 485                 Property aProperty(
 486                     OUString::createFromAscii( pSettings->AsciiName ),
 487                     -1,
 488                     pSettings->ValueType,
 489                     PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT | PropertyAttribute::MAYBEVOID
 490                 );
 491                 xSettingsSet->insert( makeAny( aProperty ) );
 492             }
 493             else
 494             {
 495                 xContainer->addProperty(
 496                     OUString::createFromAscii( pSettings->AsciiName ),
 497                     PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT,
 498                     pSettings->DefaultValue
 499                 );
 500             }
 501         }
 502     }
 503     catch( const Exception& )
 504     {
 505         DBG_UNHANDLED_EXCEPTION();
 506     }
 507     m_rDBContext.appendAtTerminateListener(*this);
 508 }
 509
 510 namespace
 511 {
 512     OUString lcl_getContainerStorageName_throw( ODatabaseModelImpl::ObjectType _eType )
 513     {
 514         const sal_Char* pAsciiName( nullptr );
 515         switch ( _eType )
 516         {
 517         case ODatabaseModelImpl::E_FORM:   pAsciiName = "forms"; break;
 518         case ODatabaseModelImpl::E_REPORT: pAsciiName = "reports"; break;
 519         case ODatabaseModelImpl::E_QUERY:  pAsciiName = "queries"; break;
 520         case ODatabaseModelImpl::E_TABLE:  pAsciiName = "tables"; break;
 521         default:
 522             throw RuntimeException();
 523         }
 524         return OUString::createFromAscii( pAsciiName );
 525     }
 526
 527     bool lcl_hasObjectWithMacros_throw( const ODefinitionContainer_Impl& _rObjectDefinitions, const Reference< XStorage >& _rxContainerStorage )
 528     {
 529         bool bSomeDocHasMacros = false;
 530
 531         for (   ODefinitionContainer_Impl::const_iterator object = _rObjectDefinitions.begin();
 532                 ( object != _rObjectDefinitions.end() ) && !bSomeDocHasMacros;
 533                 ++object
 534             )
 535         {
 536 #if OSL_DEBUG_LEVEL > 0
 537             const OUString& rName( object->first ); (void)rName;
 538 #endif
 539
 540             const TContentPtr& rDefinition( object->second );
 541             const OUString& rPersistentName( rDefinition->m_aProps.sPersistentName );
 542
 543             if ( rPersistentName.isEmpty() )
 544             {   // it's a logical sub folder used to organize the real objects
 545                 const ODefinitionContainer_Impl& rSubFoldersObjectDefinitions( dynamic_cast< const ODefinitionContainer_Impl& >( *rDefinition.get() ) );
 546                 bSomeDocHasMacros = lcl_hasObjectWithMacros_throw( rSubFoldersObjectDefinitions, _rxContainerStorage );
 547                 continue;
 548             }
 549
 550             bSomeDocHasMacros = ODatabaseModelImpl::objectHasMacros( _rxContainerStorage, rPersistentName );
 551         }
 552         return bSomeDocHasMacros;
 553     }
 554
 555     bool lcl_hasObjectsWithMacros_nothrow( ODatabaseModelImpl& _rModel, const ODatabaseModelImpl::ObjectType _eType )
 556     {
 557         bool bSomeDocHasMacros = false;
 558
 559         const OContentHelper_Impl& rContainerData( *_rModel.getObjectContainer( _eType ).get() );
 560         const ODefinitionContainer_Impl& rObjectDefinitions = dynamic_cast< const ODefinitionContainer_Impl& >( rContainerData );
 561
 562         try
 563         {
 564             Reference< XStorage > xContainerStorage( _rModel.getStorage( _eType ) );
 565             // note the READWRITE here: If the storage already existed before, then the OpenMode will
 566             // be ignored, anyway.
 567             // If the storage did not yet exist, then it will be created. If the database document
 568             // is read-only, the OpenMode will be automatically downgraded to READ. Otherwise,
 569             // the storage will in fact be created as READWRITE. While this is not strictly necessary
 570             // for this particular use case here, it is required since the storage is *cached*, and
 571             // later use cases will need the READWRITE mode.
 572
 573             if ( xContainerStorage.is() )
 574                 bSomeDocHasMacros = lcl_hasObjectWithMacros_throw( rObjectDefinitions, xContainerStorage );
 575         }
 576         catch( const Exception& )
 577         {
 578             DBG_UNHANDLED_EXCEPTION();
 579             // be on the safe side: If we can't reliably determine whether there are macros,
 580             // assume there actually are. Better this way, than the other way round.
 581             bSomeDocHasMacros = true;
 582         }
 583
 584         return bSomeDocHasMacros;
 585     }
 586 }
 587
 588 bool ODatabaseModelImpl::objectHasMacros( const Reference< XStorage >& _rxContainerStorage, const OUString& _rPersistentName )
 589 {
 590     OSL_PRECOND( _rxContainerStorage.is(), "ODatabaseModelImpl::objectHasMacros: this will crash!" );
 591
 592     bool bHasMacros = true;
 593     try
 594     {
 595         if ( !_rxContainerStorage->hasByName( _rPersistentName ) )
 596             return false;
 597
 598         Reference< XStorage > xObjectStor( _rxContainerStorage->openStorageElement(
 599             _rPersistentName, ElementModes::READ ) );
 600
 601         bHasMacros = ::sfx2::DocumentMacroMode::storageHasMacros( xObjectStor );
 602     }
 603     catch( const Exception& )
 604     {
 605         DBG_UNHANDLED_EXCEPTION();
 606     }
 607     return bHasMacros;
 608 }
 609
 610 void ODatabaseModelImpl::reset()
 611 {
 612     m_bReadOnly = false;
 613     ::std::vector< TContentPtr > aEmptyContainers( 4 );
 614     m_aContainer.swap( aEmptyContainers );
 615
 616     if ( m_pStorageAccess.is() )
 617     {
 618         m_pStorageAccess->dispose();
 619         m_pStorageAccess.clear();
 620     }
 621 }
 622
 623 void SAL_CALL ODatabaseModelImpl::disposing( const css::lang::EventObject& Source ) throw(RuntimeException)
 624 {
 625     Reference<XConnection> xCon(Source.Source,UNO_QUERY);
 626     if ( xCon.is() )
 627     {
 628         bool bStore = false;
 629         for (OWeakConnectionArray::iterator i = m_aConnections.begin(); i != m_aConnections.end(); )
 630         {
 631             css::uno::Reference< css::sdbc::XConnection > xIterConn ( *i );
 632             if ( !xIterConn.is())
 633             {
 634                 i = m_aConnections.erase(i);
 635             }
 636             else if ( xCon == xIterConn )
 637             {
 638                 *i = css::uno::WeakReference< css::sdbc::XConnection >();
 639                 bStore = true;
 640                 break;
 641             } else
 642                 ++i;
 643         }
 644
 645         if ( bStore )
 646             commitRootStorage();
 647     }
 648     else
 649     {
 650         OSL_FAIL( "ODatabaseModelImpl::disposing: where does this come from?" );
 651     }
 652 }
 653
 654 void ODatabaseModelImpl::clearConnections()
 655 {
 656     OWeakConnectionArray aConnections;
 657     aConnections.swap( m_aConnections );
 658
 659     Reference< XConnection > xConn;
 660     OWeakConnectionArray::const_iterator aEnd = aConnections.end();
 661     for ( OWeakConnectionArray::const_iterator i = aConnections.begin(); aEnd != i; ++i )
 662     {
 663         xConn = *i;
 664         if ( xConn.is() )
 665         {
 666             try
 667             {
 668                 xConn->close();
 669             }
 670             catch(const Exception&)
 671             {
 672                 DBG_UNHANDLED_EXCEPTION();
 673             }
 674         }
 675     }
 676
 677     m_pSharedConnectionManager = nullptr;
 678     m_xSharedConnectionManager = nullptr;
 679 }
 680
 681 void ODatabaseModelImpl::dispose()
 682 {
 683     // dispose the data source and the model
 684     try
 685     {
 686         Reference< XDataSource > xDS( m_xDataSource );
 687         ::comphelper::disposeComponent( xDS );
 688
 689         Reference< XModel > xModel( m_xModel );
 690         ::comphelper::disposeComponent( xModel );
 691     }
 692     catch( const Exception& )
 693     {
 694         DBG_UNHANDLED_EXCEPTION();
 695     }
 696     m_xDataSource = WeakReference<XDataSource>();
 697     m_xModel = WeakReference< XModel >();
 698
 699     ::std::vector<TContentPtr>::const_iterator aIter = m_aContainer.begin();
 700     ::std::vector<TContentPtr>::const_iterator aEnd = m_aContainer.end();
 701     for (;aIter != aEnd ; ++aIter)
 702     {
 703         if ( aIter->get() )
 704             (*aIter)->m_pDataSource = nullptr;
 705     }
 706     m_aContainer.clear();
 707
 708     clearConnections();
 709
 710     m_xNumberFormatsSupplier = nullptr;
 711
 712     try
 713     {
 714         bool bCouldStore = commitEmbeddedStorage( true );
 715             // "true" means that committing the embedded storage should not trigger committing the root
 716             // storage. This is because we are going to commit the root storage ourself, anyway
 717         disposeStorages();
 718         if ( bCouldStore )
 719             commitRootStorage();
 720
 721         impl_switchToStorage_throw( nullptr );
 722     }
 723     catch( const Exception& )
 724     {
 725         DBG_UNHANDLED_EXCEPTION();
 726     }
 727
 728     if ( m_pStorageAccess.is() )
 729     {
 730         m_pStorageAccess->dispose();
 731         m_pStorageAccess.clear();
 732     }
 733 }
 734
 735 const Reference< XNumberFormatsSupplier > & ODatabaseModelImpl::getNumberFormatsSupplier()
 736 {
 737     if (!m_xNumberFormatsSupplier.is())
 738     {
 739         // the arguments : the locale of the current user
 740         UserInformation aUserInfo;
 741         Locale aLocale = aUserInfo.getUserLanguage();
 742
 743         m_xNumberFormatsSupplier.set( NumberFormatsSupplier::createWithLocale( m_aContext, aLocale ) );
 744     }
 745     return m_xNumberFormatsSupplier;
 746 }
 747
 748 void ODatabaseModelImpl::setDocFileLocation( const OUString& i_rLoadedFrom )
 749 {
 750     ENSURE_OR_THROW( !i_rLoadedFrom.isEmpty(), "invalid URL" );
 751     m_sDocFileLocation = i_rLoadedFrom;
 752 }
 753
 754 void ODatabaseModelImpl::setResource( const OUString& i_rDocumentURL, const Sequence< PropertyValue >& _rArgs )
 755 {
 756     ENSURE_OR_THROW( !i_rDocumentURL.isEmpty(), "invalid URL" );
 757
 758     ::comphelper::NamedValueCollection aMediaDescriptor( _rArgs );
 759 #if OSL_DEBUG_LEVEL > 0
 760     if ( aMediaDescriptor.has( "SalvagedFile" ) )
 761     {
 762         OUString sSalvagedFile( aMediaDescriptor.getOrDefault( "SalvagedFile", OUString() ) );
 763         // If SalvagedFile is an empty string, this indicates "the document is being recovered, but i_rDocumentURL already
 764         // is the real document URL, not the temporary document location"
 765         if ( sSalvagedFile.isEmpty() )
 766             sSalvagedFile = i_rDocumentURL;
 767
 768         OSL_ENSURE( sSalvagedFile == i_rDocumentURL, "ODatabaseModelImpl::setResource: inconsistency!" );
 769             // nowadays, setResource should only be called with the logical URL of the document
 770     }
 771 #endif
 772
 773     m_aMediaDescriptor = stripLoadArguments( aMediaDescriptor );
 774
 775     impl_switchToLogicalURL( i_rDocumentURL );
 776 }
 777
 778 ::comphelper::NamedValueCollection ODatabaseModelImpl::stripLoadArguments( const ::comphelper::NamedValueCollection& _rArguments )
 779 {
 780     OSL_ENSURE( !_rArguments.has( "Model" ), "ODatabaseModelImpl::stripLoadArguments: this is suspicious (1)!" );
 781     OSL_ENSURE( !_rArguments.has( "ViewName" ), "ODatabaseModelImpl::stripLoadArguments: this is suspicious (2)!" );
 782
 783     ::comphelper::NamedValueCollection aMutableArgs( _rArguments );
 784     aMutableArgs.remove( "Model" );
 785     aMutableArgs.remove( "ViewName" );
 786     return aMutableArgs;
 787 }
 788
 789 void ODatabaseModelImpl::disposeStorages()
 790 {
 791     getDocumentStorageAccess()->disposeStorages();
 792 }
 793
 794 Reference< XSingleServiceFactory > ODatabaseModelImpl::createStorageFactory() const
 795 {
 796     return StorageFactory::create( m_aContext );
 797 }
 798
 799 void ODatabaseModelImpl::commitRootStorage()
 800 {
 801     Reference< XStorage > xStorage( getOrCreateRootStorage() );
 802     bool bSuccess = commitStorageIfWriteable_ignoreErrors( xStorage );
 803     SAL_WARN_IF(!bSuccess && xStorage.is(), "dbaccess",
 804         "ODatabaseModelImpl::commitRootStorage: could not commit the storage!");
 805 }
 806
 807 Reference< XStorage > ODatabaseModelImpl::getOrCreateRootStorage()
 808 {
 809     if ( !m_xDocumentStorage.is() )
 810     {
 811         Reference< XSingleServiceFactory> xStorageFactory = StorageFactory::create( m_aContext );
 812         Any aSource;
 813         aSource = m_aMediaDescriptor.get( "Stream" );
 814         if ( !aSource.hasValue() )
 815             aSource = m_aMediaDescriptor.get( "InputStream" );
 816         if ( !aSource.hasValue() && !m_sDocFileLocation.isEmpty() )
 817             aSource <<= m_sDocFileLocation;
 818         // TODO: shouldn't we also check URL?
 819
 820         OSL_ENSURE( aSource.hasValue(), "ODatabaseModelImpl::getOrCreateRootStorage: no source to create the storage from!" );
 821
 822         if ( aSource.hasValue() )
 823         {
 824             Sequence< Any > aStorageCreationArgs(2);
 825             aStorageCreationArgs[0] = aSource;
 826             aStorageCreationArgs[1] <<= ElementModes::READWRITE;
 827
 828             Reference< XStorage > xDocumentStorage;
 829             OUString sURL;
 830             aSource >>= sURL;
 831             // Don't try to load a meta-URL as-is.
 832             if (!sURL.startsWithIgnoreAsciiCase("vnd.sun.star.pkg:"))
 833             {
 834                 try
 835                 {
 836                     xDocumentStorage.set( xStorageFactory->createInstanceWithArguments( aStorageCreationArgs ), UNO_QUERY_THROW );
 837                 }
 838                 catch( const Exception& )
 839                 {
 840                     m_bDocumentReadOnly = true;
 841                     aStorageCreationArgs[1] <<= ElementModes::READ;
 842                     try
 843                     {
 844                         xDocumentStorage.set( xStorageFactory->createInstanceWithArguments( aStorageCreationArgs ), UNO_QUERY_THROW );
 845                     }
 846                     catch( const Exception& )
 847                     {
 848                         DBG_UNHANDLED_EXCEPTION();
 849                     }
 850                 }
 851             }
 852
 853             impl_switchToStorage_throw( xDocumentStorage );
 854         }
 855     }
 856     return m_xDocumentStorage.getTyped();
 857 }
 858
 859 DocumentStorageAccess* ODatabaseModelImpl::getDocumentStorageAccess()
 860 {
 861     if ( !m_pStorageAccess.is() )
 862     {
 863         m_pStorageAccess = new DocumentStorageAccess( *this );
 864     }
 865     return m_pStorageAccess.get();
 866 }
 867
 868 void ODatabaseModelImpl::modelIsDisposing( const bool _wasInitialized, ResetModelAccess )
 869 {
 870     m_xModel.clear();
 871
 872     // Basic libraries and Dialog libraries are a model facet, though held at this impl class.
 873     // They automatically dispose themself when the model they belong to is being disposed.
 874     // So, to not be tempted to do anything with them, again, we reset them.
 875     m_xBasicLibraries.clear();
 876     m_xDialogLibraries.clear();
 877
 878     m_bDocumentInitialized = _wasInitialized;
 879 }
 880
 881 Reference< XDocumentSubStorageSupplier > ODatabaseModelImpl::getDocumentSubStorageSupplier()
 882 {
 883     return getDocumentStorageAccess();
 884 }
 885
 886 bool ODatabaseModelImpl::commitEmbeddedStorage( bool _bPreventRootCommits )
 887 {
 888     return getDocumentStorageAccess()->commitEmbeddedStorage( _bPreventRootCommits );
 889 }
 890
 891 bool ODatabaseModelImpl::commitStorageIfWriteable_ignoreErrors( const Reference< XStorage >& _rxStorage )
 892 {
 893     bool bSuccess = false;
 894     try
 895     {
 896         bSuccess = tools::stor::commitStorageIfWriteable( _rxStorage );
 897     }
 898     catch( const Exception& )
 899     {
 900         DBG_UNHANDLED_EXCEPTION();
 901     }
 902     return bSuccess;
 903 }
 904
 905 void ODatabaseModelImpl::setModified( bool _bModified )
 906 {
 907     if ( isModifyLocked() )
 908         return;
 909
 910     try
 911     {
 912         Reference< XModifiable > xModi( m_xModel.get(), UNO_QUERY );
 913         if ( xModi.is() )
 914             xModi->setModified( _bModified );
 915         else
 916             m_bModified = _bModified;
 917     }
 918     catch( const Exception& )
 919     {
 920         DBG_UNHANDLED_EXCEPTION();
 921     }
 922 }
 923
 924 Reference<XDataSource> ODatabaseModelImpl::getOrCreateDataSource()
 925 {
 926     Reference<XDataSource> xDs = m_xDataSource;
 927     if ( !xDs.is() )
 928     {
 929         xDs = new ODatabaseSource(this);
 930         m_xDataSource = xDs;
 931     }
 932     return xDs;
 933 }
 934
 935 Reference< XModel> ODatabaseModelImpl::getModel_noCreate() const
 936 {
 937     return m_xModel;
 938 }
 939
 940 Reference< XModel > ODatabaseModelImpl::createNewModel_deliverOwnership()
 941 {
 942     Reference< XModel > xModel( m_xModel );
 943     OSL_PRECOND( !xModel.is(), "ODatabaseModelImpl::createNewModel_deliverOwnership: not to be called if there already is a model!" );
 944     if ( !xModel.is() )
 945     {
 946         bool bHadModelBefore = m_bDocumentInitialized;
 947
 948         xModel = ODatabaseDocument::createDatabaseDocument( this, ODatabaseDocument::FactoryAccess() );
 949         m_xModel = xModel;
 950
 951         try
 952         {
 953             Reference< XGlobalEventBroadcaster > xModelCollection = theGlobalEventBroadcaster::get( m_aContext );
 954             xModelCollection->insert( makeAny( xModel ) );
 955         }
 956         catch( const Exception& )
 957         {
 958             DBG_UNHANDLED_EXCEPTION();
 959         }
 960
 961         if ( bHadModelBefore )
 962         {
 963             // do an attachResources
 964             // In case the document is loaded regularly, this is not necessary, as our loader will do it.
 965             // However, in case that the document is implicitly created by asking the data source for the document,
 966             // then nobody would call the doc's attachResource. So, we do it here, to ensure it's in a proper
 967             // state, fires all events, and so on.
 968             // #i105505#
 969             xModel->attachResource( xModel->getURL(), m_aMediaDescriptor.getPropertyValues() );
 970         }
 971     }
 972     return xModel;
 973 }
 974
 975 void SAL_CALL ODatabaseModelImpl::acquire()
 976 {
 977     osl_atomic_increment(&m_refCount);
 978 }
 979
 980 void SAL_CALL ODatabaseModelImpl::release()
 981 {
 982     if ( osl_atomic_decrement(&m_refCount) == 0 )
 983     {
 984         acquire();  // prevent multiple releases
 985         m_rDBContext.removeFromTerminateListener(*this);
 986         dispose();
 987         m_rDBContext.storeTransientProperties(*this);
 988         if (!m_sDocumentURL.isEmpty())
 989             m_rDBContext.revokeDatabaseDocument(*this);
 990         delete this;
 991     }
 992 }
 993
 994 void ODatabaseModelImpl::commitStorages()
 995 {
 996     getDocumentStorageAccess()->commitStorages();
 997 }
 998
 999 Reference< XStorage > ODatabaseModelImpl::getStorage( const ObjectType _eType )
1000 {
1001     return getDocumentStorageAccess()->getDocumentSubStorage( getObjectContainerStorageName( _eType ),
1002                     css::embed::ElementModes::READWRITE );
1003 }
1004
1005 const AsciiPropertyValue* ODatabaseModelImpl::getDefaultDataSourceSettings()
1006 {
1007     static const AsciiPropertyValue aKnownSettings[] =
1008     {
1009         // known JDBC settings
1010         AsciiPropertyValue( "JavaDriverClass",            makeAny( OUString() ) ),
1011         AsciiPropertyValue( "JavaDriverClassPath",        makeAny( OUString() ) ),
1012         AsciiPropertyValue( "IgnoreCurrency",             makeAny( false ) ),
1013         // known settings for file-based drivers
1014         AsciiPropertyValue( "Extension",                  makeAny( OUString() ) ),
1015         AsciiPropertyValue( "CharSet",                    makeAny( OUString() ) ),
1016         AsciiPropertyValue( "HeaderLine",                 makeAny( true ) ),
1017         AsciiPropertyValue( "FieldDelimiter",             makeAny( OUString( "," ) ) ),
1018         AsciiPropertyValue( "StringDelimiter",            makeAny( OUString( "\"" ) ) ),
1019         AsciiPropertyValue( "DecimalDelimiter",           makeAny( OUString( "." ) ) ),
1020         AsciiPropertyValue( "ThousandDelimiter",          makeAny( OUString() ) ),
1021         AsciiPropertyValue( "ShowDeleted",                makeAny( false ) ),
1022         // known ODBC settings
1023         AsciiPropertyValue( "SystemDriverSettings",       makeAny( OUString() ) ),
1024         AsciiPropertyValue( "UseCatalog",                 makeAny( false ) ),
1025         AsciiPropertyValue( "TypeInfoSettings",           makeAny( Sequence< Any >()) ),
1026         // settings related to auto increment handling
1027         AsciiPropertyValue( "AutoIncrementCreation",      makeAny( OUString() ) ),
1028         AsciiPropertyValue( "AutoRetrievingStatement",    makeAny( OUString() ) ),
1029         AsciiPropertyValue( "IsAutoRetrievingEnabled",    makeAny( false ) ),
1030         // known LDAP driver settings
1031         AsciiPropertyValue( "HostName",                   makeAny( OUString() ) ),
1032         AsciiPropertyValue( "PortNumber",                 makeAny( (sal_Int32)389 ) ),
1033         AsciiPropertyValue( "BaseDN",                     makeAny( OUString() ) ),
1034         AsciiPropertyValue( "MaxRowCount",                makeAny( (sal_Int32)100 ) ),
1035         // known MySQLNative driver settings
1036         AsciiPropertyValue( "LocalSocket",                makeAny( OUString() ) ),
1037         AsciiPropertyValue( "NamedPipe",                  makeAny( OUString() ) ),
1038         // misc known driver settings
1039         AsciiPropertyValue( "ParameterNameSubstitution",  makeAny( false ) ),
1040         AsciiPropertyValue( "AddIndexAppendix",           makeAny( true ) ),
1041         AsciiPropertyValue( "IgnoreDriverPrivileges",     makeAny( true ) ),
1042         AsciiPropertyValue( "ImplicitCatalogRestriction", ::cppu::UnoType< OUString >::get() ),
1043         AsciiPropertyValue( "ImplicitSchemaRestriction",  ::cppu::UnoType< OUString >::get() ),
1044         AsciiPropertyValue( "PrimaryKeySupport",          ::cppu::UnoType< sal_Bool >::get() ),
1045         AsciiPropertyValue( "ShowColumnDescription",      makeAny( false ) ),
1046         // known SDB level settings
1047         AsciiPropertyValue( "NoNameLengthLimit",          makeAny( false ) ),
1048         AsciiPropertyValue( "AppendTableAliasName",       makeAny( false ) ),
1049         AsciiPropertyValue( "GenerateASBeforeCorrelationName",  makeAny( false ) ),
1050         AsciiPropertyValue( "ColumnAliasInOrderBy",       makeAny( true ) ),
1051         AsciiPropertyValue( "EnableSQL92Check",           makeAny( false ) ),
1052         AsciiPropertyValue( "BooleanComparisonMode",      makeAny( BooleanComparisonMode::EQUAL_INTEGER ) ),
1053         AsciiPropertyValue( "TableTypeFilterMode",        makeAny( (sal_Int32)3 ) ),
1054         AsciiPropertyValue( "RespectDriverResultSetType", makeAny( false ) ),
1055         AsciiPropertyValue( "UseSchemaInSelect",          makeAny( true ) ),
1056         AsciiPropertyValue( "UseCatalogInSelect",         makeAny( true ) ),
1057         AsciiPropertyValue( "EnableOuterJoinEscape",      makeAny( true ) ),
1058         AsciiPropertyValue( "PreferDosLikeLineEnds",      makeAny( false ) ),
1059         AsciiPropertyValue( "FormsCheckRequiredFields",   makeAny( true ) ),
1060         AsciiPropertyValue( "EscapeDateTime",             makeAny( true ) ),
1061
1062         // known services to handle database tasks
1063         AsciiPropertyValue( "TableAlterationServiceName", makeAny( OUString() ) ),
1064         AsciiPropertyValue( "TableRenameServiceName",     makeAny( OUString() ) ),
1065         AsciiPropertyValue( "ViewAlterationServiceName",  makeAny( OUString() ) ),
1066         AsciiPropertyValue( "ViewAccessServiceName",      makeAny( OUString() ) ),
1067         AsciiPropertyValue( "CommandDefinitions",         makeAny( OUString() ) ),
1068         AsciiPropertyValue( "Forms",                      makeAny( OUString() ) ),
1069         AsciiPropertyValue( "Reports",                    makeAny( OUString() ) ),
1070         AsciiPropertyValue( "KeyAlterationServiceName",   makeAny( OUString() ) ),
1071         AsciiPropertyValue( "IndexAlterationServiceName", makeAny( OUString() ) ),
1072
1073         AsciiPropertyValue()
1074     };
1075     return aKnownSettings;
1076 }
1077
1078 TContentPtr& ODatabaseModelImpl::getObjectContainer( ObjectType _eType )
1079 {
1080     OSL_PRECOND( _eType >= E_FORM && _eType <= E_TABLE, "ODatabaseModelImpl::getObjectContainer: illegal index!" );
1081     TContentPtr& rContentPtr = m_aContainer[ _eType ];
1082
1083     if ( !rContentPtr.get() )
1084     {
1085         rContentPtr = TContentPtr( new ODefinitionContainer_Impl );
1086         rContentPtr->m_pDataSource = this;
1087         rContentPtr->m_aProps.aTitle = lcl_getContainerStorageName_throw( _eType );
1088     }
1089     return rContentPtr;
1090 }
1091
1092 bool ODatabaseModelImpl::adjustMacroMode_AutoReject()
1093 {
1094     return m_aMacroMode.adjustMacroMode( nullptr );
1095 }
1096
1097 bool ODatabaseModelImpl::checkMacrosOnLoading()
1098 {
1099     Reference< XInteractionHandler > xInteraction;
1100     xInteraction = m_aMediaDescriptor.getOrDefault( "InteractionHandler", xInteraction );
1101     return m_aMacroMode.checkMacrosOnLoading( xInteraction );
1102 }
1103
1104 void ODatabaseModelImpl::resetMacroExecutionMode()
1105 {
1106     m_aMacroMode = ::sfx2::DocumentMacroMode( *this );
1107 }
1108
1109 Reference< XStorageBasedLibraryContainer > ODatabaseModelImpl::getLibraryContainer( bool _bScript )
1110 {
1111     Reference< XStorageBasedLibraryContainer >& rxContainer( _bScript ? m_xBasicLibraries : m_xDialogLibraries );
1112     if ( rxContainer.is() )
1113         return rxContainer;
1114
1115     Reference< XStorageBasedDocument > xDocument( getModel_noCreate(), UNO_QUERY_THROW );
1116         // this is only to be called if there already exists a document model - in fact, it is
1117         // to be called by the document model only
1118
1119     try
1120     {
1121         Reference< XStorageBasedLibraryContainer > (*Factory)( const Reference< XComponentContext >&, const Reference< XStorageBasedDocument >&)
1122             = _bScript ? &DocumentScriptLibraryContainer::create : &DocumentDialogLibraryContainer::create;
1123
1124         rxContainer.set(
1125             (*Factory)( m_aContext, xDocument ),
1126             UNO_QUERY_THROW
1127         );
1128     }
1129     catch( const RuntimeException& )
1130     {
1131         throw;
1132     }
1133     catch( const Exception& )
1134     {
1135         throw WrappedTargetRuntimeException(
1136             OUString(),
1137             xDocument,
1138             ::cppu::getCaughtException()
1139         );
1140     }
1141     return rxContainer;
1142 }
1143
1144 void ODatabaseModelImpl::storeLibraryContainersTo( const Reference< XStorage >& _rxToRootStorage )
1145 {
1146     if ( m_xBasicLibraries.is() )
1147         m_xBasicLibraries->storeLibrariesToStorage( _rxToRootStorage );
1148
1149     if ( m_xDialogLibraries.is() )
1150         m_xDialogLibraries->storeLibrariesToStorage( _rxToRootStorage );
1151 }
1152
1153 Reference< XStorage > ODatabaseModelImpl::switchToStorage( const Reference< XStorage >& _rxNewRootStorage )
1154 {
1155     if ( !_rxNewRootStorage.is() )
1156         throw IllegalArgumentException();
1157
1158     return impl_switchToStorage_throw( _rxNewRootStorage );
1159 }
1160
1161 namespace
1162 {
1163     void lcl_modifyListening( ::sfx2::IModifiableDocument& _rDocument,
1164         const Reference< XStorage >& _rxStorage, ::rtl::Reference< ::sfx2::DocumentStorageModifyListener >& _inout_rListener,
1165         comphelper::SolarMutex& _rMutex, bool _bListen )
1166     {
1167         Reference< XModifiable > xModify( _rxStorage, UNO_QUERY );
1168         OSL_ENSURE( xModify.is() || !_rxStorage.is(), "lcl_modifyListening: storage can't notify us!" );
1169
1170         if ( xModify.is() && !_bListen && _inout_rListener.is() )
1171         {
1172             xModify->removeModifyListener( _inout_rListener.get() );
1173         }
1174
1175         if ( _inout_rListener.is() )
1176         {
1177             _inout_rListener->dispose();
1178             _inout_rListener = nullptr;
1179         }
1180
1181         if ( xModify.is() && _bListen )
1182         {
1183             _inout_rListener = new ::sfx2::DocumentStorageModifyListener( _rDocument, _rMutex );
1184             xModify->addModifyListener( _inout_rListener.get() );
1185         }
1186     }
1187 }
1188
1189 namespace
1190 {
1191     void lcl_rebaseScriptStorage_throw( const Reference< XStorageBasedLibraryContainer >& _rxContainer,
1192         const Reference< XStorage >& _rxNewRootStorage )
1193     {
1194         if ( _rxContainer.is() )
1195         {
1196             if ( _rxNewRootStorage.is() )
1197                 _rxContainer->setRootStorage( _rxNewRootStorage );
1198 //            else
1199                    // TODO: what to do here? dispose the container?
1200         }
1201     }
1202 }
1203
1204 Reference< XStorage > ODatabaseModelImpl::impl_switchToStorage_throw( const Reference< XStorage >& _rxNewRootStorage )
1205 {
1206     // stop listening for modifications at the old storage
1207     lcl_modifyListening( *this, m_xDocumentStorage.getTyped(), m_pStorageModifyListener, m_aMutexFacade, false );
1208
1209     // set new storage
1210     m_xDocumentStorage.reset( _rxNewRootStorage, SharedStorage::TakeOwnership );
1211
1212     // start listening for modifications
1213     lcl_modifyListening( *this, m_xDocumentStorage.getTyped(), m_pStorageModifyListener, m_aMutexFacade, true );
1214
1215     // forward new storage to Basic and Dialog library containers
1216     lcl_rebaseScriptStorage_throw( m_xBasicLibraries, m_xDocumentStorage.getTyped() );
1217     lcl_rebaseScriptStorage_throw( m_xDialogLibraries, m_xDocumentStorage.getTyped() );
1218
1219     m_bReadOnly = !tools::stor::storageIsWritable_nothrow( m_xDocumentStorage.getTyped() );
1220     // TODO: our data source, if it exists, must broadcast the change of its ReadOnly property
1221
1222     return m_xDocumentStorage.getTyped();
1223 }
1224
1225 void ODatabaseModelImpl::impl_switchToLogicalURL( const OUString& i_rDocumentURL )
1226 {
1227     if ( i_rDocumentURL == m_sDocumentURL )
1228         return;
1229
1230     const OUString sOldURL( m_sDocumentURL );
1231     // update our name, if necessary
1232     if  (   ( m_sName == m_sDocumentURL )   // our name is our old URL
1233         ||  ( m_sName.isEmpty() )        // we do not have a name, yet (i.e. are not registered at the database context)
1234         )
1235     {
1236         INetURLObject aURL( i_rDocumentURL );
1237         if ( aURL.GetProtocol() != INetProtocol::NotValid )
1238         {
1239             m_sName = i_rDocumentURL;
1240             // TODO: our data source must broadcast the change of the Name property
1241         }
1242     }
1243
1244     // remember URL
1245     m_sDocumentURL = i_rDocumentURL;
1246
1247     // update our location, if necessary
1248     if  ( m_sDocFileLocation.isEmpty() )
1249         m_sDocFileLocation = m_sDocumentURL;
1250
1251     // register at the database context, or change registration
1252     if (!sOldURL.isEmpty())
1253         m_rDBContext.databaseDocumentURLChange( sOldURL, m_sDocumentURL );
1254     else
1255         m_rDBContext.registerDatabaseDocument( *this );
1256 }
1257
1258 OUString ODatabaseModelImpl::getObjectContainerStorageName( const ObjectType _eType )
1259 {
1260     return lcl_getContainerStorageName_throw( _eType );
1261 }
1262
1263 sal_Int16 ODatabaseModelImpl::getCurrentMacroExecMode() const
1264 {
1265     sal_Int16 nCurrentMode = MacroExecMode::NEVER_EXECUTE;
1266     try
1267     {
1268         nCurrentMode = m_aMediaDescriptor.getOrDefault( "MacroExecutionMode", nCurrentMode );
1269     }
1270     catch( const Exception& )
1271     {
1272         DBG_UNHANDLED_EXCEPTION();
1273     }
1274     return nCurrentMode;
1275 }
1276
1277 void ODatabaseModelImpl::setCurrentMacroExecMode( sal_uInt16 nMacroMode )
1278 {
1279     m_aMediaDescriptor.put( "MacroExecutionMode", nMacroMode );
1280 }
1281
1282 OUString ODatabaseModelImpl::getDocumentLocation() const
1283 {
1284     return getURL();
1285     // formerly, we returned getDocFileLocation here, which is the location of the file from which we
1286     // recovered the "real" document.
1287     // However, during CWS autorecovery evolving, we clarified (with MAV/MT) the role of XModel::getURL and
1288     // XStorable::getLocation. In this course, we agreed that for a macro security check, the *document URL*
1289     // (not the recovery file URL) is to be used: The recovery file lies in the backup folder, and by definition,
1290     // this folder is considered to be secure. So, the document URL needs to be used to decide about the security.
1291 }
1292
1293 ODatabaseModelImpl::EmbeddedMacros ODatabaseModelImpl::determineEmbeddedMacros()
1294 {
1295     if ( !m_aEmbeddedMacros )
1296     {
1297         if ( ::sfx2::DocumentMacroMode::storageHasMacros( getOrCreateRootStorage() ) )
1298         {
1299             m_aEmbeddedMacros.reset( eDocumentWideMacros );
1300         }
1301         else if (   lcl_hasObjectsWithMacros_nothrow( const_cast< ODatabaseModelImpl& >( *this ), E_FORM )
1302                 ||  lcl_hasObjectsWithMacros_nothrow( const_cast< ODatabaseModelImpl& >( *this ), E_REPORT )
1303                 )
1304         {
1305             m_aEmbeddedMacros.reset( eSubDocumentMacros );
1306         }
1307         else
1308         {
1309             m_aEmbeddedMacros.reset( eNoMacros );
1310         }
1311     }
1312     return *m_aEmbeddedMacros;
1313 }
1314
1315 bool ODatabaseModelImpl::documentStorageHasMacros() const
1316 {
1317     const_cast< ODatabaseModelImpl* >( this )->determineEmbeddedMacros();
1318     return ( *m_aEmbeddedMacros != eNoMacros );
1319 }
1320
1321 Reference< XEmbeddedScripts > ODatabaseModelImpl::getEmbeddedDocumentScripts() const
1322 {
1323     return Reference< XEmbeddedScripts >( getModel_noCreate(), UNO_QUERY );
1324 }
1325
1326 SignatureState ODatabaseModelImpl::getScriptingSignatureState()
1327 {
1328     // no support for signatures at the moment
1329     return SignatureState::NOSIGNATURES;
1330 }
1331
1332 bool ODatabaseModelImpl::hasTrustedScriptingSignature( bool /*bAllowUIToAddAuthor*/ )
1333 {
1334     // no support for signatures at the moment
1335     return false;
1336 }
1337
1338 void ODatabaseModelImpl::showBrokenSignatureWarning( const Reference< XInteractionHandler >& /*_rxInteraction*/ ) const
1339 {
1340     OSL_FAIL( "ODatabaseModelImpl::showBrokenSignatureWarning: signatures can't be broken - we do not support them!" );
1341 }
1342
1343 void ODatabaseModelImpl::storageIsModified()
1344 {
1345     setModified( true );
1346 }
1347
1348 ModelDependentComponent::ModelDependentComponent( const ::rtl::Reference< ODatabaseModelImpl >& _model )
1349     :m_pImpl( _model )
1350     ,m_aMutex( _model->getSharedMutex() )
1351 {
1352 }
1353
1354 ModelDependentComponent::~ModelDependentComponent()
1355 {
1356 }
1357
1358 }   // namespace dbaccess
1359
1360 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */