ModelImpl.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include "ContentHelper.hxx"
#include "documentevents.hxx"
 
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/XPropertyBag.hpp>
#include <com/sun/star/document/XDocumentSubStorageSupplier.hpp>
#include <com/sun/star/embed/XStorage.hpp>
#include <com/sun/star/frame/XModel.hpp>
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
#include <com/sun/star/script/XStorageBasedLibraryContainer.hpp>
#include <com/sun/star/sdbc/XDataSource.hpp>
#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
 
#include <comphelper/namedvaluecollection.hxx>
#include <cppuhelper/weakref.hxx>
#include <vcl/svapp.hxx>
#include <sfx2/docmacromode.hxx>
#include <sfx2/docstoragemodifylistener.hxx>
#include <unotools/sharedunocomponent.hxx>
#include <rtl/ref.hxx>
#include <o3tl/enumarray.hxx>
 
namespace comphelper
{
    class NamedValueCollection;
}
 
namespace dbaccess
{
 
typedef std::vector< css::uno::WeakReference< css::sdbc::XConnection > > OWeakConnectionArray;
 
struct AsciiPropertyValue
{
    // note: the canonic member order would be AsciiName / DefaultValue, but
    // this crashes on unxlngi6.pro, since there's a bug which somehow results in
    // getDefaultDataSourceSettings returning corrupted Any instances then.
    css::uno::Any          DefaultValue;
    const char*            AsciiName;
    const css::uno::Type&  ValueType;
 
    AsciiPropertyValue()
        :DefaultValue( )
        ,AsciiName( nullptr )
        ,ValueType( ::cppu::UnoType<void>::get() )
    {
    }
 
