dbaccess/source/core/inc/ModelImpl.hxx

   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 #pragma once
  21
  22 #include "ContentHelper.hxx"
  23 #include "documentevents.hxx"
  24
  25 #include <com/sun/star/beans/PropertyValue.hpp>
  26 #include <com/sun/star/beans/XPropertyBag.hpp>
  27 #include <com/sun/star/document/XDocumentSubStorageSupplier.hpp>
  28 #include <com/sun/star/embed/XStorage.hpp>
  29 #include <com/sun/star/frame/XModel.hpp>
  30 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  31 #include <com/sun/star/script/XStorageBasedLibraryContainer.hpp>
  32 #include <com/sun/star/sdbc/XDataSource.hpp>
  33 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
  34
  35 #include <comphelper/namedvaluecollection.hxx>
  36 #include <cppuhelper/weakref.hxx>
  37 #include <vcl/svapp.hxx>
  38 #include <sfx2/docmacromode.hxx>
  39 #include <sfx2/docstoragemodifylistener.hxx>
  40 #include <unotools/sharedunocomponent.hxx>
  41 #include <rtl/ref.hxx>
  42 #include <o3tl/enumarray.hxx>
  43
  44 namespace comphelper
  45 {
  46     class NamedValueCollection;
  47 }
  48
  49 namespace dbaccess
  50 {
  51
  52 typedef std::vector< css::uno::WeakReference< css::sdbc::XConnection > > OWeakConnectionArray;
  53
  54 struct AsciiPropertyValue
  55 {
  56     // note: the canonic member order would be AsciiName / DefaultValue, but
  57     // this crashes on unxlngi6.pro, since there's a bug which somehow results in
  58     // getDefaultDataSourceSettings returning corrupted Any instances then.
  59     css::uno::Any          DefaultValue;
  60     const char*            AsciiName;
  61     const css::uno::Type&  ValueType;
  62
  63     AsciiPropertyValue()
  64         :DefaultValue( )
  65         ,AsciiName( nullptr )
  66         ,ValueType( ::cppu::UnoType<void>::get() )
  67     {
  68     }
  69
  70     AsciiPropertyValue( const char* _pAsciiName, const css::uno::Any& _rDefaultValue )
  71         :DefaultValue( _rDefaultValue )
  72         ,AsciiName( _pAsciiName )
  73         ,ValueType( _rDefaultValue.getValueType() )
  74     {
  75         OSL_ENSURE( ValueType.getTypeClass() != css::uno::TypeClass_VOID,
  76             "AsciiPropertyValue::AsciiPropertyValue: NULL values not allowed here, use the other CTOR for this!" );
  77     }
  78     AsciiPropertyValue( const char* _pAsciiName, const css::uno::Type& _rValeType )
  79         :DefaultValue()
  80         ,AsciiName( _pAsciiName )
  81         ,ValueType( _rValeType )
  82     {
  83         OSL_ENSURE( ValueType.getTypeClass() != css::uno::TypeClass_VOID,
  84             "AsciiPropertyValue::AsciiPropertyValue: VOID property values not supported!" );
  85     }
  86 };
  87
  88 class ODatabaseContext;
  89 class OSharedConnectionManager;
  90
  91 // ODatabaseModelImpl
  92 typedef ::utl::SharedUNOComponent< css::embed::XStorage >  SharedStorage;
  93
  94 class ODatabaseContext;
  95 class DocumentStorageAccess;
  96 class OSharedConnectionManager;
  97
  98 class ODatabaseModelImpl    :public ::sfx2::IMacroDocumentAccess
  99                             ,public ::sfx2::IModifiableDocument
 100 {
 101 public:
 102
 103     enum class ObjectType
 104     {
 105         Form   = 0,
 106         Report = 1,
 107         Query  = 2,
 108         Table = 3,
 109         LAST = Table
 110     };
 111
 112     enum class EmbeddedMacros
 113     {
 114         // the database document (storage) itself contains macros
 115         DocumentWide,
 116         // there are sub document( storage)s containing macros
 117         SubDocument,
 118         // there are no known macro( storage)s
 119         NONE
 120     };
 121
 122 private:
 123     css::uno::WeakReference< css::frame::XModel >                     m_xModel;
 124     css::uno::WeakReference< css::sdbc::XDataSource >                 m_xDataSource;
 125
 126     rtl::Reference<DocumentStorageAccess>                             m_pStorageAccess;
 127     o3tl::enumarray< ObjectType, TContentPtr >                        m_aContainer;   // one for each ObjectType
 128     ::sfx2::DocumentMacroMode                                         m_aMacroMode;
 129     sal_Int16                                                         m_nImposedMacroExecMode;
 130
 131     css::uno::Reference< css::script::XStorageBasedLibraryContainer > m_xBasicLibraries;
 132     css::uno::Reference< css::script::XStorageBasedLibraryContainer > m_xDialogLibraries;
 133
 134     SharedStorage                                                     m_xDocumentStorage;
 135     ::rtl::Reference< ::sfx2::DocumentStorageModifyListener >         m_pStorageModifyListener;
 136     ODatabaseContext&                                                 m_rDBContext;
 137     DocumentEventsData                                                m_aDocumentEvents;
 138
 139     ::comphelper::NamedValueCollection                                m_aMediaDescriptor;
 140     /// the URL the document was loaded from
 141     OUString                                                          m_sDocFileLocation;
 142
 143     oslInterlockedCount                                 m_refCount;
 144
 145     /// do we have any object (forms/reports) which contains macros?
 146     ::std::optional< EmbeddedMacros >                 m_aEmbeddedMacros;
 147
 148     /// true if setting the Modified flag of the document is currently locked
 149     bool                                                m_bModificationLock;
 150
 151     /// true if and only if a database document existed previously (though meanwhile disposed), and was already initialized
 152     bool                                                m_bDocumentInitialized;
 153
 154     /** the URL which the document should report as its URL
 155
 156         This might differ from ->m_sDocFileLocation in case the document was loaded
 157         as part of a crash recovery process. In this case, ->m_sDocFileLocation points to
 158         the temporary file where the DB had been saved to, after a crash.
 159         ->m_sDocumentURL then is the URL of the document which actually had
 160         been recovered.
 161     */
 162     OUString                                     m_sDocumentURL;
 163
 164     SignatureState m_nScriptingSignatureState;
 165
 166 public:
 167     OWeakConnectionArray                                                        m_aConnections;
 168     const css::uno::Reference< css::uno::XComponentContext >  m_aContext;
 169
 170 public:
 171     css::uno::WeakReference< css::container::XNameAccess >    m_xCommandDefinitions;
 172     css::uno::WeakReference< css::container::XNameAccess >    m_xTableDefinitions;
 173
 174     css::uno::Reference< css::util::XNumberFormatsSupplier >
 175                                                               m_xNumberFormatsSupplier;
 176     OUString                                     m_sConnectURL;
 177     OUString                                     m_sName;        // transient, our creator has to tell us the title
 178     OUString                                     m_sUser;
 179     OUString                                     m_aPassword;    // transient !
 180     OUString                                     m_sFailedPassword;
 181     css::uno::Sequence< css::beans::PropertyValue>
 182                                                     m_aLayoutInformation;
 183     sal_Int32                                       m_nLoginTimeout;
 184     bool                                            m_bReadOnly : 1;
 185     bool                                            m_bPasswordRequired : 1;
 186     bool                                            m_bSuppressVersionColumns : 1;
 187     bool                                            m_bModified : 1;
 188     bool                                            m_bDocumentReadOnly : 1;
 189     bool                                            m_bMacroCallsSeenWhileLoading : 1;
 190     css::uno::Reference< css::beans::XPropertyBag >
 191                                                         m_xSettings;
 192     css::uno::Sequence< OUString >                      m_aTableFilter;
 193     css::uno::Sequence< OUString >                      m_aTableTypeFilter;
 194     OSharedConnectionManager*                           m_pSharedConnectionManager;
 195     css::uno::Reference< css::lang::XEventListener >
 196                                                         m_xSharedConnectionManager;
 197     css::uno::Reference<css::awt::XWindow>
 198                                                         m_xDialogParent;
 199     sal_uInt16                                          m_nControllerLockCount;
 200
 201     void reset();
 202
 203     /** determines whether the database document has an embedded data storage
 204     */
 205     bool isEmbeddedDatabase() const { return m_sConnectURL.startsWith("sdbc:embedded:"); }
 206
 207     /** stores the embedded storage ("database")
 208
 209         @param _bPreventRootCommits
 210             Normally, committing the embedded storage results in also committing the root storage
 211             - this is an automatism for data safety reasons.
 212             If you pass <TRUE/> here, committing the root storage is prevented for this particular
 213             call.
 214         @return <TRUE/> if the storage could be committed, otherwise <FALSE/>
 215     */
 216     bool        commitEmbeddedStorage( bool _bPreventRootCommits = false );
 217
 218     /// commits all sub storages
 219     void commitStorages();
 220
 221     ODatabaseModelImpl(
 222         const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
 223         ODatabaseContext& _pDBContext
 224     );
 225     virtual ~ODatabaseModelImpl();
 226
 227     ODatabaseModelImpl(
 228         OUString _sRegistrationName,
 229         const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
 230         ODatabaseContext& _rDBContext
 231         );
 232
 233     // XEventListener
 234     /// @throws css::uno::RuntimeException
 235     void disposing( const css::lang::EventObject& Source );
 236
 237     void setModified( bool bModified );
 238
 239     void dispose();
 240
 241     const OUString& getURL() const               { return m_sDocumentURL;     }
 242     const OUString& getDocFileLocation() const   { return m_sDocFileLocation; }
 243
 244     css::uno::Reference< css::embed::XStorage >
 245             getStorage( const ObjectType _eType );
 246
 247 // helper
 248     const css::uno::Reference< css::util::XNumberFormatsSupplier >&
 249             getNumberFormatsSupplier();
 250
 251     DocumentEventsData&
 252             getDocumentEvents() { return m_aDocumentEvents; }
 253
 254     const ::comphelper::NamedValueCollection&
 255             getMediaDescriptor() const { return m_aMediaDescriptor; }
 256
 257     void    setResource(
 258                 const OUString& _rURL,
 259                 const css::uno::Sequence< css::beans::PropertyValue >& _rArgs
 260             );
 261     void    setDocFileLocation(
 262                 const OUString& i_rLoadedFrom
 263             );
 264
 265     static ::comphelper::NamedValueCollection
 266             stripLoadArguments( const ::comphelper::NamedValueCollection& _rArguments );
 267
 268 // other stuff
 269
 270     // disposes all elements in m_aStorages, and clears it
 271     void    disposeStorages();
 272
 273     /// creates a ->css::embed::StorageFactory
 274     css::uno::Reference< css::lang::XSingleServiceFactory >
 275             createStorageFactory() const;
 276
 277     /// commits our storage
 278     void    commitRootStorage();
 279
 280     /// commits a given storage if it's not readonly, ignoring (but asserting) all errors
 281     bool    commitStorageIfWriteable_ignoreErrors(
 282                 const css::uno::Reference< css::embed::XStorage >& _rxStorage
 283             );
 284
 285     void clearConnections();
 286
 287     css::uno::Reference< css::embed::XStorage > const & getOrCreateRootStorage();
 288     css::uno::Reference< css::embed::XStorage > const & getRootStorage() const { return m_xDocumentStorage.getTyped(); }
 289     void resetRootStorage() { impl_switchToStorage_throw( nullptr ); }
 290
 291     /** returns the data source. If it doesn't exist it will be created
 292     */
 293     css::uno::Reference< css::sdbc::XDataSource> getOrCreateDataSource();
 294
 295     /** returns the model, if there already exists one
 296     */
 297     css::uno::Reference< css::frame::XModel > getModel_noCreate() const;
 298
 299     /** returns a new ->ODatabaseDocument
 300
 301         @precond
 302             No ->ODatabaseDocument exists so far
 303
 304         @seealso
 305             getModel_noCreate
 306     */
 307     css::uno::Reference< css::frame::XModel > createNewModel_deliverOwnership();
 308
 309     struct ResetModelAccess { friend class ODatabaseDocument; private: ResetModelAccess() { } };
 310
 311     /** resets the model to NULL
 312
 313         Only to be called when the model is being disposed
 314     */
 315     void    modelIsDisposing( const bool _wasInitialized, ResetModelAccess );
 316
 317     bool    hadInitializedDocument() const { return m_bDocumentInitialized; }
 318
 319     DocumentStorageAccess*
 320             getDocumentStorageAccess();
 321
 322     css::uno::Reference< css::document::XDocumentSubStorageSupplier >
 323             getDocumentSubStorageSupplier();
 324
 325     void acquire();
 326
 327     void release();
 328
 329     /// returns all known data source settings, including their default values
 330     static const AsciiPropertyValue* getDefaultDataSourceSettings();
 331
 332     /** retrieves the requested container of objects (forms/reports/tables/queries)
 333     */
 334     TContentPtr&    getObjectContainer( const ObjectType _eType );
 335
 336     /** returns the name of the storage which is used to stored objects of the given type, if applicable
 337     */
 338     static OUString
 339                     getObjectContainerStorageName( const ObjectType _eType );
 340
 341     /** determines whether a given object storage contains macros
 342     */
 343     static bool     objectHasMacros(
 344                         const css::uno::Reference< css::embed::XStorage >& _rxContainerStorage,
 345                         const OUString& _rPersistentName
 346                     );
 347
 348     /** determines which kind of embedded macros are present in the document
 349     */
 350     EmbeddedMacros  determineEmbeddedMacros();
 351
 352     /** checks our document's macro execution mode, using the interaction handler as supplied with our
 353         load arguments
 354     */
 355     bool            checkMacrosOnLoading();
 356
 357     /** adjusts our document's macro execution mode, without using any UI, assuming the user
 358         would reject execution of macros, if she would have been asked.
 359
 360         If checkMacrosOnLoading has been called before (and thus the macro execution mode
 361         is already adjusted), then the current execution mode is simply returned.
 362
 363         @return
 364             whether or not macro execution is allowed
 365     */
 366     bool            adjustMacroMode_AutoReject();
 367
 368     /** resets our macro execute mode, so next time  the checkMacrosOnLoading is called, it will
 369         behave as if it has never been called before
 370     */
 371     void            resetMacroExecutionMode();
 372
 373     /** ensures that ->m_xBasicLibraries resp. m_xDialogLibraries exists
 374
 375         @return
 376             the requested library container. Is never <NULL/>.
 377
 378         @throws RuntimeException
 379             if something does wrong, which indicates a server error in the installation
 380     */
 381     css::uno::Reference< css::script::XStorageBasedLibraryContainer >
 382             getLibraryContainer( bool _bScript );
 383
 384     /** lets our library containers store themself into the given root storage
 385     */
 386     void    storeLibraryContainersTo( const css::uno::Reference< css::embed::XStorage >& _rxToRootStorage );
 387
 388     /** rebases the document to the given storage
 389
 390         No actual committing, copying, saving, whatsoever happens. The storage is just remembered as the documents
 391         new storage, nothing more.
 392
 393         @throws css::lang::IllegalArgumentException
 394             if the given storage is <NULL/>
 395         @throws css::lang::RuntimeException
 396             if any of the invoked operations does so
 397     */
 398     css::uno::Reference< css::embed::XStorage >
 399             switchToStorage(
 400                 const css::uno::Reference< css::embed::XStorage >& _rxNewRootStorage
 401             );
 402
 403     /** returns the macro mode imposed by an external instance, which passed it to attachResource
 404     */
 405     sal_Int16       getImposedMacroExecMode() const
 406     {
 407         return m_nImposedMacroExecMode;
 408     }
 409     void            setImposedMacroExecMode( const sal_Int16 _nMacroMode )
 410     {
 411         m_nImposedMacroExecMode = _nMacroMode;
 412     }
 413
 414 public:
 415     // IMacroDocumentAccess overridables
 416     virtual sal_Int16 getCurrentMacroExecMode() const override;
 417     virtual void setCurrentMacroExecMode( sal_uInt16 ) override;
 418     virtual OUString getDocumentLocation() const override;
 419     virtual bool documentStorageHasMacros() const override;
 420     virtual bool macroCallsSeenWhileLoading() const override;
 421     virtual css::uno::Reference< css::document::XEmbeddedScripts > getEmbeddedDocumentScripts() const override;
 422     virtual SignatureState getScriptingSignatureState() override;
 423     virtual bool hasTrustedScriptingSignature( bool bAllowUIToAddAuthor ) override;
 424
 425     // IModifiableDocument
 426     virtual void storageIsModified() override;
 427
 428     // don't use directly, use the ModifyLock class instead
 429     void    lockModify()              { m_bModificationLock = true; }
 430     void    unlockModify()            { m_bModificationLock = false; }
 431     bool    isModifyLocked() const    { return m_bModificationLock; }
 432
 433     weld::Window* GetFrameWeld();
 434
 435 private:
 436     void    impl_construct_nothrow();
 437     css::uno::Reference< css::embed::XStorage > const &
 438             impl_switchToStorage_throw( const css::uno::Reference< css::embed::XStorage >& _rxNewRootStorage );
 439
 440     /** switches to the given document URL, which denotes the logical URL of the document, not necessarily the
 441         URL where the doc was loaded/recovered from
 442     */
 443     void    impl_switchToLogicalURL(
 444                 const OUString& i_rDocumentURL
 445             );
 446
 447 };
 448
 449 /** a small base class for UNO components whose functionality depends on an ODatabaseModelImpl
 450 */
 451 class ModelDependentComponent
 452 {
 453 protected:
 454     ::rtl::Reference< ODatabaseModelImpl >  m_pImpl;
 455     ::osl::Mutex m_aMutex; // only use this to init WeakComponentImplHelper
 456
 457 protected:
 458     explicit ModelDependentComponent( ::rtl::Reference< ODatabaseModelImpl > _model );
 459     virtual ~ModelDependentComponent();
 460
 461     /** returns the component itself
 462     */
 463     virtual css::uno::Reference< css::uno::XInterface > getThis() const = 0;
 464
 465     ::osl::Mutex& getMutex()
 466     {
 467         return m_aMutex;
 468     }
 469
 470 public:
 471     /// checks whether the component is already disposed, throws a DisposedException if so
 472     void checkDisposed() const
 473     {
 474         if ( !m_pImpl.is() )
 475             throw css::lang::DisposedException( "Component is already disposed.", getThis() );
 476     }
 477
 478     void lockModify()
 479     {
 480         m_pImpl->lockModify();
 481     }
 482
 483     void unlockModify()
 484     {
 485         m_pImpl->unlockModify();
 486     }
 487 };
 488
 489 class ModifyLock
 490 {
 491 public:
 492     explicit ModifyLock( ModelDependentComponent& _component )
 493         :m_rComponent( _component )
 494     {
 495         m_rComponent.lockModify();
 496     }
 497
 498     ~ModifyLock()
 499     {
 500         m_rComponent.unlockModify();
 501     }
 502
 503 private:
 504     ModelDependentComponent&    m_rComponent;
 505 };
 506
 507 /** a guard for public methods of objects dependent on an ODatabaseModelImpl instance
 508
 509     Just put this guard onto the stack at the beginning of your method. Don't bother yourself
 510     with a MutexGuard, checks for being disposed, and the like.
 511 */
 512 class ModelMethodGuard
 513 {
 514 private:
 515     // to avoid deadlocks, lock SolarMutex
 516     SolarMutexResettableGuard m_SolarGuard;
 517
 518 public:
 519     /** constructs the guard
 520
 521         @param _component
 522             the component whose functionality depends on an ODatabaseModelImpl instance
 523
 524         @throws css::lang::DisposedException
 525             If the given component is already disposed
 526     */
 527     explicit ModelMethodGuard( const ModelDependentComponent& _component )
 528     {
 529         _component.checkDisposed();
 530     }
 531
 532     void clear()
 533     {
 534         // note: this only releases *once* so may still be locked
 535         m_SolarGuard.clear();
 536     }
 537
 538     void reset()
 539     {
 540         m_SolarGuard.reset();
 541     }
 542 };
 543
 544 }   // namespace dbaccess
 545
 546 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */