forked from amazingfate/loongoffice
3840aede59
All backends implement the SolarMutex in mostly the same way. So this consolidates this code into a GenericSolarMutex. We still need the abstract SolarMutex class for the fake AKA fascade implementation in dbaccess. The patch also replaces various places of direct mutex usage with either SolarMutexGuard or SolarMutexReleaser objects. Change-Id: Ia0146dd6c51a3b9a513cc6af34a66def58aad831 Reviewed-on: https://gerrit.libreoffice.org/42325 Tested-by: Jenkins <ci@libreoffice.org> Reviewed-by: Michael Meeks <michael.meeks@collabora.com> Reviewed-by: Jan-Marek Glogowski <glogow@fbihome.de>
1359 lines
46 KiB
C++
1359 lines
46 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include "commandcontainer.hxx"
|
|
#include "connection.hxx"
|
|
#include "strings.hrc"
|
|
#include "core_resource.hxx"
|
|
#include "databasecontext.hxx"
|
|
#include "databasedocument.hxx"
|
|
#include "datasource.hxx"
|
|
#include "stringconstants.hxx"
|
|
#include "ModelImpl.hxx"
|
|
#include "userinformation.hxx"
|
|
#include "sdbcoretools.hxx"
|
|
|
|
#include <com/sun/star/beans/PropertyBag.hpp>
|
|
#include <com/sun/star/container/XSet.hpp>
|
|
#include <com/sun/star/document/MacroExecMode.hpp>
|
|
#include <com/sun/star/embed/XTransactedObject.hpp>
|
|
#include <com/sun/star/embed/XTransactionBroadcaster.hpp>
|
|
#include <com/sun/star/embed/StorageFactory.hpp>
|
|
#include <com/sun/star/form/XLoadable.hpp>
|
|
#include <com/sun/star/frame/theGlobalEventBroadcaster.hpp>
|
|
#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
|
|
#include <com/sun/star/sdb/BooleanComparisonMode.hpp>
|
|
#include <com/sun/star/script/DocumentScriptLibraryContainer.hpp>
|
|
#include <com/sun/star/script/DocumentDialogLibraryContainer.hpp>
|
|
#include <com/sun/star/util/NumberFormatsSupplier.hpp>
|
|
|
|
#include <comphelper/interaction.hxx>
|
|
#include <comphelper/seqstream.hxx>
|
|
#include <comphelper/sequence.hxx>
|
|
#include <connectivity/dbexception.hxx>
|
|
#include <cppuhelper/exc_hlp.hxx>
|
|
#include <cppuhelper/implbase.hxx>
|
|
#include <cppuhelper/typeprovider.hxx>
|
|
#include <rtl/digest.h>
|
|
#include <sfx2/signaturestate.hxx>
|
|
#include <tools/debug.hxx>
|
|
#include <tools/diagnose_ex.h>
|
|
#include <osl/diagnose.h>
|
|
#include <sal/log.hxx>
|
|
#include <vcl/errcode.hxx>
|
|
#include <tools/urlobj.hxx>
|
|
#include <unotools/sharedunocomponent.hxx>
|
|
|
|
#include <algorithm>
|
|
|
|
using namespace ::com::sun::star::document;
|
|
using namespace ::com::sun::star::sdbc;
|
|
using namespace ::com::sun::star::sdbcx;
|
|
using namespace ::com::sun::star::sdb;
|
|
using namespace ::com::sun::star::beans;
|
|
using namespace ::com::sun::star::uno;
|
|
using namespace ::com::sun::star::lang;
|
|
using namespace ::com::sun::star::embed;
|
|
using namespace ::com::sun::star::container;
|
|
using namespace ::com::sun::star::util;
|
|
using namespace ::com::sun::star::io;
|
|
using namespace ::com::sun::star::ucb;
|
|
using namespace ::com::sun::star::frame;
|
|
using namespace ::com::sun::star::view;
|
|
using namespace ::com::sun::star::task;
|
|
using namespace ::com::sun::star::script;
|
|
using namespace ::cppu;
|
|
using namespace ::osl;
|
|
using namespace ::dbtools;
|
|
using namespace ::comphelper;
|
|
|
|
namespace dbaccess
|
|
{
|
|
|
|
// VosMutexFacade
|
|
VosMutexFacade::VosMutexFacade( ::osl::Mutex& _rMutex )
|
|
:m_rMutex( _rMutex )
|
|
{
|
|
}
|
|
|
|
void VosMutexFacade::doAcquire( sal_uInt32 nLockCount )
|
|
{
|
|
assert( 1 == nLockCount ); (void) nLockCount;
|
|
m_rMutex.acquire();
|
|
}
|
|
|
|
sal_uInt32 VosMutexFacade::doRelease( bool bUnlockAll )
|
|
{
|
|
assert( !bUnlockAll ); (void) bUnlockAll;
|
|
m_rMutex.release();
|
|
return 1;
|
|
}
|
|
|
|
bool VosMutexFacade::tryToAcquire()
|
|
{
|
|
return m_rMutex.tryToAcquire();
|
|
}
|
|
|
|
bool VosMutexFacade::IsCurrentThread() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// DocumentStorageAccess
|
|
class DocumentStorageAccess : public ::cppu::WeakImplHelper< XDocumentSubStorageSupplier
|
|
, XTransactionListener >
|
|
{
|
|
typedef std::map< OUString, Reference< XStorage > > NamedStorages;
|
|
|
|
::osl::Mutex m_aMutex;
|
|
/// all sub storages which we ever gave to the outer world
|
|
NamedStorages m_aExposedStorages;
|
|
ODatabaseModelImpl* m_pModelImplementation;
|
|
bool m_bPropagateCommitToRoot;
|
|
bool m_bDisposingSubStorages;
|
|
|
|
public:
|
|
explicit DocumentStorageAccess( ODatabaseModelImpl& _rModelImplementation )
|
|
:m_pModelImplementation( &_rModelImplementation )
|
|
,m_bPropagateCommitToRoot( true )
|
|
,m_bDisposingSubStorages( false )
|
|
{
|
|
}
|
|
|
|
protected:
|
|
virtual ~DocumentStorageAccess() override
|
|
{
|
|
}
|
|
|
|
public:
|
|
void dispose();
|
|
|
|
// XDocumentSubStorageSupplier
|
|
virtual Reference< XStorage > SAL_CALL getDocumentSubStorage( const OUString& aStorageName, ::sal_Int32 _nMode ) override;
|
|
virtual Sequence< OUString > SAL_CALL getDocumentSubStoragesNames( ) override;
|
|
|
|
// XTransactionListener
|
|
virtual void SAL_CALL preCommit( const css::lang::EventObject& aEvent ) override;
|
|
virtual void SAL_CALL commited( const css::lang::EventObject& aEvent ) override;
|
|
virtual void SAL_CALL preRevert( const css::lang::EventObject& aEvent ) override;
|
|
virtual void SAL_CALL reverted( const css::lang::EventObject& aEvent ) override;
|
|
|
|
// XEventListener
|
|
virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
|
|
|
|
/// disposes all storages managed by this instance
|
|
void disposeStorages();
|
|
|
|
/// disposes all known sub storages
|
|
void commitStorages();
|
|
|
|
/// commits the dedicated "database" storage
|
|
bool commitEmbeddedStorage( bool _bPreventRootCommits );
|
|
|
|
private:
|
|
/** opens the sub storage with the given name, in the given mode
|
|
*/
|
|
Reference< XStorage > impl_openSubStorage_nothrow( const OUString& _rStorageName, sal_Int32 _nMode );
|
|
|
|
void impl_suspendCommitPropagation()
|
|
{
|
|
OSL_ENSURE( m_bPropagateCommitToRoot, "DocumentStorageAccess::impl_suspendCommitPropagation: already suspended" );
|
|
m_bPropagateCommitToRoot = false;
|
|
}
|
|
void impl_resumeCommitPropagation()
|
|
{
|
|
OSL_ENSURE( !m_bPropagateCommitToRoot, "DocumentStorageAccess::impl_resumeCommitPropagation: not suspended" );
|
|
m_bPropagateCommitToRoot = true;
|
|
}
|
|
|
|
};
|
|
|
|
void DocumentStorageAccess::dispose()
|
|
{
|
|
::osl::MutexGuard aGuard( m_aMutex );
|
|
|
|
for ( NamedStorages::const_iterator loop = m_aExposedStorages.begin();
|
|
loop != m_aExposedStorages.end();
|
|
++loop
|
|
)
|
|
{
|
|
try
|
|
{
|
|
Reference< XTransactionBroadcaster > xBroadcaster( loop->second, UNO_QUERY );
|
|
if ( xBroadcaster.is() )
|
|
xBroadcaster->removeTransactionListener( this );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
}
|
|
|
|
m_aExposedStorages.clear();
|
|
|
|
m_pModelImplementation = nullptr;
|
|
}
|
|
|
|
Reference< XStorage > DocumentStorageAccess::impl_openSubStorage_nothrow( const OUString& _rStorageName, sal_Int32 _nDesiredMode )
|
|
{
|
|
OSL_ENSURE( !_rStorageName.isEmpty(),"ODatabaseModelImpl::impl_openSubStorage_nothrow: Invalid storage name!" );
|
|
|
|
Reference< XStorage > xStorage;
|
|
try
|
|
{
|
|
Reference< XStorage > xRootStorage( m_pModelImplementation->getOrCreateRootStorage() );
|
|
if ( xRootStorage.is() )
|
|
{
|
|
sal_Int32 nRealMode = m_pModelImplementation->m_bDocumentReadOnly ? ElementModes::READ : _nDesiredMode;
|
|
if ( nRealMode == ElementModes::READ )
|
|
{
|
|
if ( xRootStorage.is() && !xRootStorage->hasByName( _rStorageName ) )
|
|
return xStorage;
|
|
}
|
|
|
|
xStorage = xRootStorage->openStorageElement( _rStorageName, nRealMode );
|
|
|
|
Reference< XTransactionBroadcaster > xBroad( xStorage, UNO_QUERY );
|
|
if ( xBroad.is() )
|
|
xBroad->addTransactionListener( this );
|
|
}
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
|
|
return xStorage;
|
|
}
|
|
|
|
void DocumentStorageAccess::disposeStorages()
|
|
{
|
|
m_bDisposingSubStorages = true;
|
|
|
|
NamedStorages::const_iterator aEnd = m_aExposedStorages.end();
|
|
for ( NamedStorages::iterator aIter = m_aExposedStorages.begin();
|
|
aIter != aEnd ;
|
|
++aIter
|
|
)
|
|
{
|
|
try
|
|
{
|
|
::comphelper::disposeComponent( aIter->second );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
}
|
|
m_aExposedStorages.clear();
|
|
|
|
m_bDisposingSubStorages = false;
|
|
}
|
|
|
|
void DocumentStorageAccess::commitStorages()
|
|
{
|
|
try
|
|
{
|
|
for ( NamedStorages::const_iterator aIter = m_aExposedStorages.begin();
|
|
aIter != m_aExposedStorages.end();
|
|
++aIter
|
|
)
|
|
{
|
|
tools::stor::commitStorageIfWriteable( aIter->second );
|
|
}
|
|
}
|
|
catch(const WrappedTargetException&)
|
|
{
|
|
// WrappedTargetException not allowed to leave
|
|
throw IOException();
|
|
}
|
|
}
|
|
|
|
bool DocumentStorageAccess::commitEmbeddedStorage( bool _bPreventRootCommits )
|
|
{
|
|
if ( _bPreventRootCommits )
|
|
impl_suspendCommitPropagation();
|
|
|
|
bool bSuccess = false;
|
|
try
|
|
{
|
|
NamedStorages::const_iterator pos = m_aExposedStorages.find( "database" );
|
|
if ( pos != m_aExposedStorages.end() )
|
|
bSuccess = tools::stor::commitStorageIfWriteable( pos->second );
|
|
}
|
|
catch( Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
|
|
if ( _bPreventRootCommits )
|
|
impl_resumeCommitPropagation();
|
|
|
|
return bSuccess;
|
|
|
|
}
|
|
|
|
Reference< XStorage > SAL_CALL DocumentStorageAccess::getDocumentSubStorage( const OUString& aStorageName, ::sal_Int32 _nDesiredMode )
|
|
{
|
|
::osl::MutexGuard aGuard( m_aMutex );
|
|
NamedStorages::const_iterator pos = m_aExposedStorages.find( aStorageName );
|
|
if ( pos == m_aExposedStorages.end() )
|
|
{
|
|
Reference< XStorage > xResult = impl_openSubStorage_nothrow( aStorageName, _nDesiredMode );
|
|
pos = m_aExposedStorages.emplace( aStorageName, xResult ).first;
|
|
}
|
|
|
|
return pos->second;
|
|
}
|
|
|
|
Sequence< OUString > SAL_CALL DocumentStorageAccess::getDocumentSubStoragesNames( )
|
|
{
|
|
Reference< XStorage > xRootStor( m_pModelImplementation->getRootStorage() );
|
|
if ( !xRootStor.is() )
|
|
return Sequence< OUString >();
|
|
|
|
std::vector< OUString > aNames;
|
|
|
|
Sequence< OUString > aElementNames( xRootStor->getElementNames() );
|
|
for ( sal_Int32 i=0; i<aElementNames.getLength(); ++i )
|
|
{
|
|
if ( xRootStor->isStorageElement( aElementNames[i] ) )
|
|
aNames.push_back( aElementNames[i] );
|
|
}
|
|
return aNames.empty()
|
|
? Sequence< OUString >()
|
|
: Sequence< OUString >( &aNames[0], aNames.size() );
|
|
}
|
|
|
|
void SAL_CALL DocumentStorageAccess::preCommit( const css::lang::EventObject& /*aEvent*/ )
|
|
{
|
|
// not interested in
|
|
}
|
|
|
|
void SAL_CALL DocumentStorageAccess::commited( const css::lang::EventObject& aEvent )
|
|
{
|
|
::osl::MutexGuard aGuard( m_aMutex );
|
|
|
|
if ( m_pModelImplementation )
|
|
m_pModelImplementation->setModified( true );
|
|
|
|
if ( m_pModelImplementation && m_bPropagateCommitToRoot )
|
|
{
|
|
Reference< XStorage > xStorage( aEvent.Source, UNO_QUERY );
|
|
|
|
// check if this is the dedicated "database" sub storage
|
|
NamedStorages::const_iterator pos = m_aExposedStorages.find( "database" );
|
|
if ( ( pos != m_aExposedStorages.end() )
|
|
&& ( pos->second == xStorage )
|
|
)
|
|
{
|
|
// if so, also commit the root storage
|
|
m_pModelImplementation->commitRootStorage();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SAL_CALL DocumentStorageAccess::preRevert( const css::lang::EventObject& /*aEvent*/ )
|
|
{
|
|
// not interested in
|
|
}
|
|
|
|
void SAL_CALL DocumentStorageAccess::reverted( const css::lang::EventObject& /*aEvent*/ )
|
|
{
|
|
// not interested in
|
|
}
|
|
|
|
void SAL_CALL DocumentStorageAccess::disposing( const css::lang::EventObject& Source )
|
|
{
|
|
OSL_ENSURE( Reference< XStorage >( Source.Source, UNO_QUERY ).is(), "DocumentStorageAccess::disposing: No storage? What's this?" );
|
|
|
|
if ( m_bDisposingSubStorages )
|
|
return;
|
|
|
|
for ( NamedStorages::const_iterator find = m_aExposedStorages.begin();
|
|
find != m_aExposedStorages.end();
|
|
++find
|
|
)
|
|
if ( find->second == Source.Source )
|
|
{
|
|
m_aExposedStorages.erase( find );
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ODatabaseModelImpl
|
|
|
|
ODatabaseModelImpl::ODatabaseModelImpl( const Reference< XComponentContext >& _rxContext, ODatabaseContext& _rDBContext )
|
|
:m_xModel()
|
|
,m_xDataSource()
|
|
,m_aMutex()
|
|
,m_aMutexFacade( m_aMutex )
|
|
,m_aContainer(4)
|
|
,m_aMacroMode( *this )
|
|
,m_nImposedMacroExecMode( MacroExecMode::NEVER_EXECUTE )
|
|
,m_rDBContext( _rDBContext )
|
|
,m_refCount(0)
|
|
,m_aEmbeddedMacros()
|
|
,m_bModificationLock( false )
|
|
,m_bDocumentInitialized( false )
|
|
,m_aContext( _rxContext )
|
|
,m_nLoginTimeout(0)
|
|
,m_bReadOnly(false)
|
|
,m_bPasswordRequired(false)
|
|
,m_bSuppressVersionColumns(true)
|
|
,m_bModified(false)
|
|
,m_bDocumentReadOnly(false)
|
|
,m_pSharedConnectionManager(nullptr)
|
|
,m_nControllerLockCount(0)
|
|
{
|
|
// some kind of default
|
|
m_sConnectURL = "jdbc:";
|
|
m_aTableFilter.realloc(1);
|
|
m_aTableFilter[0] = "%";
|
|
impl_construct_nothrow();
|
|
}
|
|
|
|
ODatabaseModelImpl::ODatabaseModelImpl(
|
|
const OUString& _rRegistrationName,
|
|
const Reference< XComponentContext >& _rxContext,
|
|
ODatabaseContext& _rDBContext
|
|
)
|
|
:m_xModel()
|
|
,m_xDataSource()
|
|
,m_aMutex()
|
|
,m_aMutexFacade( m_aMutex )
|
|
,m_aContainer(4)
|
|
,m_aMacroMode( *this )
|
|
,m_nImposedMacroExecMode( MacroExecMode::NEVER_EXECUTE )
|
|
,m_rDBContext( _rDBContext )
|
|
,m_refCount(0)
|
|
,m_aEmbeddedMacros()
|
|
,m_bModificationLock( false )
|
|
,m_bDocumentInitialized( false )
|
|
,m_aContext( _rxContext )
|
|
,m_sName(_rRegistrationName)
|
|
,m_nLoginTimeout(0)
|
|
,m_bReadOnly(false)
|
|
,m_bPasswordRequired(false)
|
|
,m_bSuppressVersionColumns(true)
|
|
,m_bModified(false)
|
|
,m_bDocumentReadOnly(false)
|
|
,m_pSharedConnectionManager(nullptr)
|
|
,m_nControllerLockCount(0)
|
|
{
|
|
impl_construct_nothrow();
|
|
}
|
|
|
|
ODatabaseModelImpl::~ODatabaseModelImpl()
|
|
{
|
|
}
|
|
|
|
void ODatabaseModelImpl::impl_construct_nothrow()
|
|
{
|
|
// create the property bag to hold the settings (also known as "Info" property)
|
|
try
|
|
{
|
|
// the set of property value types in the bag is limited:
|
|
Sequence< Type > aAllowedTypes(6);
|
|
Type* pAllowedType = aAllowedTypes.getArray();
|
|
*pAllowedType++ = ::cppu::UnoType<sal_Bool>::get();
|
|
*pAllowedType++ = ::cppu::UnoType<double>::get();
|
|
*pAllowedType++ = ::cppu::UnoType<OUString>::get();
|
|
*pAllowedType++ = ::cppu::UnoType<sal_Int32>::get();
|
|
*pAllowedType++ = ::cppu::UnoType<sal_Int16>::get();
|
|
*pAllowedType++ = cppu::UnoType<Sequence< Any >>::get();
|
|
|
|
m_xSettings = PropertyBag::createWithTypes( m_aContext, aAllowedTypes, false/*AllowEmptyPropertyName*/, true/*AutomaticAddition*/ );
|
|
|
|
// insert the default settings
|
|
Reference< XPropertyContainer > xContainer( m_xSettings, UNO_QUERY_THROW );
|
|
Reference< XSet > xSettingsSet( m_xSettings, UNO_QUERY_THROW );
|
|
const AsciiPropertyValue* pSettings = getDefaultDataSourceSettings();
|
|
for ( ; pSettings->AsciiName; ++pSettings )
|
|
{
|
|
if ( !pSettings->DefaultValue.hasValue() )
|
|
{
|
|
Property aProperty(
|
|
OUString::createFromAscii( pSettings->AsciiName ),
|
|
-1,
|
|
pSettings->ValueType,
|
|
PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT | PropertyAttribute::MAYBEVOID
|
|
);
|
|
xSettingsSet->insert( makeAny( aProperty ) );
|
|
}
|
|
else
|
|
{
|
|
xContainer->addProperty(
|
|
OUString::createFromAscii( pSettings->AsciiName ),
|
|
PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT,
|
|
pSettings->DefaultValue
|
|
);
|
|
}
|
|
}
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
m_rDBContext.appendAtTerminateListener(*this);
|
|
}
|
|
|
|
namespace
|
|
{
|
|
OUString lcl_getContainerStorageName_throw( ODatabaseModelImpl::ObjectType _eType )
|
|
{
|
|
const sal_Char* pAsciiName( nullptr );
|
|
switch ( _eType )
|
|
{
|
|
case ODatabaseModelImpl::E_FORM: pAsciiName = "forms"; break;
|
|
case ODatabaseModelImpl::E_REPORT: pAsciiName = "reports"; break;
|
|
case ODatabaseModelImpl::E_QUERY: pAsciiName = "queries"; break;
|
|
case ODatabaseModelImpl::E_TABLE: pAsciiName = "tables"; break;
|
|
default:
|
|
throw RuntimeException();
|
|
}
|
|
return OUString::createFromAscii( pAsciiName );
|
|
}
|
|
|
|
bool lcl_hasObjectWithMacros_throw( const ODefinitionContainer_Impl& _rObjectDefinitions, const Reference< XStorage >& _rxContainerStorage )
|
|
{
|
|
bool bSomeDocHasMacros = false;
|
|
|
|
for ( ODefinitionContainer_Impl::const_iterator object = _rObjectDefinitions.begin();
|
|
( object != _rObjectDefinitions.end() ) && !bSomeDocHasMacros;
|
|
++object
|
|
)
|
|
{
|
|
const TContentPtr& rDefinition( object->second );
|
|
const OUString& rPersistentName( rDefinition->m_aProps.sPersistentName );
|
|
|
|
if ( rPersistentName.isEmpty() )
|
|
{ // it's a logical sub folder used to organize the real objects
|
|
const ODefinitionContainer_Impl& rSubFoldersObjectDefinitions( dynamic_cast< const ODefinitionContainer_Impl& >( *rDefinition.get() ) );
|
|
bSomeDocHasMacros = lcl_hasObjectWithMacros_throw( rSubFoldersObjectDefinitions, _rxContainerStorage );
|
|
continue;
|
|
}
|
|
|
|
bSomeDocHasMacros = ODatabaseModelImpl::objectHasMacros( _rxContainerStorage, rPersistentName );
|
|
}
|
|
return bSomeDocHasMacros;
|
|
}
|
|
|
|
bool lcl_hasObjectsWithMacros_nothrow( ODatabaseModelImpl& _rModel, const ODatabaseModelImpl::ObjectType _eType )
|
|
{
|
|
bool bSomeDocHasMacros = false;
|
|
|
|
const OContentHelper_Impl& rContainerData( *_rModel.getObjectContainer( _eType ).get() );
|
|
const ODefinitionContainer_Impl& rObjectDefinitions = dynamic_cast< const ODefinitionContainer_Impl& >( rContainerData );
|
|
|
|
try
|
|
{
|
|
Reference< XStorage > xContainerStorage( _rModel.getStorage( _eType ) );
|
|
// note the READWRITE here: If the storage already existed before, then the OpenMode will
|
|
// be ignored, anyway.
|
|
// If the storage did not yet exist, then it will be created. If the database document
|
|
// is read-only, the OpenMode will be automatically downgraded to READ. Otherwise,
|
|
// the storage will in fact be created as READWRITE. While this is not strictly necessary
|
|
// for this particular use case here, it is required since the storage is *cached*, and
|
|
// later use cases will need the READWRITE mode.
|
|
|
|
if ( xContainerStorage.is() )
|
|
bSomeDocHasMacros = lcl_hasObjectWithMacros_throw( rObjectDefinitions, xContainerStorage );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
// be on the safe side: If we can't reliably determine whether there are macros,
|
|
// assume there actually are. Better this way, than the other way round.
|
|
bSomeDocHasMacros = true;
|
|
}
|
|
|
|
return bSomeDocHasMacros;
|
|
}
|
|
}
|
|
|
|
bool ODatabaseModelImpl::objectHasMacros( const Reference< XStorage >& _rxContainerStorage, const OUString& _rPersistentName )
|
|
{
|
|
OSL_PRECOND( _rxContainerStorage.is(), "ODatabaseModelImpl::objectHasMacros: this will crash!" );
|
|
|
|
bool bHasMacros = true;
|
|
try
|
|
{
|
|
if ( !_rxContainerStorage->hasByName( _rPersistentName ) )
|
|
return false;
|
|
|
|
Reference< XStorage > xObjectStor( _rxContainerStorage->openStorageElement(
|
|
_rPersistentName, ElementModes::READ ) );
|
|
|
|
bHasMacros = ::sfx2::DocumentMacroMode::storageHasMacros( xObjectStor );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
return bHasMacros;
|
|
}
|
|
|
|
void ODatabaseModelImpl::reset()
|
|
{
|
|
m_bReadOnly = false;
|
|
std::vector< TContentPtr > aEmptyContainers( 4 );
|
|
m_aContainer.swap( aEmptyContainers );
|
|
|
|
if ( m_pStorageAccess.is() )
|
|
{
|
|
m_pStorageAccess->dispose();
|
|
m_pStorageAccess.clear();
|
|
}
|
|
}
|
|
|
|
void SAL_CALL ODatabaseModelImpl::disposing( const css::lang::EventObject& Source )
|
|
{
|
|
Reference<XConnection> xCon(Source.Source,UNO_QUERY);
|
|
if ( xCon.is() )
|
|
{
|
|
bool bStore = false;
|
|
for (OWeakConnectionArray::iterator i = m_aConnections.begin(); i != m_aConnections.end(); )
|
|
{
|
|
css::uno::Reference< css::sdbc::XConnection > xIterConn ( *i );
|
|
if ( !xIterConn.is())
|
|
{
|
|
i = m_aConnections.erase(i);
|
|
}
|
|
else if ( xCon == xIterConn )
|
|
{
|
|
*i = css::uno::WeakReference< css::sdbc::XConnection >();
|
|
bStore = true;
|
|
break;
|
|
} else
|
|
++i;
|
|
}
|
|
|
|
if ( bStore )
|
|
commitRootStorage();
|
|
}
|
|
else
|
|
{
|
|
OSL_FAIL( "ODatabaseModelImpl::disposing: where does this come from?" );
|
|
}
|
|
}
|
|
|
|
void ODatabaseModelImpl::clearConnections()
|
|
{
|
|
OWeakConnectionArray aConnections;
|
|
aConnections.swap( m_aConnections );
|
|
|
|
Reference< XConnection > xConn;
|
|
OWeakConnectionArray::const_iterator aEnd = aConnections.end();
|
|
for ( OWeakConnectionArray::const_iterator i = aConnections.begin(); aEnd != i; ++i )
|
|
{
|
|
xConn = *i;
|
|
if ( xConn.is() )
|
|
{
|
|
try
|
|
{
|
|
xConn->close();
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
}
|
|
}
|
|
|
|
m_pSharedConnectionManager = nullptr;
|
|
m_xSharedConnectionManager = nullptr;
|
|
}
|
|
|
|
void ODatabaseModelImpl::dispose()
|
|
{
|
|
// dispose the data source and the model
|
|
try
|
|
{
|
|
Reference< XDataSource > xDS( m_xDataSource );
|
|
::comphelper::disposeComponent( xDS );
|
|
|
|
Reference< XModel > xModel( m_xModel );
|
|
::comphelper::disposeComponent( xModel );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
m_xDataSource = WeakReference<XDataSource>();
|
|
m_xModel = WeakReference< XModel >();
|
|
|
|
std::vector<TContentPtr>::const_iterator aIter = m_aContainer.begin();
|
|
std::vector<TContentPtr>::const_iterator aEnd = m_aContainer.end();
|
|
for (;aIter != aEnd ; ++aIter)
|
|
{
|
|
if ( aIter->get() )
|
|
(*aIter)->m_pDataSource = nullptr;
|
|
}
|
|
m_aContainer.clear();
|
|
|
|
clearConnections();
|
|
|
|
m_xNumberFormatsSupplier = nullptr;
|
|
|
|
try
|
|
{
|
|
bool bCouldStore = commitEmbeddedStorage( true );
|
|
// "true" means that committing the embedded storage should not trigger committing the root
|
|
// storage. This is because we are going to commit the root storage ourself, anyway
|
|
disposeStorages();
|
|
if ( bCouldStore )
|
|
commitRootStorage();
|
|
|
|
impl_switchToStorage_throw( nullptr );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
|
|
if ( m_pStorageAccess.is() )
|
|
{
|
|
m_pStorageAccess->dispose();
|
|
m_pStorageAccess.clear();
|
|
}
|
|
}
|
|
|
|
const Reference< XNumberFormatsSupplier > & ODatabaseModelImpl::getNumberFormatsSupplier()
|
|
{
|
|
if (!m_xNumberFormatsSupplier.is())
|
|
{
|
|
// the arguments : the locale of the current user
|
|
UserInformation aUserInfo;
|
|
Locale aLocale = aUserInfo.getUserLanguage();
|
|
|
|
m_xNumberFormatsSupplier.set( NumberFormatsSupplier::createWithLocale( m_aContext, aLocale ) );
|
|
}
|
|
return m_xNumberFormatsSupplier;
|
|
}
|
|
|
|
void ODatabaseModelImpl::setDocFileLocation( const OUString& i_rLoadedFrom )
|
|
{
|
|
ENSURE_OR_THROW( !i_rLoadedFrom.isEmpty(), "invalid URL" );
|
|
m_sDocFileLocation = i_rLoadedFrom;
|
|
}
|
|
|
|
void ODatabaseModelImpl::setResource( const OUString& i_rDocumentURL, const Sequence< PropertyValue >& _rArgs )
|
|
{
|
|
ENSURE_OR_THROW( !i_rDocumentURL.isEmpty(), "invalid URL" );
|
|
|
|
::comphelper::NamedValueCollection aMediaDescriptor( _rArgs );
|
|
#if OSL_DEBUG_LEVEL > 0
|
|
if ( aMediaDescriptor.has( "SalvagedFile" ) )
|
|
{
|
|
OUString sSalvagedFile( aMediaDescriptor.getOrDefault( "SalvagedFile", OUString() ) );
|
|
// If SalvagedFile is an empty string, this indicates "the document is being recovered, but i_rDocumentURL already
|
|
// is the real document URL, not the temporary document location"
|
|
if ( sSalvagedFile.isEmpty() )
|
|
sSalvagedFile = i_rDocumentURL;
|
|
|
|
OSL_ENSURE( sSalvagedFile == i_rDocumentURL, "ODatabaseModelImpl::setResource: inconsistency!" );
|
|
// nowadays, setResource should only be called with the logical URL of the document
|
|
}
|
|
#endif
|
|
|
|
m_aMediaDescriptor = stripLoadArguments( aMediaDescriptor );
|
|
|
|
impl_switchToLogicalURL( i_rDocumentURL );
|
|
}
|
|
|
|
::comphelper::NamedValueCollection ODatabaseModelImpl::stripLoadArguments( const ::comphelper::NamedValueCollection& _rArguments )
|
|
{
|
|
OSL_ENSURE( !_rArguments.has( "Model" ), "ODatabaseModelImpl::stripLoadArguments: this is suspicious (1)!" );
|
|
OSL_ENSURE( !_rArguments.has( "ViewName" ), "ODatabaseModelImpl::stripLoadArguments: this is suspicious (2)!" );
|
|
|
|
::comphelper::NamedValueCollection aMutableArgs( _rArguments );
|
|
aMutableArgs.remove( "Model" );
|
|
aMutableArgs.remove( "ViewName" );
|
|
return aMutableArgs;
|
|
}
|
|
|
|
void ODatabaseModelImpl::disposeStorages()
|
|
{
|
|
getDocumentStorageAccess()->disposeStorages();
|
|
}
|
|
|
|
Reference< XSingleServiceFactory > ODatabaseModelImpl::createStorageFactory() const
|
|
{
|
|
return StorageFactory::create( m_aContext );
|
|
}
|
|
|
|
void ODatabaseModelImpl::commitRootStorage()
|
|
{
|
|
Reference< XStorage > xStorage( getOrCreateRootStorage() );
|
|
bool bSuccess = commitStorageIfWriteable_ignoreErrors( xStorage );
|
|
SAL_WARN_IF(!bSuccess && xStorage.is(), "dbaccess",
|
|
"ODatabaseModelImpl::commitRootStorage: could not commit the storage!");
|
|
}
|
|
|
|
Reference< XStorage > ODatabaseModelImpl::getOrCreateRootStorage()
|
|
{
|
|
if ( !m_xDocumentStorage.is() )
|
|
{
|
|
Reference< XSingleServiceFactory> xStorageFactory = StorageFactory::create( m_aContext );
|
|
Any aSource;
|
|
aSource = m_aMediaDescriptor.get( "Stream" );
|
|
if ( !aSource.hasValue() )
|
|
aSource = m_aMediaDescriptor.get( "InputStream" );
|
|
if ( !aSource.hasValue() && !m_sDocFileLocation.isEmpty() )
|
|
aSource <<= m_sDocFileLocation;
|
|
// TODO: shouldn't we also check URL?
|
|
|
|
OSL_ENSURE( aSource.hasValue(), "ODatabaseModelImpl::getOrCreateRootStorage: no source to create the storage from!" );
|
|
|
|
if ( aSource.hasValue() )
|
|
{
|
|
Sequence< Any > aStorageCreationArgs(2);
|
|
aStorageCreationArgs[0] = aSource;
|
|
aStorageCreationArgs[1] <<= ElementModes::READWRITE;
|
|
|
|
Reference< XStorage > xDocumentStorage;
|
|
OUString sURL;
|
|
aSource >>= sURL;
|
|
// Don't try to load a meta-URL as-is.
|
|
if (!sURL.startsWithIgnoreAsciiCase("vnd.sun.star.pkg:"))
|
|
{
|
|
try
|
|
{
|
|
xDocumentStorage.set( xStorageFactory->createInstanceWithArguments( aStorageCreationArgs ), UNO_QUERY_THROW );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
m_bDocumentReadOnly = true;
|
|
aStorageCreationArgs[1] <<= ElementModes::READ;
|
|
try
|
|
{
|
|
xDocumentStorage.set( xStorageFactory->createInstanceWithArguments( aStorageCreationArgs ), UNO_QUERY_THROW );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_switchToStorage_throw( xDocumentStorage );
|
|
}
|
|
}
|
|
return m_xDocumentStorage.getTyped();
|
|
}
|
|
|
|
DocumentStorageAccess* ODatabaseModelImpl::getDocumentStorageAccess()
|
|
{
|
|
if ( !m_pStorageAccess.is() )
|
|
{
|
|
m_pStorageAccess = new DocumentStorageAccess( *this );
|
|
}
|
|
return m_pStorageAccess.get();
|
|
}
|
|
|
|
void ODatabaseModelImpl::modelIsDisposing( const bool _wasInitialized, ResetModelAccess )
|
|
{
|
|
m_xModel.clear();
|
|
|
|
// Basic libraries and Dialog libraries are a model facet, though held at this impl class.
|
|
// They automatically dispose themself when the model they belong to is being disposed.
|
|
// So, to not be tempted to do anything with them, again, we reset them.
|
|
m_xBasicLibraries.clear();
|
|
m_xDialogLibraries.clear();
|
|
|
|
m_bDocumentInitialized = _wasInitialized;
|
|
}
|
|
|
|
Reference< XDocumentSubStorageSupplier > ODatabaseModelImpl::getDocumentSubStorageSupplier()
|
|
{
|
|
return getDocumentStorageAccess();
|
|
}
|
|
|
|
bool ODatabaseModelImpl::commitEmbeddedStorage( bool _bPreventRootCommits )
|
|
{
|
|
return getDocumentStorageAccess()->commitEmbeddedStorage( _bPreventRootCommits );
|
|
}
|
|
|
|
bool ODatabaseModelImpl::commitStorageIfWriteable_ignoreErrors( const Reference< XStorage >& _rxStorage )
|
|
{
|
|
bool bSuccess = false;
|
|
try
|
|
{
|
|
bSuccess = tools::stor::commitStorageIfWriteable( _rxStorage );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
return bSuccess;
|
|
}
|
|
|
|
void ODatabaseModelImpl::setModified( bool _bModified )
|
|
{
|
|
if ( isModifyLocked() )
|
|
return;
|
|
|
|
try
|
|
{
|
|
Reference< XModifiable > xModi( m_xModel.get(), UNO_QUERY );
|
|
if ( xModi.is() )
|
|
xModi->setModified( _bModified );
|
|
else
|
|
m_bModified = _bModified;
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
}
|
|
|
|
Reference<XDataSource> ODatabaseModelImpl::getOrCreateDataSource()
|
|
{
|
|
Reference<XDataSource> xDs = m_xDataSource;
|
|
if ( !xDs.is() )
|
|
{
|
|
xDs = new ODatabaseSource(this);
|
|
m_xDataSource = xDs;
|
|
}
|
|
return xDs;
|
|
}
|
|
|
|
Reference< XModel> ODatabaseModelImpl::getModel_noCreate() const
|
|
{
|
|
return m_xModel;
|
|
}
|
|
|
|
Reference< XModel > ODatabaseModelImpl::createNewModel_deliverOwnership()
|
|
{
|
|
Reference< XModel > xModel( m_xModel );
|
|
OSL_PRECOND( !xModel.is(), "ODatabaseModelImpl::createNewModel_deliverOwnership: not to be called if there already is a model!" );
|
|
if ( !xModel.is() )
|
|
{
|
|
bool bHadModelBefore = m_bDocumentInitialized;
|
|
|
|
xModel = ODatabaseDocument::createDatabaseDocument( this, ODatabaseDocument::FactoryAccess() );
|
|
m_xModel = xModel;
|
|
|
|
try
|
|
{
|
|
Reference< XGlobalEventBroadcaster > xModelCollection = theGlobalEventBroadcaster::get( m_aContext );
|
|
xModelCollection->insert( makeAny( xModel ) );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
|
|
if ( bHadModelBefore )
|
|
{
|
|
// do an attachResources
|
|
// In case the document is loaded regularly, this is not necessary, as our loader will do it.
|
|
// However, in case that the document is implicitly created by asking the data source for the document,
|
|
// then nobody would call the doc's attachResource. So, we do it here, to ensure it's in a proper
|
|
// state, fires all events, and so on.
|
|
// #i105505#
|
|
xModel->attachResource( xModel->getURL(), m_aMediaDescriptor.getPropertyValues() );
|
|
}
|
|
}
|
|
return xModel;
|
|
}
|
|
|
|
void SAL_CALL ODatabaseModelImpl::acquire()
|
|
{
|
|
osl_atomic_increment(&m_refCount);
|
|
}
|
|
|
|
void SAL_CALL ODatabaseModelImpl::release()
|
|
{
|
|
if ( osl_atomic_decrement(&m_refCount) == 0 )
|
|
{
|
|
acquire(); // prevent multiple releases
|
|
m_rDBContext.removeFromTerminateListener(*this);
|
|
dispose();
|
|
m_rDBContext.storeTransientProperties(*this);
|
|
if (!m_sDocumentURL.isEmpty())
|
|
m_rDBContext.revokeDatabaseDocument(*this);
|
|
delete this;
|
|
}
|
|
}
|
|
|
|
void ODatabaseModelImpl::commitStorages()
|
|
{
|
|
getDocumentStorageAccess()->commitStorages();
|
|
}
|
|
|
|
Reference< XStorage > ODatabaseModelImpl::getStorage( const ObjectType _eType )
|
|
{
|
|
return getDocumentStorageAccess()->getDocumentSubStorage( getObjectContainerStorageName( _eType ),
|
|
css::embed::ElementModes::READWRITE );
|
|
}
|
|
|
|
const AsciiPropertyValue* ODatabaseModelImpl::getDefaultDataSourceSettings()
|
|
{
|
|
static const AsciiPropertyValue aKnownSettings[] =
|
|
{
|
|
// known JDBC settings
|
|
AsciiPropertyValue( "JavaDriverClass", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "JavaDriverClassPath", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "IgnoreCurrency", makeAny( false ) ),
|
|
// known settings for file-based drivers
|
|
AsciiPropertyValue( "Extension", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "CharSet", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "HeaderLine", makeAny( true ) ),
|
|
AsciiPropertyValue( "FieldDelimiter", makeAny( OUString( "," ) ) ),
|
|
AsciiPropertyValue( "StringDelimiter", makeAny( OUString( "\"" ) ) ),
|
|
AsciiPropertyValue( "DecimalDelimiter", makeAny( OUString( "." ) ) ),
|
|
AsciiPropertyValue( "ThousandDelimiter", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "ShowDeleted", makeAny( false ) ),
|
|
// known ODBC settings
|
|
AsciiPropertyValue( "SystemDriverSettings", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "UseCatalog", makeAny( false ) ),
|
|
AsciiPropertyValue( "TypeInfoSettings", makeAny( Sequence< Any >()) ),
|
|
// settings related to auto increment handling
|
|
AsciiPropertyValue( "AutoIncrementCreation", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "AutoRetrievingStatement", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "IsAutoRetrievingEnabled", makeAny( false ) ),
|
|
// known LDAP driver settings
|
|
AsciiPropertyValue( "HostName", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "PortNumber", makeAny( (sal_Int32)389 ) ),
|
|
AsciiPropertyValue( "BaseDN", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "MaxRowCount", makeAny( (sal_Int32)100 ) ),
|
|
// known MySQLNative driver settings
|
|
AsciiPropertyValue( "LocalSocket", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "NamedPipe", makeAny( OUString() ) ),
|
|
// misc known driver settings
|
|
AsciiPropertyValue( "ParameterNameSubstitution", makeAny( false ) ),
|
|
AsciiPropertyValue( "AddIndexAppendix", makeAny( true ) ),
|
|
AsciiPropertyValue( "IgnoreDriverPrivileges", makeAny( true ) ),
|
|
AsciiPropertyValue( "ImplicitCatalogRestriction", ::cppu::UnoType< OUString >::get() ),
|
|
AsciiPropertyValue( "ImplicitSchemaRestriction", ::cppu::UnoType< OUString >::get() ),
|
|
AsciiPropertyValue( "PrimaryKeySupport", ::cppu::UnoType< sal_Bool >::get() ),
|
|
AsciiPropertyValue( "ShowColumnDescription", makeAny( false ) ),
|
|
// known SDB level settings
|
|
AsciiPropertyValue( "NoNameLengthLimit", makeAny( false ) ),
|
|
AsciiPropertyValue( "AppendTableAliasName", makeAny( false ) ),
|
|
AsciiPropertyValue( "GenerateASBeforeCorrelationName", makeAny( false ) ),
|
|
AsciiPropertyValue( "ColumnAliasInOrderBy", makeAny( true ) ),
|
|
AsciiPropertyValue( "EnableSQL92Check", makeAny( false ) ),
|
|
AsciiPropertyValue( "BooleanComparisonMode", makeAny( BooleanComparisonMode::EQUAL_INTEGER ) ),
|
|
AsciiPropertyValue( "TableTypeFilterMode", makeAny( (sal_Int32)3 ) ),
|
|
AsciiPropertyValue( "RespectDriverResultSetType", makeAny( false ) ),
|
|
AsciiPropertyValue( "UseSchemaInSelect", makeAny( true ) ),
|
|
AsciiPropertyValue( "UseCatalogInSelect", makeAny( true ) ),
|
|
AsciiPropertyValue( "EnableOuterJoinEscape", makeAny( true ) ),
|
|
AsciiPropertyValue( "PreferDosLikeLineEnds", makeAny( false ) ),
|
|
AsciiPropertyValue( "FormsCheckRequiredFields", makeAny( true ) ),
|
|
AsciiPropertyValue( "EscapeDateTime", makeAny( true ) ),
|
|
|
|
// known services to handle database tasks
|
|
AsciiPropertyValue( "TableAlterationServiceName", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "TableRenameServiceName", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "ViewAlterationServiceName", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "ViewAccessServiceName", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "CommandDefinitions", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "Forms", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "Reports", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "KeyAlterationServiceName", makeAny( OUString() ) ),
|
|
AsciiPropertyValue( "IndexAlterationServiceName", makeAny( OUString() ) ),
|
|
|
|
AsciiPropertyValue()
|
|
};
|
|
return aKnownSettings;
|
|
}
|
|
|
|
TContentPtr& ODatabaseModelImpl::getObjectContainer( ObjectType _eType )
|
|
{
|
|
OSL_PRECOND( _eType >= E_FORM && _eType <= E_TABLE, "ODatabaseModelImpl::getObjectContainer: illegal index!" );
|
|
TContentPtr& rContentPtr = m_aContainer[ _eType ];
|
|
|
|
if ( !rContentPtr.get() )
|
|
{
|
|
rContentPtr = TContentPtr( new ODefinitionContainer_Impl );
|
|
rContentPtr->m_pDataSource = this;
|
|
rContentPtr->m_aProps.aTitle = lcl_getContainerStorageName_throw( _eType );
|
|
}
|
|
return rContentPtr;
|
|
}
|
|
|
|
bool ODatabaseModelImpl::adjustMacroMode_AutoReject()
|
|
{
|
|
return m_aMacroMode.adjustMacroMode( nullptr );
|
|
}
|
|
|
|
bool ODatabaseModelImpl::checkMacrosOnLoading()
|
|
{
|
|
Reference< XInteractionHandler > xInteraction;
|
|
xInteraction = m_aMediaDescriptor.getOrDefault( "InteractionHandler", xInteraction );
|
|
return m_aMacroMode.checkMacrosOnLoading( xInteraction );
|
|
}
|
|
|
|
void ODatabaseModelImpl::resetMacroExecutionMode()
|
|
{
|
|
m_aMacroMode = ::sfx2::DocumentMacroMode( *this );
|
|
}
|
|
|
|
Reference< XStorageBasedLibraryContainer > ODatabaseModelImpl::getLibraryContainer( bool _bScript )
|
|
{
|
|
Reference< XStorageBasedLibraryContainer >& rxContainer( _bScript ? m_xBasicLibraries : m_xDialogLibraries );
|
|
if ( rxContainer.is() )
|
|
return rxContainer;
|
|
|
|
Reference< XStorageBasedDocument > xDocument( getModel_noCreate(), UNO_QUERY_THROW );
|
|
// this is only to be called if there already exists a document model - in fact, it is
|
|
// to be called by the document model only
|
|
|
|
try
|
|
{
|
|
Reference< XStorageBasedLibraryContainer > (*Factory)( const Reference< XComponentContext >&, const Reference< XStorageBasedDocument >&)
|
|
= _bScript ? &DocumentScriptLibraryContainer::create : &DocumentDialogLibraryContainer::create;
|
|
|
|
rxContainer.set(
|
|
(*Factory)( m_aContext, xDocument ),
|
|
UNO_QUERY_THROW
|
|
);
|
|
}
|
|
catch( const RuntimeException& )
|
|
{
|
|
throw;
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
throw WrappedTargetRuntimeException(
|
|
OUString(),
|
|
xDocument,
|
|
::cppu::getCaughtException()
|
|
);
|
|
}
|
|
return rxContainer;
|
|
}
|
|
|
|
void ODatabaseModelImpl::storeLibraryContainersTo( const Reference< XStorage >& _rxToRootStorage )
|
|
{
|
|
if ( m_xBasicLibraries.is() )
|
|
m_xBasicLibraries->storeLibrariesToStorage( _rxToRootStorage );
|
|
|
|
if ( m_xDialogLibraries.is() )
|
|
m_xDialogLibraries->storeLibrariesToStorage( _rxToRootStorage );
|
|
}
|
|
|
|
Reference< XStorage > ODatabaseModelImpl::switchToStorage( const Reference< XStorage >& _rxNewRootStorage )
|
|
{
|
|
if ( !_rxNewRootStorage.is() )
|
|
throw IllegalArgumentException();
|
|
|
|
return impl_switchToStorage_throw( _rxNewRootStorage );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
void lcl_modifyListening( ::sfx2::IModifiableDocument& _rDocument,
|
|
const Reference< XStorage >& _rxStorage, ::rtl::Reference< ::sfx2::DocumentStorageModifyListener >& _inout_rListener,
|
|
comphelper::SolarMutex& _rMutex, bool _bListen )
|
|
{
|
|
Reference< XModifiable > xModify( _rxStorage, UNO_QUERY );
|
|
OSL_ENSURE( xModify.is() || !_rxStorage.is(), "lcl_modifyListening: storage can't notify us!" );
|
|
|
|
if ( xModify.is() && !_bListen && _inout_rListener.is() )
|
|
{
|
|
xModify->removeModifyListener( _inout_rListener.get() );
|
|
}
|
|
|
|
if ( _inout_rListener.is() )
|
|
{
|
|
_inout_rListener->dispose();
|
|
_inout_rListener = nullptr;
|
|
}
|
|
|
|
if ( xModify.is() && _bListen )
|
|
{
|
|
_inout_rListener = new ::sfx2::DocumentStorageModifyListener( _rDocument, _rMutex );
|
|
xModify->addModifyListener( _inout_rListener.get() );
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace
|
|
{
|
|
void lcl_rebaseScriptStorage_throw( const Reference< XStorageBasedLibraryContainer >& _rxContainer,
|
|
const Reference< XStorage >& _rxNewRootStorage )
|
|
{
|
|
if ( _rxContainer.is() )
|
|
{
|
|
if ( _rxNewRootStorage.is() )
|
|
_rxContainer->setRootStorage( _rxNewRootStorage );
|
|
// else
|
|
// TODO: what to do here? dispose the container?
|
|
}
|
|
}
|
|
}
|
|
|
|
Reference< XStorage > ODatabaseModelImpl::impl_switchToStorage_throw( const Reference< XStorage >& _rxNewRootStorage )
|
|
{
|
|
// stop listening for modifications at the old storage
|
|
lcl_modifyListening( *this, m_xDocumentStorage.getTyped(), m_pStorageModifyListener, m_aMutexFacade, false );
|
|
|
|
// set new storage
|
|
m_xDocumentStorage.reset( _rxNewRootStorage, SharedStorage::TakeOwnership );
|
|
|
|
// start listening for modifications
|
|
lcl_modifyListening( *this, m_xDocumentStorage.getTyped(), m_pStorageModifyListener, m_aMutexFacade, true );
|
|
|
|
// forward new storage to Basic and Dialog library containers
|
|
lcl_rebaseScriptStorage_throw( m_xBasicLibraries, m_xDocumentStorage.getTyped() );
|
|
lcl_rebaseScriptStorage_throw( m_xDialogLibraries, m_xDocumentStorage.getTyped() );
|
|
|
|
m_bReadOnly = !tools::stor::storageIsWritable_nothrow( m_xDocumentStorage.getTyped() );
|
|
// TODO: our data source, if it exists, must broadcast the change of its ReadOnly property
|
|
|
|
return m_xDocumentStorage.getTyped();
|
|
}
|
|
|
|
void ODatabaseModelImpl::impl_switchToLogicalURL( const OUString& i_rDocumentURL )
|
|
{
|
|
if ( i_rDocumentURL == m_sDocumentURL )
|
|
return;
|
|
|
|
const OUString sOldURL( m_sDocumentURL );
|
|
// update our name, if necessary
|
|
if ( ( m_sName == m_sDocumentURL ) // our name is our old URL
|
|
|| ( m_sName.isEmpty() ) // we do not have a name, yet (i.e. are not registered at the database context)
|
|
)
|
|
{
|
|
INetURLObject aURL( i_rDocumentURL );
|
|
if ( aURL.GetProtocol() != INetProtocol::NotValid )
|
|
{
|
|
m_sName = i_rDocumentURL;
|
|
// TODO: our data source must broadcast the change of the Name property
|
|
}
|
|
}
|
|
|
|
// remember URL
|
|
m_sDocumentURL = i_rDocumentURL;
|
|
|
|
// update our location, if necessary
|
|
if ( m_sDocFileLocation.isEmpty() )
|
|
m_sDocFileLocation = m_sDocumentURL;
|
|
|
|
// register at the database context, or change registration
|
|
if (!sOldURL.isEmpty())
|
|
m_rDBContext.databaseDocumentURLChange( sOldURL, m_sDocumentURL );
|
|
else
|
|
m_rDBContext.registerDatabaseDocument( *this );
|
|
}
|
|
|
|
OUString ODatabaseModelImpl::getObjectContainerStorageName( const ObjectType _eType )
|
|
{
|
|
return lcl_getContainerStorageName_throw( _eType );
|
|
}
|
|
|
|
sal_Int16 ODatabaseModelImpl::getCurrentMacroExecMode() const
|
|
{
|
|
sal_Int16 nCurrentMode = MacroExecMode::NEVER_EXECUTE;
|
|
try
|
|
{
|
|
nCurrentMode = m_aMediaDescriptor.getOrDefault( "MacroExecutionMode", nCurrentMode );
|
|
}
|
|
catch( const Exception& )
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION();
|
|
}
|
|
return nCurrentMode;
|
|
}
|
|
|
|
void ODatabaseModelImpl::setCurrentMacroExecMode( sal_uInt16 nMacroMode )
|
|
{
|
|
m_aMediaDescriptor.put( "MacroExecutionMode", nMacroMode );
|
|
}
|
|
|
|
OUString ODatabaseModelImpl::getDocumentLocation() const
|
|
{
|
|
return getURL();
|
|
// formerly, we returned getDocFileLocation here, which is the location of the file from which we
|
|
// recovered the "real" document.
|
|
// However, during CWS autorecovery evolving, we clarified (with MAV/MT) the role of XModel::getURL and
|
|
// XStorable::getLocation. In this course, we agreed that for a macro security check, the *document URL*
|
|
// (not the recovery file URL) is to be used: The recovery file lies in the backup folder, and by definition,
|
|
// this folder is considered to be secure. So, the document URL needs to be used to decide about the security.
|
|
}
|
|
|
|
ODatabaseModelImpl::EmbeddedMacros ODatabaseModelImpl::determineEmbeddedMacros()
|
|
{
|
|
if ( !m_aEmbeddedMacros )
|
|
{
|
|
if ( ::sfx2::DocumentMacroMode::storageHasMacros( getOrCreateRootStorage() ) )
|
|
{
|
|
m_aEmbeddedMacros.reset( eDocumentWideMacros );
|
|
}
|
|
else if ( lcl_hasObjectsWithMacros_nothrow( *this, E_FORM )
|
|
|| lcl_hasObjectsWithMacros_nothrow( *this, E_REPORT )
|
|
)
|
|
{
|
|
m_aEmbeddedMacros.reset( eSubDocumentMacros );
|
|
}
|
|
else
|
|
{
|
|
m_aEmbeddedMacros.reset( eNoMacros );
|
|
}
|
|
}
|
|
return *m_aEmbeddedMacros;
|
|
}
|
|
|
|
bool ODatabaseModelImpl::documentStorageHasMacros() const
|
|
{
|
|
const_cast< ODatabaseModelImpl* >( this )->determineEmbeddedMacros();
|
|
return ( *m_aEmbeddedMacros != eNoMacros );
|
|
}
|
|
|
|
Reference< XEmbeddedScripts > ODatabaseModelImpl::getEmbeddedDocumentScripts() const
|
|
{
|
|
return Reference< XEmbeddedScripts >( getModel_noCreate(), UNO_QUERY );
|
|
}
|
|
|
|
SignatureState ODatabaseModelImpl::getScriptingSignatureState()
|
|
{
|
|
// no support for signatures at the moment
|
|
return SignatureState::NOSIGNATURES;
|
|
}
|
|
|
|
bool ODatabaseModelImpl::hasTrustedScriptingSignature( bool /*bAllowUIToAddAuthor*/ )
|
|
{
|
|
// no support for signatures at the moment
|
|
return false;
|
|
}
|
|
|
|
void ODatabaseModelImpl::storageIsModified()
|
|
{
|
|
setModified( true );
|
|
}
|
|
|
|
ModelDependentComponent::ModelDependentComponent( const ::rtl::Reference< ODatabaseModelImpl >& _model )
|
|
:m_pImpl( _model )
|
|
,m_aMutex( _model->getSharedMutex() )
|
|
{
|
|
}
|
|
|
|
ModelDependentComponent::~ModelDependentComponent()
|
|
{
|
|
}
|
|
|
|
} // namespace dbaccess
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|