    AsciiPropertyValue( const char* _pAsciiName, const css::uno::Any& _rDefaultValue )
        :DefaultValue( _rDefaultValue )
        ,AsciiName( _pAsciiName )
        ,ValueType( _rDefaultValue.getValueType() )
    {
        OSL_ENSURE( ValueType.getTypeClass() != css::uno::TypeClass_VOID,
            "AsciiPropertyValue::AsciiPropertyValue: NULL values not allowed here, use the other CTOR for this!" );
    }
    AsciiPropertyValue( const char* _pAsciiName, const css::uno::Type& _rValeType )
        :DefaultValue()
        ,AsciiName( _pAsciiName )
        ,ValueType( _rValeType )
    {
        OSL_ENSURE( ValueType.getTypeClass() != css::uno::TypeClass_VOID,
            "AsciiPropertyValue::AsciiPropertyValue: VOID property values not supported!" );
    }
};
 
class ODatabaseContext;
class OSharedConnectionManager;
 
// ODatabaseModelImpl
typedef ::utl::SharedUNOComponent< css::embed::XStorage >  SharedStorage;
 
class ODatabaseContext;
class DocumentStorageAccess;
class OSharedConnectionManager;
 
class ODatabaseModelImpl    :public ::sfx2::IMacroDocumentAccess
                            ,public ::sfx2::IModifiableDocument
{
public:
 
    enum class ObjectType
    {
        Form   = 0,
        Report = 1,
        Query  = 2,
        Table = 3,
        LAST = Table
    };
 
    enum class EmbeddedMacros
    {
        // the database document (storage) itself contains macros
        DocumentWide,
        // there are sub document( storage)s containing macros
        SubDocument,
        // there are no known macro( storage)s
        NONE
    };
 
private:
    css::uno::WeakReference< css::frame::XModel >                     m_xModel;
    css::uno::WeakReference< css::sdbc::XDataSource >                 m_xDataSource;
 
    rtl::Reference<DocumentStorageAccess>                             m_pStorageAccess;
    o3tl::enumarray< ObjectType, TContentPtr >                        m_aContainer;   // one for each ObjectType
    ::sfx2::DocumentMacroMode                                         m_aMacroMode;
    sal_Int16                                                         m_nImposedMacroExecMode;
 
    css::uno::Reference< css::script::XStorageBasedLibraryContainer > m_xBasicLibraries;
    css::uno::Reference< css::script::XStorageBasedLibraryContainer > m_xDialogLibraries;
 
    SharedStorage                                                     m_xDocumentStorage;
    ::rtl::Reference< ::sfx2::DocumentStorageModifyListener >         m_pStorageModifyListener;
    ODatabaseContext&                                                 m_rDBContext;
    DocumentEventsData                                                m_aDocumentEvents;
 
    ::comphelper::NamedValueCollection                                m_aMediaDescriptor;
    OUString                                                          m_sDocFileLocation;
 
    oslInterlockedCount                                 m_refCount;
 
    ::std::optional< EmbeddedMacros >                 m_aEmbeddedMacros;
 
    bool                                                m_bModificationLock;
 
    bool                                                m_bDocumentInitialized;
 
    OUString                                     m_sDocumentURL;
 
    SignatureState m_nScriptingSignatureState;
 
public:
    OWeakConnectionArray                                                        m_aConnections;
    const css::uno::Reference< css::uno::XComponentContext >  m_aContext;
 
public:
    css::uno::WeakReference< css::container::XNameAccess >    m_xCommandDefinitions;
    css::uno::WeakReference< css::container::XNameAccess >    m_xTableDefinitions;
 
    css::uno::Reference< css::util::XNumberFormatsSupplier >
                                                              m_xNumberFormatsSupplier;
    OUString                                     m_sConnectURL;
    OUString                                     m_sName;        // transient, our creator has to tell us the title
    OUString                                     m_sUser;
    OUString                                     m_aPassword;    // transient !
    OUString                                     m_sFailedPassword;
    css::uno::Sequence< css::beans::PropertyValue>
                                                    m_aLayoutInformation;
    sal_Int32                                       m_nLoginTimeout;
    bool                                            m_bReadOnly : 1;
    bool                                            m_bPasswordRequired : 1;
    bool                                            m_bSuppressVersionColumns : 1;
    bool                                            m_bModified : 1;
    bool                                            m_bDocumentReadOnly : 1;
    bool                                            m_bMacroCallsSeenWhileLoading : 1;
    css::uno::Reference< css::beans::XPropertyBag >
                                                        m_xSettings;
    css::uno::Sequence< OUString >                      m_aTableFilter;
    css::uno::Sequence< OUString >                      m_aTableTypeFilter;
    OSharedConnectionManager*                           m_pSharedConnectionManager;
    css::uno::Reference< css::lang::XEventListener >
                                                        m_xSharedConnectionManager;
    css::uno::Reference<css::awt::XWindow>
                                                        m_xDialogParent;
    sal_uInt16                                          m_nControllerLockCount;
 
    void reset();
 
    bool isEmbeddedDatabase() const { return m_sConnectURL.startsWith("sdbc:embedded:"); }
 
    bool        commitEmbeddedStorage( bool _bPreventRootCommits = false );
 
    void commitStorages();
 
    ODatabaseModelImpl(
        const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
        ODatabaseContext& _pDBContext
    );
    virtual ~ODatabaseModelImpl();
 
    ODatabaseModelImpl(
        OUString _sRegistrationName,
        const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
        ODatabaseContext& _rDBContext
        );
 
    // XEventListener
    void disposing( const css::lang::EventObject& Source );
 
    void setModified( bool bModified );
 
    void dispose();
 
    const OUString& getURL() const               { return m_sDocumentURL;     }
    const OUString& getDocFileLocation() const   { return m_sDocFileLocation; }
 
    css::uno::Reference< css::embed::XStorage >
            getStorage( const ObjectType _eType );
 
// helper
    const css::uno::Reference< css::util::XNumberFormatsSupplier >&
            getNumberFormatsSupplier();
 
    DocumentEventsData&
            getDocumentEvents() { return m_aDocumentEvents; }
 
    const ::comphelper::NamedValueCollection&
            getMediaDescriptor() const { return m_aMediaDescriptor; }
 
    void    setResource(
                const OUString& _rURL,
                const css::uno::Sequence< css::beans::PropertyValue >& _rArgs
            );
    void    setDocFileLocation(
                const OUString& i_rLoadedFrom
            );
 
    static ::comphelper::NamedValueCollection
            stripLoadArguments( const ::comphelper::NamedValueCollection& _rArguments );
 
// other stuff
 
    // disposes all elements in m_aStorages, and clears it
    void    disposeStorages();
 
    css::uno::Reference< css::lang::XSingleServiceFactory >
            createStorageFactory() const;
 
    void    commitRootStorage();
 
    bool    commitStorageIfWriteable_ignoreErrors(
                const css::uno::Reference< css::embed::XStorage >& _rxStorage
            );
 
    void clearConnections();
 
    css::uno::Reference< css::embed::XStorage > const & getOrCreateRootStorage();
    css::uno::Reference< css::embed::XStorage > const & getRootStorage() const { return m_xDocumentStorage.getTyped(); }
    void resetRootStorage() { impl_switchToStorage_throw( nullptr ); }
 
    css::uno::Reference< css::sdbc::XDataSource> getOrCreateDataSource();
 
    css::uno::Reference< css::frame::XModel > getModel_noCreate() const;
 
    css::uno::Reference< css::frame::XModel > createNewModel_deliverOwnership();
 
    struct ResetModelAccess { friend class ODatabaseDocument; private: ResetModelAccess() { } };
 
    void    modelIsDisposing( const bool _wasInitialized, ResetModelAccess );
 
    bool    hadInitializedDocument() const { return m_bDocumentInitialized; }
 
    DocumentStorageAccess*
            getDocumentStorageAccess();
 
    css::uno::Reference< css::document::XDocumentSubStorageSupplier >
            getDocumentSubStorageSupplier();
 
    void acquire();
 
    void release();
 
    static const AsciiPropertyValue* getDefaultDataSourceSettings();
 
    TContentPtr&    getObjectContainer( const ObjectType _eType );
 
    static OUString
                    getObjectContainerStorageName( const ObjectType _eType );
 
    static bool     objectHasMacros(
                        const css::uno::Reference< css::embed::XStorage >& _rxContainerStorage,
                        const OUString& _rPersistentName
                    );
 
    EmbeddedMacros  determineEmbeddedMacros();
 
    bool            checkMacrosOnLoading();
 
    bool            adjustMacroMode_AutoReject();
 
    void            resetMacroExecutionMode();
 
    css::uno::Reference< css::script::XStorageBasedLibraryContainer >
            getLibraryContainer( bool _bScript );
 
    void    storeLibraryContainersTo( const css::uno::Reference< css::embed::XStorage >& _rxToRootStorage );
 
    css::uno::Reference< css::embed::XStorage >
            switchToStorage(
                const css::uno::Reference< css::embed::XStorage >& _rxNewRootStorage
            );
 
    sal_Int16       getImposedMacroExecMode() const
    {
        return m_nImposedMacroExecMode;
    }
    void            setImposedMacroExecMode( const sal_Int16 _nMacroMode )
    {
        m_nImposedMacroExecMode = _nMacroMode;
    }
 
public:
    // IMacroDocumentAccess overridables
    virtual sal_Int16 getCurrentMacroExecMode() const override;
    virtual void setCurrentMacroExecMode( sal_uInt16 ) override;
    virtual OUString getDocumentLocation() const override;
    virtual bool documentStorageHasMacros() const override;
    virtual bool macroCallsSeenWhileLoading() const override;
    virtual css::uno::Reference< css::document::XEmbeddedScripts > getEmbeddedDocumentScripts() const override;
    virtual SignatureState getScriptingSignatureState() override;
    virtual bool hasTrustedScriptingSignature( bool bAllowUIToAddAuthor ) override;
 
    // IModifiableDocument
    virtual void storageIsModified() override;
 
    // don't use directly, use the ModifyLock class instead
    void    lockModify()              { m_bModificationLock = true; }
    void    unlockModify()            { m_bModificationLock = false; }
    bool    isModifyLocked() const    { return m_bModificationLock; }
 
    weld::Window* GetFrameWeld();
 
private:
    void    impl_construct_nothrow();
    css::uno::Reference< css::embed::XStorage > const &
            impl_switchToStorage_throw( const css::uno::Reference< css::embed::XStorage >& _rxNewRootStorage );
 
    void    impl_switchToLogicalURL(
                const OUString& i_rDocumentURL
            );
 
};
 
class ModelDependentComponent
{
protected:
    ::rtl::Reference< ODatabaseModelImpl >  m_pImpl;
    ::osl::Mutex m_aMutex; // only use this to init WeakComponentImplHelper
 
protected:
    explicit ModelDependentComponent( ::rtl::Reference< ODatabaseModelImpl > _model );
    virtual ~ModelDependentComponent();
 
    virtual css::uno::Reference< css::uno::XInterface > getThis() const = 0;
 
    ::osl::Mutex& getMutex()
    {
        return m_aMutex;
    }
 
public:
    void checkDisposed() const
    {
        if ( !m_pImpl.is() )
            throw css::lang::DisposedException( "Component is already disposed.", getThis() );
    }
 
    void lockModify()
    {
        m_pImpl->lockModify();
    }
 
    void unlockModify()
    {
        m_pImpl->unlockModify();
    }
};
 
class ModifyLock
{
public:
    explicit ModifyLock( ModelDependentComponent& _component )
        :m_rComponent( _component )
    {
        m_rComponent.lockModify();
    }
 
    ~ModifyLock()
    {
        m_rComponent.unlockModify();
    }
 
private:
    ModelDependentComponent&    m_rComponent;
};
 
class ModelMethodGuard
{
private:
    // to avoid deadlocks, lock SolarMutex
    SolarMutexResettableGuard m_SolarGuard;
 
public:
    explicit ModelMethodGuard( const ModelDependentComponent& _component )
    {
        _component.checkDisposed();
    }
 
    void clear()
    {
        // note: this only releases *once* so may still be locked
        m_SolarGuard.clear();
    }
 
    void reset()
    {
        m_SolarGuard.reset();
    }
};
 
}   // namespace dbaccess
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */