1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_dbaccess.hxx"
26 
27 #include "core_resource.hxx"
28 #include "core_resource.hrc"
29 #include "datasource.hxx"
30 #include "databasedocument.hxx"
31 #include "dbastrings.hrc"
32 #include "module_dba.hxx"
33 #include "documenteventexecutor.hxx"
34 #include "databasecontext.hxx"
35 #include "documentcontainer.hxx"
36 #include "sdbcoretools.hxx"
37 #include "recovery/dbdocrecovery.hxx"
38 
39 /** === begin UNO includes === **/
40 #include <com/sun/star/beans/Optional.hpp>
41 #include <com/sun/star/document/XExporter.hpp>
42 #include <com/sun/star/document/XFilter.hpp>
43 #include <com/sun/star/document/XImporter.hpp>
44 #include <com/sun/star/embed/EntryInitModes.hpp>
45 #include <com/sun/star/embed/XEmbedPersist.hpp>
46 #include <com/sun/star/embed/XTransactedObject.hpp>
47 #include <com/sun/star/embed/XTransactionBroadcaster.hpp>
48 #include <com/sun/star/io/XActiveDataSource.hpp>
49 #include <com/sun/star/io/XSeekable.hpp>
50 #include <com/sun/star/io/XOutputStream.hpp>
51 #include <com/sun/star/io/XTruncate.hpp>
52 #include <com/sun/star/script/provider/XScriptProviderFactory.hpp>
53 #include <com/sun/star/task/ErrorCodeIOException.hpp>
54 #include <com/sun/star/task/XStatusIndicator.hpp>
55 #include <com/sun/star/task/XStatusIndicatorFactory.hpp>
56 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
57 #include <com/sun/star/ui/XUIConfigurationStorage.hpp>
58 #include <com/sun/star/view/XSelectionSupplier.hpp>
59 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
60 #include <com/sun/star/ucb/XContent.hpp>
61 #include <com/sun/star/sdb/application/XDatabaseDocumentUI.hpp>
62 /** === end UNO includes === **/
63 
64 #include <comphelper/documentconstants.hxx>
65 #include <comphelper/enumhelper.hxx>
66 #include <comphelper/genericpropertyset.hxx>
67 #include <comphelper/interaction.hxx>
68 #include <comphelper/mediadescriptor.hxx>
69 #include <comphelper/namedvaluecollection.hxx>
70 #include <comphelper/numberedcollection.hxx>
71 #include <comphelper/property.hxx>
72 #include <comphelper/storagehelper.hxx>
73 #include <comphelper/genericpropertyset.hxx>
74 #include <comphelper/property.hxx>
75 
76 #include <connectivity/dbtools.hxx>
77 
78 #include <cppuhelper/exc_hlp.hxx>
79 #include <framework/titlehelper.hxx>
80 #include <unotools/saveopt.hxx>
81 #include <tools/debug.hxx>
82 #include <tools/diagnose_ex.h>
83 #include <tools/errcode.hxx>
84 #include <tools/urlobj.hxx>
85 
86 #include <boost/bind.hpp>
87 
88 #include <algorithm>
89 #include <functional>
90 #include <list>
91 
92 #define MAP_LEN(x) x, sizeof(x) - 1
93 
94 #define MAP_LEN(x) x, sizeof(x) - 1
95 
96 using namespace ::com::sun::star::uno;
97 using namespace ::com::sun::star::beans;
98 using namespace ::com::sun::star::frame;
99 using namespace ::com::sun::star::lang;
100 using namespace ::com::sun::star::container;
101 using namespace ::com::sun::star::document;
102 using namespace ::com::sun::star::io;
103 using namespace ::com::sun::star::util;
104 using namespace ::com::sun::star::embed;
105 using namespace ::com::sun::star::task;
106 using namespace ::com::sun::star::view;
107 using namespace ::com::sun::star::sdbc;
108 using namespace ::com::sun::star;
109 using namespace ::com::sun::star::xml::sax;
110 using namespace ::com::sun::star::script;
111 using namespace ::com::sun::star::script::provider;
112 using namespace ::com::sun::star::ui;
113 using namespace ::cppu;
114 using namespace ::osl;
115 
116 using ::com::sun::star::awt::XWindow;
117 using ::com::sun::star::ucb::XContent;
118 using ::com::sun::star::sdb::application::XDatabaseDocumentUI;
119 
120 //........................................................................
121 namespace dbaccess
122 {
123 //........................................................................
124 
125 //============================================================
126 //= ViewMonitor
127 //============================================================
128 //--------------------------------------------------------------------------
129 bool ViewMonitor::onControllerConnected( const Reference< XController >& _rxController )
130 {
131     bool bFirstControllerEver = ( m_bEverHadController == false );
132     m_bEverHadController = true;
133 
134     m_xLastConnectedController = _rxController;
135     m_bLastIsFirstEverController = bFirstControllerEver;
136 
137     return bFirstControllerEver;
138 }
139 
140 //--------------------------------------------------------------------------
141 bool ViewMonitor::onSetCurrentController( const Reference< XController >& _rxController )
142 {
143     // we interpret this as "loading the document (including UI) is finished",
144     // if and only if this is the controller which was last connected, and it was the
145     // first controller ever connected
146     bool bLoadFinished = ( _rxController == m_xLastConnectedController ) && m_bLastIsFirstEverController;
147 
148     // notify the respective events
149     if ( bLoadFinished )
150         m_rEventNotifier.notifyDocumentEventAsync( m_bIsNewDocument ? "OnNew" : "OnLoad" );
151 
152     return bLoadFinished;
153 }
154 
155 //============================================================
156 //= ODatabaseDocument
157 //============================================================
158 DBG_NAME(ODatabaseDocument)
159 //--------------------------------------------------------------------------
160 extern "C" void SAL_CALL createRegistryInfo_ODatabaseDocument()
161 {
162 	static ::dba::OAutoRegistration< ODatabaseDocument > aAutoRegistration;
163 }
164 
165 //--------------------------------------------------------------------------
166 ODatabaseDocument::ODatabaseDocument(const ::rtl::Reference<ODatabaseModelImpl>& _pImpl	)
167             :ModelDependentComponent( _pImpl )
168             ,ODatabaseDocument_OfficeDocument( getMutex() )
169             ,m_aModifyListeners( getMutex() )
170 			,m_aCloseListener( getMutex() )
171             ,m_aStorageListeners( getMutex() )
172             ,m_pEventContainer( new DocumentEvents( *this, getMutex(), _pImpl->getDocumentEvents() ) )
173             ,m_pEventExecutor( NULL )   // initialized below, ref-count-protected
174             ,m_aEventNotifier( *this, getMutex() )
175             ,m_aViewMonitor( m_aEventNotifier )
176             ,m_eInitState( NotInitialized )
177             ,m_bClosing( false )
178             ,m_bAllowDocumentScripting( false )
179             ,m_bHasBeenRecovered( false )
180 {
181 	DBG_CTOR(ODatabaseDocument,NULL);
182     OSL_TRACE( "DD: ctor: %p: %p", this, m_pImpl.get() );
183 
184     osl_incrementInterlockedCount( &m_refCount );
185     {
186         impl_reparent_nothrow( m_xForms );
187         impl_reparent_nothrow( m_xReports );
188         impl_reparent_nothrow( m_pImpl->m_xTableDefinitions );
189         impl_reparent_nothrow( m_pImpl->m_xCommandDefinitions );
190 
191         m_pEventExecutor = new DocumentEventExecutor( m_pImpl->m_aContext, this );
192     }
193     osl_decrementInterlockedCount( &m_refCount );
194 
195     // if there previously was a document instance for the same Impl which was already initialized,
196     // then consider ourself initialized, too.
197     // #i94840#
198     if ( m_pImpl->hadInitializedDocument() )
199     {
200         // Note we set our init-state to "Initializing", not "Initialized". We're created from inside the ModelImpl,
201         // which is expected to call attachResource in case there was a previous incarnation of the document,
202         // so we can properly finish our initialization then.
203         impl_setInitializing();
204 
205         if ( m_pImpl->getURL().getLength() )
206         {
207             // if the previous incarnation of the DatabaseDocument already had an URL, then creating this incarnation
208             // here is effectively loading the document.
209             // #i105505# / 2009-10-01 / frank.schoenheit@sun.com
210             m_aViewMonitor.onLoadedDocument();
211         }
212     }
213 }
214 
215 //--------------------------------------------------------------------------
216 ODatabaseDocument::~ODatabaseDocument()
217 {
218     OSL_TRACE( "DD: dtor: %p: %p", this, m_pImpl.get() );
219 	DBG_DTOR(ODatabaseDocument,NULL);
220 	if ( !ODatabaseDocument_OfficeDocument::rBHelper.bInDispose && !ODatabaseDocument_OfficeDocument::rBHelper.bDisposed )
221 	{
222 		acquire();
223 		dispose();
224 	}
225 
226     delete m_pEventContainer, m_pEventContainer = NULL;
227 }
228 // -----------------------------------------------------------------------------
229 Any SAL_CALL ODatabaseDocument::queryInterface( const Type& _rType ) throw (RuntimeException)
230 {
231     // strip XEmbeddedScripts and XScriptInvocationContext if we have any form/report
232     // which already contains macros. In this case, the database document itself is not
233     // allowed to contain macros, too.
234     if  (   !m_bAllowDocumentScripting
235         &&  (   _rType.equals( XEmbeddedScripts::static_type() )
236             ||  _rType.equals( XScriptInvocationContext::static_type() )
237             )
238         )
239         return Any();
240 
241 	Any aReturn = ODatabaseDocument_OfficeDocument::queryInterface(_rType);
242 	if (!aReturn.hasValue())
243 		aReturn = ODatabaseDocument_Title::queryInterface(_rType);
244 	return aReturn;
245 }
246 //------------------------------------------------------------------------------
247 void SAL_CALL ODatabaseDocument::acquire(  ) throw ()
248 {
249 	ODatabaseDocument_OfficeDocument::acquire();
250 }
251 
252 //------------------------------------------------------------------------------
253 void SAL_CALL ODatabaseDocument::release(  ) throw ()
254 {
255 	ODatabaseDocument_OfficeDocument::release();
256 }
257 //------------------------------------------------------------------------------
258 Sequence< Type > SAL_CALL ODatabaseDocument::getTypes(	) throw (RuntimeException)
259 {
260 	Sequence< Type > aTypes = ::comphelper::concatSequences(
261 		ODatabaseDocument_OfficeDocument::getTypes(),
262 		ODatabaseDocument_Title::getTypes()
263 	);
264 
265     // strip XEmbeddedScripts and XScriptInvocationContext if we have any form/report
266     // which already contains macros. In this case, the database document itself is not
267     // allowed to contain macros, too.
268     if ( !m_bAllowDocumentScripting )
269     {
270         Sequence< Type > aStrippedTypes( aTypes.getLength() );
271         Type* pStripTo( aStrippedTypes.getArray() );
272 
273         // strip XEmbeddedScripts, and immediately re-assign to aTypes
274         aTypes = Sequence< Type >(
275             pStripTo,
276             ::std::remove_copy_if(
277                 aTypes.getConstArray(),
278                 aTypes.getConstArray() + aTypes.getLength(),
279                 pStripTo,
280                 ::std::bind2nd( ::std::equal_to< Type >(), XEmbeddedScripts::static_type() )
281             ) - pStripTo
282         );
283 
284         // strip XScriptInvocationContext, and immediately re-assign to aTypes
285         aTypes = Sequence< Type >(
286             pStripTo,
287             ::std::remove_copy_if(
288                 aTypes.getConstArray(),
289                 aTypes.getConstArray() + aTypes.getLength(),
290                 pStripTo,
291                 ::std::bind2nd( ::std::equal_to< Type >(), XScriptInvocationContext::static_type() )
292             ) - pStripTo
293         );
294     }
295 
296     return aTypes;
297 }
298 //------------------------------------------------------------------------------
299 Sequence< sal_Int8 > SAL_CALL ODatabaseDocument::getImplementationId(  ) throw (RuntimeException)
300 {
301 	static ::cppu::OImplementationId * pId = 0;
302 	if (! pId)
303 	{
304 		::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
305 		if (! pId)
306 		{
307 			static ::cppu::OImplementationId aId;
308 			pId = &aId;
309 		}
310 	}
311 	return pId->getImplementationId();
312 }
313 
314 // -----------------------------------------------------------------------------
315 // local functions
316 // -----------------------------------------------------------------------------
317 namespace
318 {
319     // -----------------------------------------------------------------------------
320     Reference< XStatusIndicator > lcl_extractStatusIndicator( const ::comphelper::NamedValueCollection& _rArguments )
321     {
322         Reference< XStatusIndicator > xStatusIndicator;
323         return _rArguments.getOrDefault( "StatusIndicator", xStatusIndicator );
324     }
325 
326     // -----------------------------------------------------------------------------
327     static void lcl_triggerStatusIndicator_throw( const ::comphelper::NamedValueCollection& _rArguments, DocumentGuard& _rGuard, const bool _bStart )
328     {
329         Reference< XStatusIndicator > xStatusIndicator( lcl_extractStatusIndicator( _rArguments ) );
330         if ( !xStatusIndicator.is() )
331             return;
332 
333         _rGuard.clear();
334         try
335         {
336             if ( _bStart )
337                 xStatusIndicator->start( ::rtl::OUString(), (sal_Int32)1000000 );
338             else
339                 xStatusIndicator->end();
340         }
341         catch( const Exception& )
342         {
343         	DBG_UNHANDLED_EXCEPTION();
344         }
345         _rGuard.reset();
346             // note that |reset| can throw a DisposedException
347     }
348 
349     // -----------------------------------------------------------------------------
350     static void lcl_extractStatusIndicator( const ::comphelper::NamedValueCollection& _rArguments, Sequence< Any >& _rCallArgs )
351     {
352         Reference< XStatusIndicator > xStatusIndicator( lcl_extractStatusIndicator( _rArguments ) );
353         if ( !xStatusIndicator.is() )
354             return;
355 
356         sal_Int32 nLength = _rCallArgs.getLength();
357         _rCallArgs.realloc( nLength + 1 );
358         _rCallArgs[ nLength ] <<= xStatusIndicator;
359     }
360 
361     // -----------------------------------------------------------------------------
362     static void lcl_extractAndStartStatusIndicator( const ::comphelper::NamedValueCollection& _rArguments, Reference< XStatusIndicator >& _rxStatusIndicator,
363         Sequence< Any >& _rCallArgs )
364     {
365         _rxStatusIndicator = lcl_extractStatusIndicator( _rArguments );
366         if ( !_rxStatusIndicator.is() )
367             return;
368 
369         try
370         {
371 	        _rxStatusIndicator->start( ::rtl::OUString(), (sal_Int32)1000000 );
372 
373             sal_Int32 nLength = _rCallArgs.getLength();
374             _rCallArgs.realloc( nLength + 1 );
375             _rCallArgs[ nLength ] <<= _rxStatusIndicator;
376         }
377         catch( const Exception& )
378         {
379             DBG_UNHANDLED_EXCEPTION();
380         }
381     }
382 
383     // -----------------------------------------------------------------------------
384     static Sequence< PropertyValue > lcl_appendFileNameToDescriptor( const ::comphelper::NamedValueCollection& _rDescriptor, const ::rtl::OUString _rURL )
385     {
386         ::comphelper::NamedValueCollection aMutableDescriptor( _rDescriptor );
387         if ( _rURL.getLength() )
388         {
389             aMutableDescriptor.put( "FileName", _rURL );
390             aMutableDescriptor.put( "URL", _rURL );
391         }
392         return aMutableDescriptor.getPropertyValues();
393     }
394 }
395 
396 // -----------------------------------------------------------------------------
397 void ODatabaseDocument::impl_setInitialized()
398 {
399     m_eInitState = Initialized;
400 
401     // start event notifications
402     m_aEventNotifier.onDocumentInitialized();
403 }
404 
405 // -----------------------------------------------------------------------------
406 void ODatabaseDocument::impl_reset_nothrow()
407 {
408     try
409 	{
410 		m_pImpl->clearConnections();
411         m_pImpl->disposeStorages();
412         m_pImpl->resetRootStroage();
413 
414         clearObjectContainer( m_xForms );
415 		clearObjectContainer( m_xReports );
416 		clearObjectContainer( m_pImpl->m_xTableDefinitions );
417 		clearObjectContainer( m_pImpl->m_xCommandDefinitions );
418 
419         m_eInitState = NotInitialized;
420 
421 		m_pImpl->reset();
422 	}
423 	catch(const Exception&)
424 	{
425         DBG_UNHANDLED_EXCEPTION();
426 	}
427 	m_pImpl->m_bDocumentReadOnly = sal_False;
428 }
429 
430 // -----------------------------------------------------------------------------
431 void ODatabaseDocument::impl_import_nolck_throw( const ::comphelper::ComponentContext _rContext, const Reference< XInterface >& _rxTargetComponent,
432                                                  const ::comphelper::NamedValueCollection& _rResource )
433 {
434 	Sequence< Any > aFilterCreationArgs;
435     Reference< XStatusIndicator > xStatusIndicator;
436     lcl_extractAndStartStatusIndicator( _rResource, xStatusIndicator, aFilterCreationArgs );
437 
438     /** property map for import info set */
439 	comphelper::PropertyMapEntry aExportInfoMap[] =
440  	{
441         { MAP_LEN( "BaseURI"), 0,&::getCppuType( (::rtl::OUString *)0 ),beans::PropertyAttribute::MAYBEVOID, 0 },
442         { MAP_LEN( "StreamName"), 0,&::getCppuType( (::rtl::OUString *)0 ),beans::PropertyAttribute::MAYBEVOID, 0 },
443   		{ NULL, 0, 0, NULL, 0, 0 }
444  	};
445  	uno::Reference< beans::XPropertySet > xInfoSet( comphelper::GenericPropertySet_CreateInstance( new comphelper::PropertySetInfo( aExportInfoMap ) ) );
446     xInfoSet->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BaseURI")), uno::makeAny(_rResource.getOrDefault("URL",::rtl::OUString())));
447     xInfoSet->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StreamName")), uno::makeAny(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("content.xml"))));
448 
449     const sal_Int32 nCount = aFilterCreationArgs.getLength();
450     aFilterCreationArgs.realloc(nCount + 1);
451     aFilterCreationArgs[nCount] <<= xInfoSet;
452 
453     Reference< XImporter > xImporter(
454         _rContext.createComponentWithArguments( "com.sun.star.comp.sdb.DBFilter", aFilterCreationArgs ),
455         UNO_QUERY_THROW );
456 
457 	Reference< XComponent > xComponent( _rxTargetComponent, UNO_QUERY_THROW );
458 	xImporter->setTargetDocument( xComponent );
459 
460     Reference< XFilter > xFilter( xImporter, UNO_QUERY_THROW );
461     Sequence< PropertyValue > aFilterArgs( ODatabaseModelImpl::stripLoadArguments( _rResource ).getPropertyValues() );
462 	xFilter->filter( aFilterArgs );
463 
464     if ( xStatusIndicator.is() )
465         xStatusIndicator->end();
466 }
467 
468 // -----------------------------------------------------------------------------
469 void SAL_CALL ODatabaseDocument::initNew(  ) throw (DoubleInitializationException, IOException, Exception, RuntimeException)
470 {
471     // SYNCHRONIZED ->
472     DocumentGuard aGuard( *this, DocumentGuard::InitMethod );
473 
474     impl_reset_nothrow();
475 
476     impl_setInitializing();
477 
478     // create a temporary storage
479     Reference< XStorage > xTempStor( ::comphelper::OStorageHelper::GetTemporaryStorage(
480         m_pImpl->m_aContext.getLegacyServiceFactory() ) );
481 
482     // store therein
483     impl_storeToStorage_throw( xTempStor, Sequence< PropertyValue >(), aGuard );
484 
485     // let the impl know we're now based on this storage
486     m_pImpl->switchToStorage( xTempStor );
487 
488     // for the newly created document, allow document-wide scripting
489     m_bAllowDocumentScripting = true;
490 
491     impl_setInitialized();
492 
493     m_aEventNotifier.notifyDocumentEventAsync( "OnTitleChanged" );
494 
495     impl_setModified_nothrow( sal_False, aGuard );
496     // <- SYNCHRONIZED
497 
498     m_aEventNotifier.notifyDocumentEvent( "OnCreate" );
499 
500     impl_notifyStorageChange_nolck_nothrow( xTempStor );
501 }
502 
503 // -----------------------------------------------------------------------------
504 void SAL_CALL ODatabaseDocument::load( const Sequence< PropertyValue >& _Arguments ) throw (DoubleInitializationException, IOException, Exception, RuntimeException)
505 {
506     // SYNCHRONIZED ->
507     DocumentGuard aGuard( *this, DocumentGuard::InitMethod );
508 
509     impl_reset_nothrow();
510 
511     ::comphelper::NamedValueCollection aResource( _Arguments );
512     if ( aResource.has( "FileName" ) && !aResource.has( "URL" ) )
513         // FileName is the compatibility name for URL, so we might have clients passing
514         // a FileName only. However, some of our code works with the URL only, so ensure
515         // we have one.
516         aResource.put( "URL", aResource.get( "FileName" ) );
517     if ( aResource.has( "URL" ) && !aResource.has( "FileName" ) )
518         // similar ... just in case there is legacy code which expects a FileName only
519         aResource.put( "FileName", aResource.get( "URL" ) );
520 
521     // now that somebody (perhaps) told us an macro execution mode, remember it as
522     // ImposedMacroExecMode
523     m_pImpl->setImposedMacroExecMode(
524         aResource.getOrDefault( "MacroExecutionMode", m_pImpl->getImposedMacroExecMode() ) );
525 
526     impl_setInitializing();
527     try
528     {
529         aGuard.clear();
530         impl_import_nolck_throw( m_pImpl->m_aContext, *this, aResource );
531         aGuard.reset();
532     }
533     catch( const Exception& )
534     {
535         impl_reset_nothrow();
536         throw;
537     }
538     // tell our view monitor that the document has been loaded - this way it will fire the proper
539     // event (OnLoad instead of OnCreate) later on
540     m_aViewMonitor.onLoadedDocument();
541 
542     // note that we do *not* call impl_setInitialized() here: The initialization is only complete
543     // when the XModel::attachResource has been called, not sooner.
544 
545     impl_setModified_nothrow( sal_False, aGuard );
546     // <- SYNCHRONIZED
547 }
548 
549 // -----------------------------------------------------------------------------
550 namespace
551 {
552     // .........................................................................
553     bool lcl_hasAnyModifiedSubComponent_throw( const Reference< XController >& i_rController )
554     {
555         Reference< XDatabaseDocumentUI > xDatabaseUI( i_rController, UNO_QUERY_THROW );
556 
557         Sequence< Reference< XComponent > > aComponents( xDatabaseUI->getSubComponents() );
558         const Reference< XComponent >* component = aComponents.getConstArray();
559         const Reference< XComponent >* componentsEnd = aComponents.getConstArray() + aComponents.getLength();
560 
561         bool isAnyModified = false;
562         for ( ; component != componentsEnd; ++component )
563         {
564             Reference< XModifiable > xModify( *component, UNO_QUERY );
565             if ( xModify.is() )
566             {
567                 isAnyModified = xModify->isModified();
568                 continue;
569             }
570 
571             // TODO: clarify: anything else to care for? Both the sub componbents with and without model
572             // should support the XModifiable interface, so I think nothing more is needed here.
573             OSL_ENSURE( false, "lcl_hasAnyModifiedSubComponent_throw: anything left to do here?" );
574         }
575 
576         return isAnyModified;
577     }
578 }
579 
580 // -----------------------------------------------------------------------------
581 ::sal_Bool SAL_CALL ODatabaseDocument::wasModifiedSinceLastSave() throw ( RuntimeException )
582 {
583     DocumentGuard aGuard( *this );
584 
585     // The implementation here is somewhat sloppy, in that it returns whether *any* part of the whole
586     // database document, including opened sub components, is modified. This is more than what is requested:
587     // We need to return <TRUE/> if the doc itself, or any of the opened sub components, has been modified
588     // since the last call to any of the save* methods, or since the document has been loaded/created.
589     // However, the API definition explicitly allows to be that sloppy ...
590 
591     if ( isModified() )
592         return sal_True;
593 
594     // auto recovery is an "UI feature", it is to restore the UI the user knows. Thus,
595     // we ask our connected controllers, not simply our existing form/report definitions.
596     // (There is some information which even cannot be obtained without asking the controller.
597     // For instance, newly created, but not yet saved, forms/reports are acessible via the
598     // controller only, but not via the model.)
599 
600     try
601     {
602         for (   Controllers::const_iterator ctrl = m_aControllers.begin();
603                 ctrl != m_aControllers.end();
604                 ++ctrl
605             )
606         {
607             if ( lcl_hasAnyModifiedSubComponent_throw( *ctrl ) )
608                 return sal_True;
609         }
610     }
611     catch( const Exception& )
612     {
613     	DBG_UNHANDLED_EXCEPTION();
614     }
615 
616     return sal_False;
617 }
618 
619 // -----------------------------------------------------------------------------
620 void SAL_CALL ODatabaseDocument::storeToRecoveryFile( const ::rtl::OUString& i_TargetLocation, const Sequence< PropertyValue >& i_MediaDescriptor ) throw ( RuntimeException, IOException, WrappedTargetException )
621 {
622     DocumentGuard aGuard( *this );
623     ModifyLock aLock( *this );
624 
625     try
626     {
627         // create a storage for the target location
628         Reference< XStorage > xTargetStorage( impl_createStorageFor_throw( i_TargetLocation ) );
629 
630         // first store the document as a whole into this storage
631         impl_storeToStorage_throw( xTargetStorage, i_MediaDescriptor, aGuard );
632 
633         // save the sub components which need saving
634         DatabaseDocumentRecovery aDocRecovery( m_pImpl->m_aContext);
635         aDocRecovery.saveModifiedSubComponents( xTargetStorage, m_aControllers );
636 
637         // commit the root storage
638         tools::stor::commitStorageIfWriteable( xTargetStorage );
639     }
640     catch( const Exception& )
641     {
642         Any aError = ::cppu::getCaughtException();
643         if  (   aError.isExtractableTo( ::cppu::UnoType< IOException >::get() )
644             ||  aError.isExtractableTo( ::cppu::UnoType< RuntimeException >::get() )
645             ||  aError.isExtractableTo( ::cppu::UnoType< WrappedTargetException >::get() )
646             )
647         {
648             // allowed to leave
649             throw;
650         }
651 
652         throw WrappedTargetException( ::rtl::OUString(), *this, aError );
653     }
654 }
655 
656 // -----------------------------------------------------------------------------
657 void SAL_CALL ODatabaseDocument::recoverFromFile( const ::rtl::OUString& i_SourceLocation, const ::rtl::OUString& i_SalvagedFile, const Sequence< PropertyValue >& i_MediaDescriptor ) throw ( RuntimeException, IOException, WrappedTargetException )
658 {
659     DocumentGuard aGuard( *this, DocumentGuard::InitMethod );
660 
661     if ( i_SourceLocation.getLength() == 0 )
662         throw IllegalArgumentException( ::rtl::OUString(), *this, 1 );
663 
664     try
665     {
666         // load the document itself, by simply delegating to our "load" method
667 
668         // our load implementation expects the SalvagedFile and URL to be in the media descriptor
669         ::comphelper::NamedValueCollection aMediaDescriptor( i_MediaDescriptor );
670         aMediaDescriptor.put( "SalvagedFile", i_SalvagedFile );
671         aMediaDescriptor.put( "URL", i_SourceLocation );
672 
673         aGuard.clear(); // (load has an own guarding scheme)
674         load( aMediaDescriptor.getPropertyValues() );
675 
676         // Without a controller, we are unable to recover the sub components, as they're always tied to a controller.
677         // So, everything else is done when the first controller is connected.
678         m_bHasBeenRecovered = true;
679 
680         // tell the impl that we've been loaded from the given location
681         m_pImpl->setDocFileLocation( i_SourceLocation );
682 
683         // by definition (of XDocumentRecovery), we're responsible for delivering a fully-initialized document,
684         // which includes an attachResource call.
685         const ::rtl::OUString sLogicalDocumentURL( i_SalvagedFile.getLength() ? i_SalvagedFile : i_SourceLocation );
686         impl_attachResource( sLogicalDocumentURL, aMediaDescriptor.getPropertyValues(), aGuard );
687         // <- SYNCHRONIZED
688     }
689     catch( const Exception& )
690     {
691         Any aError = ::cppu::getCaughtException();
692         if  (   aError.isExtractableTo( ::cppu::UnoType< IOException >::get() )
693             ||  aError.isExtractableTo( ::cppu::UnoType< RuntimeException >::get() )
694             ||  aError.isExtractableTo( ::cppu::UnoType< WrappedTargetException >::get() )
695             )
696         {
697             // allowed to leave
698             throw;
699         }
700 
701         throw WrappedTargetException( ::rtl::OUString(), *this, aError );
702     }
703 }
704 
705 // -----------------------------------------------------------------------------
706 // XModel
707 sal_Bool SAL_CALL ODatabaseDocument::attachResource( const ::rtl::OUString& _rURL, const Sequence< PropertyValue >& _rArguments ) throw (RuntimeException)
708 {
709     DocumentGuard aGuard( *this, DocumentGuard::MethodUsedDuringInit );
710     return impl_attachResource( _rURL, _rArguments, aGuard );
711 }
712 
713 // -----------------------------------------------------------------------------
714 sal_Bool ODatabaseDocument::impl_attachResource( const ::rtl::OUString& i_rLogicalDocumentURL,
715             const Sequence< PropertyValue >& i_rMediaDescriptor, DocumentGuard& _rDocGuard )
716 {
717     if  (   ( i_rLogicalDocumentURL == getURL() )
718         &&  ( i_rMediaDescriptor.getLength() == 1 )
719         &&  ( i_rMediaDescriptor[0].Name.compareToAscii( "BreakMacroSignature" ) == 0 )
720         )
721     {
722         // this is a BAD hack of the Basic importer code ... there should be a dedicated API for this,
723         // not this bad mis-using of existing interfaces
724         return sal_False;
725             // (we do not support macro signatures, so we can ignore this call)
726     }
727 
728     // if no URL has been provided, the caller was lazy enough to not call our getURL - which is not allowed anymore,
729     // now since getURL and getLocation both return the same, so calling one of those should be simple.
730     ::rtl::OUString sDocumentURL( i_rLogicalDocumentURL );
731     OSL_ENSURE( sDocumentURL.getLength(), "ODatabaseDocument::impl_attachResource: invalid URL!" );
732     if ( !sDocumentURL.getLength() )
733         sDocumentURL = getURL();
734 
735     m_pImpl->setResource( sDocumentURL, i_rMediaDescriptor );
736 
737     if ( impl_isInitializing() )
738     {   // this means we've just been loaded, and this is the attachResource call which follows
739         // the load call.
740         impl_setInitialized();
741 
742         // determine whether the document as a whole, or sub documents, have macros. Especially the latter
743         // controls the availability of our XEmbeddedScripts and XScriptInvocationContext interfaces, and we
744         // should know this before anybody actually uses the object.
745         m_bAllowDocumentScripting = ( m_pImpl->determineEmbeddedMacros() != ODatabaseModelImpl::eSubDocumentMacros );
746 
747         _rDocGuard.clear();
748         // <- SYNCHRONIZED
749         m_aEventNotifier.notifyDocumentEvent( "OnLoadFinished" );
750     }
751 
752     return sal_True;
753 }
754 
755 // -----------------------------------------------------------------------------
756 ::rtl::OUString SAL_CALL ODatabaseDocument::getURL(  ) throw (RuntimeException)
757 {
758     DocumentGuard aGuard( *this, DocumentGuard::MethodWithoutInit );
759     return m_pImpl->getURL();
760 }
761 
762 // -----------------------------------------------------------------------------
763 Sequence< PropertyValue > SAL_CALL ODatabaseDocument::getArgs(  ) throw (RuntimeException)
764 {
765     DocumentGuard aGuard( *this, DocumentGuard::MethodWithoutInit );
766     return m_pImpl->getMediaDescriptor().getPropertyValues();
767 }
768 
769 // -----------------------------------------------------------------------------
770 void SAL_CALL ODatabaseDocument::connectController( const Reference< XController >& _xController ) throw (RuntimeException)
771 {
772     DocumentGuard aGuard( *this );
773 
774 #if OSL_DEBUG_LEVEL > 0
775     for (   Controllers::const_iterator controller = m_aControllers.begin();
776             controller != m_aControllers.end();
777             ++controller
778         )
779     {
780         OSL_ENSURE( *controller != _xController, "ODatabaseDocument::connectController: this controller is already connected!" );
781     }
782 #endif
783 
784     m_aControllers.push_back( _xController );
785 
786     m_aEventNotifier.notifyDocumentEventAsync( "OnViewCreated", Reference< XController2 >( _xController, UNO_QUERY ) );
787 
788     bool bFirstControllerEver = m_aViewMonitor.onControllerConnected( _xController );
789     if ( !bFirstControllerEver )
790         return;
791 
792     // check/adjust our macro mode.
793     m_pImpl->checkMacrosOnLoading();
794 }
795 
796 // -----------------------------------------------------------------------------
797 void SAL_CALL ODatabaseDocument::disconnectController( const Reference< XController >& _xController ) throw (RuntimeException)
798 {
799     bool bNotifyViewClosed = false;
800     bool bLastControllerGone = false;
801     bool bIsClosing = false;
802 
803     // SYNCHRONIZED ->
804     {
805         DocumentGuard aGuard( *this );
806 
807         Controllers::iterator pos = ::std::find( m_aControllers.begin(), m_aControllers.end(), _xController );
808         OSL_ENSURE( pos != m_aControllers.end(), "ODatabaseDocument::disconnectController: don't know this controller!" );
809         if ( pos != m_aControllers.end() )
810         {
811             m_aControllers.erase( pos );
812             bNotifyViewClosed = true;
813         }
814 
815 	    if ( m_xCurrentController == _xController )
816 		    m_xCurrentController = NULL;
817 
818         bLastControllerGone = m_aControllers.empty();
819         bIsClosing = m_bClosing;
820     }
821     // <- SYNCHRONIZED
822 
823     if ( bNotifyViewClosed )
824         m_aEventNotifier.notifyDocumentEvent( "OnViewClosed", Reference< XController2 >( _xController, UNO_QUERY ) );
825 
826     if ( bLastControllerGone && !bIsClosing )
827     {
828         // if this was the last view, close the document as a whole
829         // #i51157# / 2006-03-16 / frank.schoenheit@sun.com
830         try
831         {
832             close( sal_True );
833         }
834         catch( const CloseVetoException& )
835         {
836             // okay, somebody vetoed and took ownership
837         }
838     }
839 }
840 
841 // -----------------------------------------------------------------------------
842 void SAL_CALL ODatabaseDocument::lockControllers(  ) throw (RuntimeException)
843 {
844     DocumentGuard aGuard( *this );
845 
846     ++m_pImpl->m_nControllerLockCount;
847 }
848 
849 // -----------------------------------------------------------------------------
850 void SAL_CALL ODatabaseDocument::unlockControllers(  ) throw (RuntimeException)
851 {
852     DocumentGuard aGuard( *this );
853 
854 	--m_pImpl->m_nControllerLockCount;
855 }
856 
857 // -----------------------------------------------------------------------------
858 sal_Bool SAL_CALL ODatabaseDocument::hasControllersLocked(  ) throw (RuntimeException)
859 {
860     DocumentGuard aGuard( *this );
861 
862 	return m_pImpl->m_nControllerLockCount != 0;
863 }
864 
865 // -----------------------------------------------------------------------------
866 Reference< XController > SAL_CALL ODatabaseDocument::getCurrentController() throw (RuntimeException)
867 {
868     DocumentGuard aGuard( *this );
869 
870 	return m_xCurrentController.is() ? m_xCurrentController : ( m_aControllers.empty() ? Reference< XController >() : *m_aControllers.begin() );
871 }
872 
873 // -----------------------------------------------------------------------------
874 void SAL_CALL ODatabaseDocument::setCurrentController( const Reference< XController >& _xController ) throw (NoSuchElementException, RuntimeException)
875 {
876     DocumentGuard aGuard( *this );
877 
878 	m_xCurrentController = _xController;
879 
880     if ( !m_aViewMonitor.onSetCurrentController( _xController ) )
881         return;
882 
883     // check if there are sub components to recover from our document storage
884     bool bAttemptRecovery = m_bHasBeenRecovered;
885     if ( !bAttemptRecovery && m_pImpl->getMediaDescriptor().has( "ForceRecovery" ) )
886         // do not use getOrDefault, it will throw for invalid types, which is not desired here
887         m_pImpl->getMediaDescriptor().get( "ForceRecovery" ) >>= bAttemptRecovery;
888 
889     if ( !bAttemptRecovery )
890         return;
891 
892     try
893     {
894         DatabaseDocumentRecovery aDocRecovery( m_pImpl->m_aContext );
895         aDocRecovery.recoverSubDocuments( m_pImpl->getRootStorage(), _xController );
896     }
897     catch( const Exception& )
898     {
899     	DBG_UNHANDLED_EXCEPTION();
900     }
901 }
902 
903 // -----------------------------------------------------------------------------
904 Reference< XInterface > SAL_CALL ODatabaseDocument::getCurrentSelection(  ) throw (RuntimeException)
905 {
906     DocumentGuard aGuard( *this );
907 
908 	Reference< XInterface > xRet;
909 	Reference< XSelectionSupplier >  xDocView( getCurrentController(), UNO_QUERY );
910 	if ( xDocView.is() )
911 		xRet.set(xDocView->getSelection(),UNO_QUERY);
912 
913 	return xRet;
914 }
915 // -----------------------------------------------------------------------------
916 
917 // XStorable
918 sal_Bool SAL_CALL ODatabaseDocument::hasLocation(  ) throw (RuntimeException)
919 {
920     return getLocation().getLength() > 0;
921 }
922 // -----------------------------------------------------------------------------
923 ::rtl::OUString SAL_CALL ODatabaseDocument::getLocation(  ) throw (RuntimeException)
924 {
925     DocumentGuard aGuard( *this, DocumentGuard::MethodWithoutInit );
926     return m_pImpl->getURL();
927         // both XStorable::getLocation and XModel::getURL have to return the URL of the document, *not*
928         // the location of the file which the docunment was possibly recovered from (which would be getDocFileLocation)
929 }
930 // -----------------------------------------------------------------------------
931 sal_Bool SAL_CALL ODatabaseDocument::isReadonly(  ) throw (RuntimeException)
932 {
933     DocumentGuard aGuard( *this, DocumentGuard::MethodWithoutInit );
934 	return m_pImpl->m_bDocumentReadOnly;
935 }
936 // -----------------------------------------------------------------------------
937 void SAL_CALL ODatabaseDocument::store(  ) throw (IOException, RuntimeException)
938 {
939     DocumentGuard aGuard( *this );
940 
941     ::rtl::OUString sDocumentURL( m_pImpl->getURL() );
942     if ( sDocumentURL.getLength() )
943     {
944         if ( m_pImpl->getDocFileLocation() == m_pImpl->getURL() )
945             if ( m_pImpl->m_bDocumentReadOnly )
946                 throw IOException();
947 
948         impl_storeAs_throw( m_pImpl->getURL(), m_pImpl->getMediaDescriptor(), SAVE, aGuard );
949         return;
950     }
951 
952     // if we have no URL, but did survive the DocumentGuard above, then we've been inited via XLoadable::initNew,
953     // i.e. we're based on a temporary storage
954     OSL_ENSURE( m_pImpl->getDocFileLocation().getLength() == 0, "ODatabaseDocument::store: unexpected URL inconsistency!" );
955 
956     try
957     {
958         impl_storeToStorage_throw( m_pImpl->getRootStorage(), m_pImpl->getMediaDescriptor().getPropertyValues(), aGuard );
959     }
960     catch( const Exception& )
961     {
962         Any aError = ::cppu::getCaughtException();
963         if  (   aError.isExtractableTo( ::cppu::UnoType< IOException >::get() )
964             ||  aError.isExtractableTo( ::cppu::UnoType< RuntimeException >::get() )
965             )
966         {
967             // allowed to leave
968             throw;
969         }
970         impl_throwIOExceptionCausedBySave_throw( aError, ::rtl::OUString() );
971     }
972 }
973 
974 // -----------------------------------------------------------------------------
975 void ODatabaseDocument::impl_throwIOExceptionCausedBySave_throw( const Any& i_rError, const ::rtl::OUString& i_rTargetURL ) const
976 {
977     ::rtl::OUString sErrorMessage = extractExceptionMessage( m_pImpl->m_aContext, i_rError );
978     sErrorMessage = ResourceManager::loadString(
979         RID_STR_ERROR_WHILE_SAVING,
980         "$location$", i_rTargetURL,
981         "$message$", sErrorMessage
982     );
983     throw IOException( sErrorMessage, *const_cast< ODatabaseDocument* >( this ) );
984 }
985 
986 // -----------------------------------------------------------------------------
987 void ODatabaseDocument::impl_storeAs_throw( const ::rtl::OUString& _rURL, const ::comphelper::NamedValueCollection& _rArguments,
988     const StoreType _eType, DocumentGuard& _rGuard ) throw ( IOException, RuntimeException )
989 {
990     OSL_PRECOND( ( _eType == SAVE ) || ( _eType == SAVE_AS ),
991         "ODatabaseDocument::impl_storeAs_throw: you introduced a new type which cannot be handled here!" );
992 
993     // if we're in the process of initializing the document (which effectively means it is an implicit
994     // initialization triggered in storeAsURL), the we do not notify events, since to an observer, the SaveAs
995     // should not be noticable
996     bool bIsInitializationProcess = impl_isInitializing();
997 
998     if ( !bIsInitializationProcess )
999     {
1000         _rGuard.clear();
1001     	m_aEventNotifier.notifyDocumentEvent( _eType == SAVE ? "OnSave" : "OnSaveAs", NULL, makeAny( _rURL ) );
1002         _rGuard.reset();
1003     }
1004 
1005     Reference< XStorage > xNewRootStorage;
1006         // will be non-NULL if our storage changed
1007 
1008     try
1009     {
1010         ModifyLock aLock( *this );
1011             // ignore all changes of our "modified" state during storing
1012 
1013         sal_Bool bLocationChanged = ( _rURL != m_pImpl->getDocFileLocation() );
1014 	    if ( bLocationChanged )
1015 	    {
1016             // create storage for target URL
1017             Reference< XStorage > xTargetStorage( impl_createStorageFor_throw( _rURL ) );
1018 
1019             if ( m_pImpl->isEmbeddedDatabase() )
1020                 m_pImpl->clearConnections();
1021 
1022             // commit everything
1023             m_pImpl->commitEmbeddedStorage();
1024             m_pImpl->commitStorages();
1025 
1026             // copy own storage to target storage
1027             Reference< XStorage > xCurrentStorage( m_pImpl->getRootStorage() );
1028             if ( xCurrentStorage.is() )
1029                 xCurrentStorage->copyToStorage( xTargetStorage );
1030 
1031             m_pImpl->disposeStorages();
1032 
1033             // each and every document definition obtained via m_xForms and m_xReports depends
1034             // on the sub storages which we just disposed. So, dispose the forms/reports collections, too.
1035             // This ensures that they're re-created when needed.
1036             clearObjectContainer( m_xForms );
1037             clearObjectContainer( m_xReports );
1038 
1039             xNewRootStorage = m_pImpl->switchToStorage( xTargetStorage );
1040 
1041             m_pImpl->m_bDocumentReadOnly = sal_False;
1042 	    }
1043 
1044         // store to current storage
1045         Reference< XStorage > xCurrentStorage( m_pImpl->getOrCreateRootStorage(), UNO_QUERY_THROW );
1046         Sequence< PropertyValue > aMediaDescriptor( lcl_appendFileNameToDescriptor( _rArguments, _rURL ) );
1047         impl_storeToStorage_throw( xCurrentStorage, aMediaDescriptor, _rGuard );
1048 
1049         // success - tell our impl
1050         m_pImpl->setDocFileLocation( _rURL );
1051         m_pImpl->setResource( _rURL, aMediaDescriptor );
1052 
1053         // if we are in an initialization process, then this is finished, now that we stored the document
1054         if ( bIsInitializationProcess )
1055             impl_setInitialized();
1056     }
1057     catch( const Exception& )
1058     {
1059         Any aError = ::cppu::getCaughtException();
1060 
1061         // notify the failure
1062         if ( !bIsInitializationProcess )
1063             m_aEventNotifier.notifyDocumentEventAsync( _eType == SAVE ? "OnSaveFailed" : "OnSaveAsFailed", NULL, makeAny( _rURL ) );
1064 
1065         if  (   aError.isExtractableTo( ::cppu::UnoType< IOException >::get() )
1066             ||  aError.isExtractableTo( ::cppu::UnoType< RuntimeException >::get() )
1067             )
1068         {
1069             // allowed to leave
1070             throw;
1071         }
1072 
1073         impl_throwIOExceptionCausedBySave_throw( aError, _rURL );
1074     }
1075 
1076     // notify the document event
1077     if ( !bIsInitializationProcess )
1078         m_aEventNotifier.notifyDocumentEventAsync( _eType == SAVE ? "OnSaveDone" : "OnSaveAsDone", NULL, makeAny( _rURL ) );
1079 
1080     // reset our "modified" flag, and clear the guard
1081     impl_setModified_nothrow( sal_False, _rGuard );
1082     // <- SYNCHRONIZED
1083 
1084     // notify storage listeners
1085     if ( xNewRootStorage.is() )
1086         impl_notifyStorageChange_nolck_nothrow( xNewRootStorage );
1087 }
1088 
1089 // -----------------------------------------------------------------------------
1090 Reference< XStorage > ODatabaseDocument::impl_createStorageFor_throw( const ::rtl::OUString& _rURL ) const
1091 {
1092 	Reference < ::com::sun::star::ucb::XSimpleFileAccess > xTempAccess;
1093 	m_pImpl->m_aContext.createComponent( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ,xTempAccess);
1094 	Reference< io::XStream > xStream = xTempAccess->openFileReadWrite( _rURL );
1095 	Reference< io::XTruncate > xTruncate(xStream,UNO_QUERY);
1096 	if ( xTruncate.is() )
1097 	{
1098 		xTruncate->truncate();
1099 	}
1100     Sequence<Any> aParam(2);
1101 	aParam[0] <<= xStream;
1102 	aParam[1] <<= ElementModes::READWRITE | ElementModes::TRUNCATE;
1103 
1104     Reference< XSingleServiceFactory > xStorageFactory( m_pImpl->createStorageFactory(), UNO_SET_THROW );
1105 	return Reference< XStorage >( xStorageFactory->createInstanceWithArguments( aParam ), UNO_QUERY_THROW );
1106 }
1107 
1108 // -----------------------------------------------------------------------------
1109 void SAL_CALL ODatabaseDocument::storeAsURL( const ::rtl::OUString& _rURL, const Sequence< PropertyValue >& _rArguments ) throw (IOException, RuntimeException)
1110 {
1111     // SYNCHRONIZED ->
1112     DocumentGuard aGuard( *this, DocumentGuard::MethodWithoutInit );
1113 
1114     // Normally, a document initialization is done via XLoadable::load or XLoadable::initNew. For convenience
1115     // reasons, and to not break existing API clients, it's allowed to call storeAsURL without having initialized
1116     // the document, in which case the initialization will be done implicitly.
1117     bool bImplicitInitialization = !impl_isInitialized();
1118     // implicit initialization while another initialization is just running is not possible
1119     if ( bImplicitInitialization && impl_isInitializing() )
1120         throw DoubleInitializationException();
1121 
1122     if ( bImplicitInitialization )
1123         impl_setInitializing();
1124 
1125     try
1126     {
1127         impl_storeAs_throw( _rURL, _rArguments, SAVE_AS, aGuard );
1128         // <- SYNCHRONIZED
1129 
1130         // impl_storeAs_throw cleared the lock on our mutex, but the below lines need this lock
1131         // SYNCHRONIZED ->
1132         aGuard.reset();
1133 
1134         // our title might have changed, potentially at least
1135         // Sadly, we cannot check this: Calling getTitle here and now would not deliver
1136         // an up-to-date result, as the call is delegated to our TitleHelper instance, which itself
1137         // updates its title only if it gets the OnSaveAsDone event (which was sent asynchronously
1138         // by impl_storeAs_throw). So, we simply notify always, and also asynchronously
1139         m_aEventNotifier.notifyDocumentEventAsync( "OnTitleChanged" );
1140     }
1141     catch( const Exception& )
1142     {
1143         impl_reset_nothrow();
1144         throw;
1145     }
1146 
1147     if ( bImplicitInitialization )
1148         m_bAllowDocumentScripting = true;
1149 
1150     aGuard.clear();
1151     // <- SYNCHRONIZED
1152 
1153     if ( bImplicitInitialization )
1154         m_aEventNotifier.notifyDocumentEvent( "OnCreate" );
1155 }
1156 
1157 // -----------------------------------------------------------------------------
1158 void ODatabaseDocument::impl_storeToStorage_throw( const Reference< XStorage >& _rxTargetStorage, const Sequence< PropertyValue >& _rMediaDescriptor,
1159                                                    DocumentGuard& _rDocGuard ) const
1160 {
1161     if ( !_rxTargetStorage.is() )
1162         throw IllegalArgumentException( ::rtl::OUString(), *const_cast< ODatabaseDocument* >( this ), 1 );
1163 
1164     if ( !m_pImpl.is() )
1165         throw DisposedException( ::rtl::OUString(), *const_cast< ODatabaseDocument* >( this ) );
1166 
1167 	try
1168 	{
1169         // commit everything
1170 	    m_pImpl->commitEmbeddedStorage();
1171         m_pImpl->commitStorages();
1172 
1173         // copy own storage to target storage
1174         if ( impl_isInitialized() )
1175         {
1176             Reference< XStorage > xCurrentStorage( m_pImpl->getOrCreateRootStorage(), UNO_QUERY_THROW );
1177             if ( xCurrentStorage != _rxTargetStorage )
1178     	        xCurrentStorage->copyToStorage( _rxTargetStorage );
1179         }
1180 
1181         // write into target storage
1182 	    ::comphelper::NamedValueCollection aWriteArgs( _rMediaDescriptor );
1183         lcl_triggerStatusIndicator_throw( aWriteArgs, _rDocGuard, true );
1184         impl_writeStorage_throw( _rxTargetStorage, aWriteArgs );
1185         lcl_triggerStatusIndicator_throw( aWriteArgs, _rDocGuard, false );
1186 
1187         // commit target storage
1188         OSL_VERIFY( tools::stor::commitStorageIfWriteable( _rxTargetStorage ) );
1189 	}
1190     catch( const IOException& ) { throw; }
1191     catch( const RuntimeException& ) { throw; }
1192 	catch ( const Exception& e )
1193 	{
1194 		throw IOException( e.Message, *const_cast< ODatabaseDocument* >( this ) );
1195 	}
1196 }
1197 
1198 // -----------------------------------------------------------------------------
1199 void SAL_CALL ODatabaseDocument::storeToURL( const ::rtl::OUString& _rURL, const Sequence< PropertyValue >& _rArguments ) throw (IOException, RuntimeException)
1200 {
1201     DocumentGuard aGuard( *this );
1202     ModifyLock aLock( *this );
1203 
1204     {
1205         aGuard.clear();
1206         m_aEventNotifier.notifyDocumentEvent( "OnSaveTo", NULL, makeAny( _rURL ) );
1207         aGuard.reset();
1208     }
1209 
1210     try
1211     {
1212         // create storage for target URL
1213         Reference< XStorage > xTargetStorage( impl_createStorageFor_throw( _rURL ) );
1214 
1215         // extend media descriptor with URL
1216         Sequence< PropertyValue > aMediaDescriptor( lcl_appendFileNameToDescriptor( _rArguments, _rURL ) );
1217 
1218         // store to this storage
1219         impl_storeToStorage_throw( xTargetStorage, aMediaDescriptor, aGuard );
1220     }
1221     catch( const Exception& )
1222     {
1223         Any aError = ::cppu::getCaughtException();
1224         m_aEventNotifier.notifyDocumentEventAsync( "OnSaveToFailed", NULL, aError );
1225 
1226         if  (   aError.isExtractableTo( ::cppu::UnoType< IOException >::get() )
1227             ||  aError.isExtractableTo( ::cppu::UnoType< RuntimeException >::get() )
1228             )
1229         {
1230             // allowed to leave
1231             throw;
1232         }
1233 
1234         impl_throwIOExceptionCausedBySave_throw( aError, _rURL );
1235     }
1236 
1237     m_aEventNotifier.notifyDocumentEventAsync( "OnSaveToDone", NULL, makeAny( _rURL ) );
1238 }
1239 
1240 // -----------------------------------------------------------------------------
1241 // XModifyBroadcaster
1242 void SAL_CALL ODatabaseDocument::addModifyListener( const Reference< XModifyListener >& _xListener ) throw (RuntimeException)
1243 {
1244     DocumentGuard aGuard( *this );
1245 	m_aModifyListeners.addInterface(_xListener);
1246 }
1247 
1248 // -----------------------------------------------------------------------------
1249 void SAL_CALL ODatabaseDocument::removeModifyListener( const Reference< XModifyListener >& _xListener ) throw (RuntimeException)
1250 {
1251     DocumentGuard aGuard( *this );
1252 	m_aModifyListeners.removeInterface(_xListener);
1253 }
1254 
1255 // -----------------------------------------------------------------------------
1256 // XModifiable
1257 sal_Bool SAL_CALL ODatabaseDocument::isModified(  ) throw (RuntimeException)
1258 {
1259     DocumentGuard aGuard( *this );
1260 
1261 	return m_pImpl->m_bModified;
1262 }
1263 
1264 // -----------------------------------------------------------------------------
1265 void SAL_CALL ODatabaseDocument::setModified( sal_Bool _bModified ) throw (PropertyVetoException, RuntimeException)
1266 {
1267     DocumentGuard aGuard( *this, DocumentGuard::MethodWithoutInit );
1268     if ( impl_isInitialized() )
1269         impl_setModified_nothrow( _bModified, aGuard );
1270     // it's allowed to call setModified without the document being initialized already. In this case,
1271     // we simply ignore the call - when the initialization is finished, the respective code will set
1272     // a proper "modified" flag
1273 }
1274 
1275 // -----------------------------------------------------------------------------
1276 void ODatabaseDocument::impl_setModified_nothrow( sal_Bool _bModified, DocumentGuard& _rGuard )
1277 {
1278     // SYNCHRONIZED ->
1279     bool bModifiedChanged = ( m_pImpl->m_bModified != _bModified ) && ( !m_pImpl->isModifyLocked() );
1280 
1281     if ( bModifiedChanged )
1282     {
1283         m_pImpl->m_bModified = _bModified;
1284         m_aEventNotifier.notifyDocumentEventAsync( "OnModifyChanged" );
1285     }
1286     _rGuard.clear();
1287     // <- SYNCHRONIZED
1288 
1289     if ( bModifiedChanged )
1290     {
1291         lang::EventObject aEvent( *this );
1292         m_aModifyListeners.notifyEach( &XModifyListener::modified, aEvent );
1293     }
1294 }
1295 
1296 // -----------------------------------------------------------------------------
1297 // ::com::sun::star::document::XEventBroadcaster
1298 void SAL_CALL ODatabaseDocument::addEventListener(const uno::Reference< document::XEventListener >& _Listener ) throw (uno::RuntimeException)
1299 {
1300     m_aEventNotifier.addLegacyEventListener( _Listener );
1301 }
1302 
1303 // -----------------------------------------------------------------------------
1304 void SAL_CALL ODatabaseDocument::removeEventListener( const uno::Reference< document::XEventListener >& _Listener ) throw (uno::RuntimeException)
1305 {
1306     m_aEventNotifier.removeLegacyEventListener( _Listener );
1307 }
1308 
1309 // -----------------------------------------------------------------------------
1310 void SAL_CALL ODatabaseDocument::addDocumentEventListener( const Reference< XDocumentEventListener >& _Listener ) throw (RuntimeException)
1311 {
1312     m_aEventNotifier.addDocumentEventListener( _Listener );
1313 }
1314 
1315 // -----------------------------------------------------------------------------
1316 void SAL_CALL ODatabaseDocument::removeDocumentEventListener( const Reference< XDocumentEventListener >& _Listener ) throw (RuntimeException)
1317 {
1318     m_aEventNotifier.removeDocumentEventListener( _Listener );
1319 }
1320 
1321 // -----------------------------------------------------------------------------
1322 void SAL_CALL ODatabaseDocument::notifyDocumentEvent( const ::rtl::OUString& _EventName, const Reference< XController2 >& _ViewController, const Any& _Supplement ) throw (IllegalArgumentException, NoSupportException, RuntimeException)
1323 {
1324     if ( !_EventName.getLength() )
1325         throw IllegalArgumentException( ::rtl::OUString(), *this, 1 );
1326 
1327     // SYNCHRONIZED ->
1328     DocumentGuard aGuard( *this );
1329 
1330     if ( !DocumentEvents::needsSynchronousNotification( _EventName ) )
1331     {
1332         m_aEventNotifier.notifyDocumentEventAsync( _EventName, _ViewController, _Supplement );
1333         return;
1334     }
1335     aGuard.clear();
1336     // <- SYNCHRONIZED
1337 
1338     m_aEventNotifier.notifyDocumentEvent( _EventName, _ViewController, _Supplement );
1339 }
1340 
1341 // -----------------------------------------------------------------------------
1342 Sequence< PropertyValue > SAL_CALL ODatabaseDocument::getPrinter(  ) throw (RuntimeException)
1343 {
1344     DBG_ERROR( "ODatabaseDocument::getPrinter: not supported!" );
1345 	return Sequence< PropertyValue >();
1346 }
1347 
1348 // -----------------------------------------------------------------------------
1349 void SAL_CALL ODatabaseDocument::setPrinter( const Sequence< PropertyValue >& /*aPrinter*/ ) throw (IllegalArgumentException, RuntimeException)
1350 {
1351     DBG_ERROR( "ODatabaseDocument::setPrinter: not supported!" );
1352 }
1353 
1354 // -----------------------------------------------------------------------------
1355 void SAL_CALL ODatabaseDocument::print( const Sequence< PropertyValue >& /*xOptions*/ ) throw (IllegalArgumentException, RuntimeException)
1356 {
1357     DBG_ERROR( "ODatabaseDocument::print: not supported!" );
1358 }
1359 
1360 // -----------------------------------------------------------------------------
1361 void ODatabaseDocument::impl_reparent_nothrow( const WeakReference< XNameAccess >& _rxContainer )
1362 {
1363 	Reference< XChild > xChild( _rxContainer.get(), UNO_QUERY );
1364 	if  ( xChild.is() )
1365 		xChild->setParent( *this );
1366 }
1367 // -----------------------------------------------------------------------------
1368 void ODatabaseDocument::clearObjectContainer( WeakReference< XNameAccess >& _rxContainer)
1369 {
1370     Reference< XNameAccess > xContainer = _rxContainer;
1371     ::comphelper::disposeComponent( xContainer );
1372 
1373 	Reference< XChild > xChild( _rxContainer.get(),UNO_QUERY );
1374 	if ( xChild.is() )
1375 		xChild->setParent( NULL );
1376     _rxContainer = Reference< XNameAccess >();
1377 }
1378 // -----------------------------------------------------------------------------
1379 Reference< XNameAccess > ODatabaseDocument::impl_getDocumentContainer_throw( ODatabaseModelImpl::ObjectType _eType )
1380 {
1381     if ( ( _eType != ODatabaseModelImpl::E_FORM ) && ( _eType != ODatabaseModelImpl::E_REPORT ) )
1382         throw IllegalArgumentException();
1383 
1384     bool bFormsContainer = _eType == ODatabaseModelImpl::E_FORM;
1385 
1386     WeakReference< XNameAccess >& rContainerRef( bFormsContainer ? m_xForms : m_xReports );
1387     Reference< XNameAccess > xContainer = rContainerRef;
1388 	if ( !xContainer.is() )
1389 	{
1390         Any aValue;
1391         ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xMy(*this);
1392         if ( dbtools::getDataSourceSetting(xMy,bFormsContainer ? "Forms" : "Reports",aValue) )
1393         {
1394             ::rtl::OUString sSupportService;
1395             aValue >>= sSupportService;
1396             if ( sSupportService.getLength() )
1397             {
1398                 Sequence<Any> aArgs(1);
1399                 aArgs[0] <<= NamedValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DatabaseDocument")),makeAny(xMy));
1400                 xContainer.set(m_pImpl->m_aContext.createComponentWithArguments(sSupportService,aArgs),UNO_QUERY);
1401                 rContainerRef = xContainer;
1402             }
1403         }
1404         if ( !xContainer.is() )
1405         {
1406             TContentPtr& rContainerData( m_pImpl->getObjectContainer( _eType ) );
1407             rContainerRef = xContainer = new ODocumentContainer( m_pImpl->m_aContext.getLegacyServiceFactory(), *this, rContainerData, bFormsContainer );
1408         }
1409         impl_reparent_nothrow( xContainer );
1410 	}
1411 	return xContainer;
1412 }
1413 
1414 // -----------------------------------------------------------------------------
1415 void ODatabaseDocument::impl_closeControllerFrames_nolck_throw( sal_Bool _bDeliverOwnership )
1416 {
1417     Controllers aCopy = m_aControllers;
1418 
1419     Controllers::iterator aEnd = aCopy.end();
1420 	for ( Controllers::iterator aIter = aCopy.begin(); aIter != aEnd ; ++aIter )
1421 	{
1422 		if ( !aIter->is() )
1423             continue;
1424 
1425         try
1426         {
1427 			Reference< XCloseable> xFrame( (*aIter)->getFrame(), UNO_QUERY );
1428 			if ( xFrame.is() )
1429 				xFrame->close( _bDeliverOwnership );
1430         }
1431         catch( const CloseVetoException& ) { throw; }
1432         catch( const Exception& )
1433         {
1434             DBG_UNHANDLED_EXCEPTION();
1435         }
1436 	}
1437 }
1438 
1439 // -----------------------------------------------------------------------------
1440 struct DisposeControllerFrame : public ::std::unary_function< Reference< XController >, void >
1441 {
1442     void operator()( const Reference< XController >& _rxController ) const
1443     {
1444         try
1445         {
1446             if ( !_rxController.is() )
1447                 return;
1448 
1449             Reference< XFrame > xFrame( _rxController->getFrame() );
1450             ::comphelper::disposeComponent( xFrame );
1451         }
1452         catch( const Exception& )
1453         {
1454         	DBG_UNHANDLED_EXCEPTION();
1455         }
1456     };
1457 };
1458 
1459 // -----------------------------------------------------------------------------
1460 void ODatabaseDocument::impl_disposeControllerFrames_nothrow()
1461 {
1462     Controllers aCopy;
1463     aCopy.swap( m_aControllers );   // ensure m_aControllers is empty afterwards
1464     ::std::for_each( aCopy.begin(), aCopy.end(), DisposeControllerFrame() );
1465 }
1466 
1467 // -----------------------------------------------------------------------------
1468 void SAL_CALL ODatabaseDocument::close( sal_Bool _bDeliverOwnership ) throw (CloseVetoException, RuntimeException)
1469 {
1470     // nearly everything below can/must be done without our mutex locked, the below is just for
1471     // the checks for being disposed and the like
1472     // SYNCHRONIZED ->
1473     {
1474         DocumentGuard aGuard( *this );
1475         m_bClosing = true;
1476     }
1477     // <- SYNCHRONIZED
1478 
1479     try
1480     {
1481         // allow listeners to veto
1482         lang::EventObject aEvent( *this );
1483         m_aCloseListener.forEach< XCloseListener >(
1484             boost::bind( &XCloseListener::queryClosing, _1, boost::cref( aEvent ), boost::cref( _bDeliverOwnership ) ) );
1485 
1486         // notify that we're going to unload
1487 	    m_aEventNotifier.notifyDocumentEvent( "OnPrepareUnload" );
1488 
1489         impl_closeControllerFrames_nolck_throw( _bDeliverOwnership );
1490 
1491         m_aCloseListener.notifyEach( &XCloseListener::notifyClosing, (const lang::EventObject&)aEvent );
1492 
1493         dispose();
1494     }
1495     catch ( const Exception& )
1496     {
1497         ::osl::MutexGuard aGuard( m_aMutex );
1498         m_bClosing = false;
1499         throw;
1500     }
1501 
1502     // SYNCHRONIZED ->
1503     ::osl::MutexGuard aGuard( m_aMutex );
1504     m_bClosing = false;
1505     // <- SYNCHRONIZED
1506 }
1507 // -----------------------------------------------------------------------------
1508 void SAL_CALL ODatabaseDocument::addCloseListener( const Reference< ::com::sun::star::util::XCloseListener >& Listener ) throw (RuntimeException)
1509 {
1510     DocumentGuard aGuard( *this );
1511 	m_aCloseListener.addInterface(Listener);
1512 }
1513 // -----------------------------------------------------------------------------
1514 void SAL_CALL ODatabaseDocument::removeCloseListener( const Reference< ::com::sun::star::util::XCloseListener >& Listener ) throw (RuntimeException)
1515 {
1516     DocumentGuard aGuard( *this );
1517     m_aCloseListener.removeInterface(Listener);
1518 }
1519 // -----------------------------------------------------------------------------
1520 Reference< XNameAccess > SAL_CALL ODatabaseDocument::getFormDocuments(  ) throw (RuntimeException)
1521 {
1522     DocumentGuard aGuard( *this, DocumentGuard::MethodUsedDuringInit );
1523     return impl_getDocumentContainer_throw( ODatabaseModelImpl::E_FORM );
1524 }
1525 // -----------------------------------------------------------------------------
1526 Reference< XNameAccess > SAL_CALL ODatabaseDocument::getReportDocuments(  ) throw (RuntimeException)
1527 {
1528     DocumentGuard aGuard( *this, DocumentGuard::MethodUsedDuringInit );
1529     return impl_getDocumentContainer_throw( ODatabaseModelImpl::E_REPORT );
1530 }
1531 
1532 // -----------------------------------------------------------------------------
1533 void ODatabaseDocument::WriteThroughComponent( const Reference< XComponent >& xComponent, const sal_Char* pStreamName,
1534 	const sal_Char* pServiceName, const Sequence< Any >& _rArguments, const Sequence< PropertyValue >& rMediaDesc,
1535 	const Reference<XStorage>& _xStorageToSaveTo ) const
1536 {
1537 	OSL_ENSURE( pStreamName, "Need stream name!" );
1538 	OSL_ENSURE( pServiceName, "Need service name!" );
1539 
1540     // open stream
1541     ::rtl::OUString sStreamName = ::rtl::OUString::createFromAscii( pStreamName );
1542     Reference< XStream > xStream = _xStorageToSaveTo->openStreamElement( sStreamName, ElementModes::READWRITE | ElementModes::TRUNCATE );
1543     if ( !xStream.is() )
1544         return;
1545 
1546     Reference< XOutputStream > xOutputStream( xStream->getOutputStream() );
1547     OSL_ENSURE( xOutputStream.is(), "Can't create output stream in package!" );
1548     if ( !xOutputStream.is() )
1549         return;
1550 
1551     Reference< XSeekable > xSeek( xOutputStream, UNO_QUERY );
1552     if ( xSeek.is() )
1553         xSeek->seek(0);
1554 
1555     Reference< XPropertySet > xStreamProp( xOutputStream, UNO_QUERY_THROW );
1556     xStreamProp->setPropertyValue( INFO_MEDIATYPE, makeAny( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "text/xml" ) ) ) );
1557     xStreamProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Compressed" ) ), makeAny( (sal_Bool)sal_True ) );
1558 
1559 	// write the stuff
1560 	WriteThroughComponent( xOutputStream, xComponent, pServiceName, _rArguments, rMediaDesc );
1561 }
1562 
1563 void ODatabaseDocument::WriteThroughComponent( const Reference< XOutputStream >& xOutputStream,
1564     const Reference< XComponent >& xComponent, const sal_Char* pServiceName, const Sequence< Any >& _rArguments,
1565 	const Sequence< PropertyValue >& rMediaDesc ) const
1566 {
1567 	OSL_ENSURE( xOutputStream.is(), "I really need an output stream!" );
1568 	OSL_ENSURE( xComponent.is(), "Need component!" );
1569 	OSL_ENSURE( NULL != pServiceName, "Need component name!" );
1570 
1571 	// get component
1572 	Reference< XActiveDataSource > xSaxWriter;
1573     OSL_VERIFY( m_pImpl->m_aContext.createComponent( "com.sun.star.xml.sax.Writer", xSaxWriter ) );
1574 	if ( !xSaxWriter.is() )
1575 		return;
1576 
1577 	// connect XML writer to output stream
1578 	xSaxWriter->setOutputStream( xOutputStream );
1579 
1580 	// prepare arguments (prepend doc handler to given arguments)
1581 	Reference< XDocumentHandler > xDocHandler( xSaxWriter,UNO_QUERY);
1582 	Sequence<Any> aArgs( 1 + _rArguments.getLength() );
1583 	aArgs[0] <<= xDocHandler;
1584 	for ( sal_Int32 i = 0; i < _rArguments.getLength(); ++i )
1585 		aArgs[ i+1 ] = _rArguments[i];
1586 
1587 	// get filter component
1588 	Reference< XExporter > xExporter;
1589     OSL_VERIFY( m_pImpl->m_aContext.createComponentWithArguments( pServiceName, aArgs, xExporter ) );
1590 	if ( !xExporter.is() )
1591 		return;
1592 
1593 	// connect model and filter
1594 	xExporter->setSourceDocument( xComponent );
1595 
1596 	// filter
1597     Reference< XFilter > xFilter( xExporter, UNO_QUERY_THROW );
1598 	xFilter->filter( rMediaDesc );
1599 }
1600 
1601 // -----------------------------------------------------------------------------
1602 void ODatabaseDocument::impl_writeStorage_throw( const Reference< XStorage >& _rxTargetStorage, const ::comphelper::NamedValueCollection& _rMediaDescriptor ) const
1603 {
1604 	// extract status indicator
1605     Sequence< Any > aDelegatorArguments;
1606     lcl_extractStatusIndicator( _rMediaDescriptor, aDelegatorArguments );
1607 
1608     /** property map for export info set */
1609 	comphelper::PropertyMapEntry aExportInfoMap[] =
1610 	{
1611         { MAP_LEN( "BaseURI"), 0,&::getCppuType( (::rtl::OUString *)0 ),beans::PropertyAttribute::MAYBEVOID, 0 },
1612         { MAP_LEN( "StreamName"), 0,&::getCppuType( (::rtl::OUString *)0 ),beans::PropertyAttribute::MAYBEVOID, 0 },
1613 		{ MAP_LEN( "UsePrettyPrinting" ), 0, &::getCppuType((sal_Bool*)0), beans::PropertyAttribute::MAYBEVOID, 0},
1614 		{ NULL, 0, 0, NULL, 0, 0 }
1615 	};
1616 	uno::Reference< beans::XPropertySet > xInfoSet( comphelper::GenericPropertySet_CreateInstance( new comphelper::PropertySetInfo( aExportInfoMap ) ) );
1617 
1618     SvtSaveOptions aSaveOpt;
1619     xInfoSet->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("UsePrettyPrinting")), uno::makeAny(aSaveOpt.IsPrettyPrinting()));
1620     if ( aSaveOpt.IsSaveRelFSys() )
1621         xInfoSet->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BaseURI")), uno::makeAny(_rMediaDescriptor.getOrDefault("URL",::rtl::OUString())));
1622 
1623     ::rtl::OUString aVersion;
1624     SvtSaveOptions::ODFDefaultVersion nDefVersion = aSaveOpt.GetODFDefaultVersion();
1625 
1626     // older versions can not have this property set, it exists only starting from ODF1.2
1627     if ( nDefVersion >= SvtSaveOptions::ODFVER_012 )
1628         aVersion = ODFVER_012_TEXT;
1629 
1630     if ( aVersion.getLength() )
1631     {
1632         try
1633         {
1634             xInfoSet->setPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "Version" )), uno::makeAny( aVersion ) );
1635         }
1636         catch( uno::Exception& )
1637         {
1638         }
1639     }
1640 
1641     sal_Int32 nArgsLen = aDelegatorArguments.getLength();
1642     aDelegatorArguments.realloc(nArgsLen+1);
1643     aDelegatorArguments[nArgsLen++] <<= xInfoSet;
1644 
1645 	Reference< XPropertySet > xProp( _rxTargetStorage, UNO_QUERY_THROW );
1646     xProp->setPropertyValue( INFO_MEDIATYPE, makeAny( (rtl::OUString)MIMETYPE_OASIS_OPENDOCUMENT_DATABASE ) );
1647 
1648 	Reference< XComponent > xComponent( *const_cast< ODatabaseDocument* >( this ), UNO_QUERY_THROW );
1649 
1650     Sequence< PropertyValue > aMediaDescriptor;
1651     _rMediaDescriptor >>= aMediaDescriptor;
1652 
1653     xInfoSet->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StreamName")), uno::makeAny(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("settings.xml"))));
1654     WriteThroughComponent( xComponent, "settings.xml", "com.sun.star.comp.sdb.XMLSettingsExporter",
1655         aDelegatorArguments, aMediaDescriptor, _rxTargetStorage );
1656 
1657     xInfoSet->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StreamName")), uno::makeAny(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("content.xml"))));
1658     WriteThroughComponent( xComponent, "content.xml", "com.sun.star.comp.sdb.DBExportFilter",
1659         aDelegatorArguments, aMediaDescriptor, _rxTargetStorage );
1660 
1661     m_pImpl->storeLibraryContainersTo( _rxTargetStorage );
1662 }
1663 
1664 // -----------------------------------------------------------------------------
1665 Reference< XUIConfigurationManager > SAL_CALL ODatabaseDocument::getUIConfigurationManager(  ) throw (RuntimeException)
1666 {
1667     DocumentGuard aGuard( *this );
1668 
1669 	if ( !m_xUIConfigurationManager.is() )
1670     {
1671         m_pImpl->m_aContext.createComponent( "com.sun.star.ui.UIConfigurationManager", m_xUIConfigurationManager );
1672         Reference< XUIConfigurationStorage > xUIConfigStorage( m_xUIConfigurationManager, UNO_QUERY );
1673         if ( xUIConfigStorage.is() )
1674         {
1675             rtl::OUString aUIConfigFolderName( RTL_CONSTASCII_USTRINGPARAM( "Configurations2" ));
1676             Reference< XStorage > xConfigStorage;
1677 
1678             // First try to open with READWRITE and then READ
1679             xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, ElementModes::READWRITE );
1680             if ( xConfigStorage.is() )
1681             {
1682                 rtl::OUString aUIConfigMediaType( RTL_CONSTASCII_USTRINGPARAM( "application/vnd.sun.xml.ui.configuration" ));
1683                 rtl::OUString aMediaType;
1684 				Reference< XPropertySet > xPropSet( xConfigStorage, UNO_QUERY );
1685                 Any a = xPropSet->getPropertyValue( INFO_MEDIATYPE );
1686                 if ( !( a >>= aMediaType ) || ( aMediaType.getLength() == 0 ))
1687                 {
1688                     a <<= aUIConfigMediaType;
1689                     xPropSet->setPropertyValue( INFO_MEDIATYPE, a );
1690                 }
1691             }
1692             else
1693                 xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, ElementModes::READ );
1694 
1695             // initialize ui configuration manager with document substorage
1696             xUIConfigStorage->setStorage( xConfigStorage );
1697         }
1698     }
1699 
1700     return m_xUIConfigurationManager;
1701 }
1702 // -----------------------------------------------------------------------------
1703 Reference< XStorage > SAL_CALL ODatabaseDocument::getDocumentSubStorage( const ::rtl::OUString& aStorageName, sal_Int32 nMode ) throw (RuntimeException)
1704 {
1705     DocumentGuard aGuard( *this );
1706 
1707     Reference< XDocumentSubStorageSupplier > xStorageAccess( m_pImpl->getDocumentSubStorageSupplier() );
1708     return xStorageAccess->getDocumentSubStorage( aStorageName, nMode );
1709 }
1710 // -----------------------------------------------------------------------------
1711 Sequence< ::rtl::OUString > SAL_CALL ODatabaseDocument::getDocumentSubStoragesNames(  ) throw (::com::sun::star::io::IOException, RuntimeException)
1712 {
1713     Reference< XDocumentSubStorageSupplier > xStorageAccess( m_pImpl->getDocumentSubStorageSupplier() );
1714     return xStorageAccess->getDocumentSubStoragesNames();
1715 }
1716 
1717 //------------------------------------------------------------------------------
1718 void ODatabaseDocument::impl_notifyStorageChange_nolck_nothrow( const Reference< XStorage >& _rxNewRootStorage )
1719 {
1720     Reference< XInterface > xMe( *const_cast< ODatabaseDocument* >( this ) );
1721 
1722     m_aStorageListeners.forEach< XStorageChangeListener >(
1723         boost::bind( &XStorageChangeListener::notifyStorageChange, _1, boost::cref( xMe ), boost::cref( _rxNewRootStorage ) ) );
1724 }
1725 
1726 //------------------------------------------------------------------------------
1727 void ODatabaseDocument::disposing()
1728 {
1729     OSL_TRACE( "DD: disp: %p: %p", this, m_pImpl.get() );
1730     if ( !m_pImpl.is() )
1731     {
1732         // this means that we're already disposed
1733         DBG_ASSERT( ODatabaseDocument_OfficeDocument::rBHelper.bDisposed, "ODatabaseDocument::disposing: no impl anymore, but not yet disposed!" );
1734         return;
1735     }
1736 
1737     if ( impl_isInitialized() )
1738 	    m_aEventNotifier.notifyDocumentEvent( "OnUnload" );
1739 
1740     Reference< XModel > xHoldAlive( this );
1741 
1742     m_aEventNotifier.disposing();
1743 
1744     lang::EventObject aDisposeEvent(static_cast<XWeak*>(this));
1745     m_aModifyListeners.disposeAndClear( aDisposeEvent );
1746     m_aCloseListener.disposeAndClear( aDisposeEvent );
1747     m_aStorageListeners.disposeAndClear( aDisposeEvent );
1748 
1749     // this is the list of objects which we currently hold as member. Upon resetting
1750     // those members, we can (potentially) release the last reference to them, in which
1751     // case they will be deleted - if they're C++ implementations, that is :).
1752     // Some of those implementations are offending enough to require the SolarMutex, which
1753     // means we should not release the last reference while our own mutex is locked ...
1754     ::std::list< Reference< XInterface > > aKeepAlive;
1755 
1756     // SYNCHRONIZED ->
1757     ::osl::ClearableMutexGuard aGuard( m_aMutex );
1758 
1759     DBG_ASSERT( m_aControllers.empty(), "ODatabaseDocument::disposing: there still are controllers!" );
1760         // normally, nobody should explicitly dispose, but only XCloseable::close the document. And upon
1761         // closing, our controllers are closed, too
1762 
1763     aKeepAlive.push_back( m_xUIConfigurationManager );
1764     m_xUIConfigurationManager = NULL;
1765 
1766     clearObjectContainer( m_xForms );
1767 	clearObjectContainer( m_xReports );
1768 
1769     // reset the macro mode: in case the our impl struct stays alive (e.g. because our DataSource
1770     // object still exists), and somebody subsequently re-opens the document, we want to have
1771     // the security warning, again.
1772     m_pImpl->resetMacroExecutionMode();
1773 
1774     // similar argueing for our ViewMonitor
1775     m_aViewMonitor.reset();
1776 
1777     // tell our Impl to forget us
1778     m_pImpl->modelIsDisposing( impl_isInitialized(), ODatabaseModelImpl::ResetModelAccess() );
1779 
1780     // now, at the latest, the controller array should be empty. Controllers are
1781     // expected to listen for our disposal, and disconnect then
1782     DBG_ASSERT( m_aControllers.empty(), "ODatabaseDocument::disposing: there still are controllers!" );
1783     impl_disposeControllerFrames_nothrow();
1784 
1785     aKeepAlive.push_back( m_xModuleManager );
1786     m_xModuleManager.clear();
1787 
1788     aKeepAlive.push_back( m_xTitleHelper );
1789     m_xTitleHelper.clear();
1790 
1791 	m_pImpl.clear();
1792 
1793     aGuard.clear();
1794     // <- SYNCHRONIZED
1795 
1796     aKeepAlive.clear();
1797 }
1798 // -----------------------------------------------------------------------------
1799 // XComponent
1800 void SAL_CALL ODatabaseDocument::dispose(  ) throw (RuntimeException)
1801 {
1802     ::cppu::WeakComponentImplHelperBase::dispose();
1803 }
1804 // -----------------------------------------------------------------------------
1805 void SAL_CALL ODatabaseDocument::addEventListener( const Reference< lang::XEventListener >& _xListener ) throw (RuntimeException)
1806 {
1807 	::cppu::WeakComponentImplHelperBase::addEventListener( _xListener );
1808 }
1809 // -----------------------------------------------------------------------------
1810 void SAL_CALL ODatabaseDocument::removeEventListener( const Reference< lang::XEventListener >& _xListener ) throw (RuntimeException)
1811 {
1812 	::cppu::WeakComponentImplHelperBase::removeEventListener( _xListener );
1813 }
1814 // XServiceInfo
1815 //------------------------------------------------------------------------------
1816 rtl::OUString ODatabaseDocument::getImplementationName(  ) throw(RuntimeException)
1817 {
1818 	return getImplementationName_static();
1819 }
1820 
1821 //------------------------------------------------------------------------------
1822 rtl::OUString ODatabaseDocument::getImplementationName_static(  ) throw(RuntimeException)
1823 {
1824 	return rtl::OUString::createFromAscii("com.sun.star.comp.dba.ODatabaseDocument");
1825 }
1826 
1827 //------------------------------------------------------------------------------
1828 Sequence< ::rtl::OUString > ODatabaseDocument::getSupportedServiceNames(  ) throw (RuntimeException)
1829 {
1830 	return getSupportedServiceNames_static();
1831 }
1832 
1833 //------------------------------------------------------------------------------
1834 Reference< XInterface > ODatabaseDocument::Create( const Reference< XComponentContext >& _rxContext )
1835 {
1836     ::comphelper::ComponentContext aContext( _rxContext );
1837     Reference< XUnoTunnel > xDBContextTunnel( aContext.createComponent( (::rtl::OUString)SERVICE_SDB_DATABASECONTEXT ), UNO_QUERY_THROW );
1838     ODatabaseContext* pContext = reinterpret_cast< ODatabaseContext* >( xDBContextTunnel->getSomething( ODatabaseContext::getUnoTunnelImplementationId() ) );
1839 
1840 	::rtl::Reference<ODatabaseModelImpl> pImpl( new ODatabaseModelImpl( aContext.getLegacyServiceFactory(), *pContext ) );
1841     Reference< XModel > xModel( pImpl->createNewModel_deliverOwnership( false ) );
1842     return xModel.get();
1843 }
1844 
1845 //------------------------------------------------------------------------------
1846 Sequence< ::rtl::OUString > ODatabaseDocument::getSupportedServiceNames_static(  ) throw (RuntimeException)
1847 {
1848 	Sequence< ::rtl::OUString > aSNS( 2 );
1849 	aSNS[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.OfficeDatabaseDocument"));
1850 	aSNS[1] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.OfficeDocument"));
1851 	return aSNS;
1852 }
1853 
1854 //------------------------------------------------------------------------------
1855 sal_Bool ODatabaseDocument::supportsService( const ::rtl::OUString& _rServiceName ) throw (RuntimeException)
1856 {
1857 	return ::comphelper::findValue(getSupportedServiceNames(), _rServiceName, sal_True).getLength() != 0;
1858 }
1859 // -----------------------------------------------------------------------------
1860 Reference< XDataSource > SAL_CALL ODatabaseDocument::getDataSource() throw (RuntimeException)
1861 {
1862     DocumentGuard aGuard( *this, DocumentGuard::MethodWithoutInit );
1863     return m_pImpl->getOrCreateDataSource();
1864 }
1865 
1866 // -----------------------------------------------------------------------------
1867 void SAL_CALL ODatabaseDocument::loadFromStorage( const Reference< XStorage >& /*xStorage*/, const Sequence< PropertyValue >& /*aMediaDescriptor*/ ) throw (IllegalArgumentException, DoubleInitializationException, IOException, Exception, RuntimeException)
1868 {
1869     DocumentGuard aGuard( *this );
1870 
1871     throw Exception(
1872         DBACORE_RESSTRING( RID_STR_NO_EMBEDDING ),
1873         *this
1874     );
1875 }
1876 
1877 // -----------------------------------------------------------------------------
1878 void SAL_CALL ODatabaseDocument::storeToStorage( const Reference< XStorage >& _rxStorage, const Sequence< PropertyValue >& _rMediaDescriptor ) throw (IllegalArgumentException, IOException, Exception, RuntimeException)
1879 {
1880     DocumentGuard aGuard( *this );
1881     impl_storeToStorage_throw( _rxStorage, _rMediaDescriptor, aGuard );
1882 }
1883 
1884 // -----------------------------------------------------------------------------
1885 void SAL_CALL ODatabaseDocument::switchToStorage( const Reference< XStorage >& _rxNewRootStorage ) throw (IllegalArgumentException, IOException, Exception, RuntimeException)
1886 {
1887     DocumentGuard aGuard( *this );
1888 
1889     Reference< XStorage > xNewRootStorage( m_pImpl->switchToStorage( _rxNewRootStorage ) );
1890 
1891     aGuard.clear();
1892     impl_notifyStorageChange_nolck_nothrow( xNewRootStorage );
1893 }
1894 
1895 // -----------------------------------------------------------------------------
1896 Reference< XStorage > SAL_CALL ODatabaseDocument::getDocumentStorage(  ) throw (IOException, Exception, RuntimeException)
1897 {
1898     DocumentGuard aGuard( *this );
1899     return m_pImpl->getOrCreateRootStorage();
1900 }
1901 
1902 // -----------------------------------------------------------------------------
1903 void SAL_CALL ODatabaseDocument::addStorageChangeListener( const Reference< XStorageChangeListener >& _Listener ) throw (RuntimeException)
1904 {
1905     DocumentGuard aGuard( *this );
1906     m_aStorageListeners.addInterface( _Listener );
1907 }
1908 
1909 // -----------------------------------------------------------------------------
1910 void SAL_CALL ODatabaseDocument::removeStorageChangeListener( const Reference< XStorageChangeListener >& _Listener ) throw (RuntimeException)
1911 {
1912     DocumentGuard aGuard( *this );
1913     m_aStorageListeners.addInterface( _Listener );
1914 }
1915 
1916 // -----------------------------------------------------------------------------
1917 Reference< XStorageBasedLibraryContainer > SAL_CALL ODatabaseDocument::getBasicLibraries() throw (RuntimeException)
1918 {
1919     DocumentGuard aGuard( *this, DocumentGuard::MethodUsedDuringInit );
1920     return m_pImpl->getLibraryContainer( true );
1921 }
1922 
1923 // -----------------------------------------------------------------------------
1924 Reference< XStorageBasedLibraryContainer > SAL_CALL ODatabaseDocument::getDialogLibraries() throw (RuntimeException)
1925 {
1926     DocumentGuard aGuard( *this );
1927     return m_pImpl->getLibraryContainer( false );
1928 }
1929 
1930 // -----------------------------------------------------------------------------
1931 ::sal_Bool SAL_CALL ODatabaseDocument::getAllowMacroExecution() throw (RuntimeException)
1932 {
1933     DocumentGuard aGuard( *this );
1934     return m_pImpl->adjustMacroMode_AutoReject();
1935 }
1936 
1937 // -----------------------------------------------------------------------------
1938 Reference< XEmbeddedScripts > SAL_CALL ODatabaseDocument::getScriptContainer() throw (RuntimeException)
1939 {
1940     DocumentGuard aGuard( *this );
1941     return this;
1942 }
1943 
1944 // -----------------------------------------------------------------------------
1945 Reference< provider::XScriptProvider > SAL_CALL ODatabaseDocument::getScriptProvider(  ) throw (RuntimeException)
1946 {
1947     DocumentGuard aGuard( *this );
1948 
1949     Reference< XScriptProvider > xScriptProvider( m_xScriptProvider );
1950     if ( !xScriptProvider.is() )
1951     {
1952         Reference < XScriptProviderFactory > xFactory(
1953             m_pImpl->m_aContext.getSingleton( "com.sun.star.script.provider.theMasterScriptProviderFactory" ), UNO_QUERY_THROW );
1954 
1955         Any aScriptProviderContext;
1956         if ( m_bAllowDocumentScripting )
1957             aScriptProviderContext <<= Reference< XModel >( this );
1958 
1959         xScriptProvider.set( xFactory->createScriptProvider( aScriptProviderContext ), UNO_SET_THROW );
1960         m_xScriptProvider = xScriptProvider;
1961     }
1962 
1963     return xScriptProvider;
1964 }
1965 
1966 // -----------------------------------------------------------------------------
1967 Reference< XNameReplace > SAL_CALL ODatabaseDocument::getEvents(  ) throw (RuntimeException)
1968 {
1969     DocumentGuard aGuard( *this, DocumentGuard::MethodUsedDuringInit );
1970     return m_pEventContainer;
1971 }
1972 
1973 // -----------------------------------------------------------------------------
1974 void SAL_CALL ODatabaseDocument::disposing( const ::com::sun::star::lang::EventObject& Source ) throw(RuntimeException)
1975 {
1976 	if ( m_pImpl.is() )
1977 		m_pImpl->disposing(Source);
1978 }
1979 
1980 //------------------------------------------------------------------
1981 Reference< XInterface > ODatabaseDocument::getThis() const
1982 {
1983     return *const_cast< ODatabaseDocument* >( this );
1984 }
1985 // -----------------------------------------------------------------------------
1986 struct CreateAny : public ::std::unary_function< Reference<XController>, Any>
1987 {
1988     Any operator() (const Reference<XController>& lhs) const
1989     {
1990         return makeAny(lhs);
1991     }
1992 };
1993 
1994 // XModel2
1995 Reference< XEnumeration > SAL_CALL ODatabaseDocument::getControllers(  ) throw (RuntimeException)
1996 {
1997     DocumentGuard aGuard( *this );
1998     uno::Sequence< Any> aController( m_aControllers.size() );
1999     ::std::transform( m_aControllers.begin(), m_aControllers.end(), aController.getArray(), CreateAny() );
2000     return new ::comphelper::OAnyEnumeration(aController);
2001 }
2002 // -----------------------------------------------------------------------------
2003 Sequence< ::rtl::OUString > SAL_CALL ODatabaseDocument::getAvailableViewControllerNames(  ) throw (RuntimeException)
2004 {
2005     Sequence< ::rtl::OUString > aNames(1);
2006     aNames[0] = SERVICE_SDB_APPLICATIONCONTROLLER;
2007     return aNames;
2008 }
2009 // -----------------------------------------------------------------------------
2010 Reference< XController2 > SAL_CALL ODatabaseDocument::createDefaultViewController( const Reference< XFrame >& _Frame ) throw (IllegalArgumentException, Exception, RuntimeException)
2011 {
2012     return createViewController(
2013         ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Default" ) ),
2014         Sequence< PropertyValue >(),
2015         _Frame
2016     );
2017 }
2018 
2019 // -----------------------------------------------------------------------------
2020 Reference< XController2 > SAL_CALL ODatabaseDocument::createViewController( const ::rtl::OUString& _ViewName, const Sequence< PropertyValue >& _Arguments, const Reference< XFrame >& _Frame ) throw (IllegalArgumentException, Exception, RuntimeException)
2021 {
2022     if ( !_ViewName.equalsAscii( "Default" ) && !_ViewName.equalsAscii( "Preview" ) )
2023         throw IllegalArgumentException( ::rtl::OUString(), *this, 1 );
2024     if ( !_Frame.is() )
2025         throw IllegalArgumentException( ::rtl::OUString(), *this, 3 );
2026 
2027     DocumentGuard aGuard( *this );
2028     ::comphelper::ComponentContext aContext( m_pImpl->m_aContext );
2029     aGuard.clear();
2030 
2031     Reference< XController2 > xController;
2032     aContext.createComponent( "org.openoffice.comp.dbu.OApplicationController", xController );
2033 
2034     ::comphelper::NamedValueCollection aInitArgs( _Arguments );
2035     aInitArgs.put( "Frame", _Frame );
2036     if ( _ViewName.equalsAscii( "Preview" ) )
2037         aInitArgs.put( "Preview", sal_Bool( sal_True ) );
2038     Reference< XInitialization > xInitController( xController, UNO_QUERY_THROW );
2039     xInitController->initialize( aInitArgs.getWrappedPropertyValues() );
2040 
2041     return xController;
2042 }
2043 
2044 // -----------------------------------------------------------------------------
2045 //=============================================================================
2046 Reference< XTitle > ODatabaseDocument::impl_getTitleHelper_throw()
2047 {
2048     if ( ! m_xTitleHelper.is ())
2049     {
2050 		Reference< XUntitledNumbers > xDesktop(
2051             m_pImpl->m_aContext.createComponent( "com.sun.star.frame.Desktop" ),
2052             UNO_QUERY_THROW );
2053         uno::Reference< frame::XModel > xThis   (getThis(), uno::UNO_QUERY_THROW);
2054 
2055         ::framework::TitleHelper* pHelper = new ::framework::TitleHelper(m_pImpl->m_aContext.getLegacyServiceFactory());
2056         m_xTitleHelper.set(static_cast< ::cppu::OWeakObject* >(pHelper), uno::UNO_QUERY_THROW);
2057         pHelper->setOwner                   (xThis   );
2058         pHelper->connectWithUntitledNumbers (xDesktop);
2059     }
2060 
2061     return m_xTitleHelper;
2062 }
2063 
2064 //=============================================================================
2065 uno::Reference< frame::XUntitledNumbers > ODatabaseDocument::impl_getUntitledHelper_throw(const uno::Reference< uno::XInterface >& _xComponent)
2066 {
2067     if ( !m_xModuleManager.is() )
2068 		m_xModuleManager.set( m_pImpl->m_aContext.createComponent( "com.sun.star.frame.ModuleManager" ), UNO_QUERY_THROW );
2069 
2070 	::rtl::OUString sModuleId;
2071 	try
2072 	{
2073 		sModuleId = m_xModuleManager->identify( _xComponent );
2074 	}
2075 	catch(uno::Exception)
2076 	{
2077 		// ni
2078 	}
2079     uno::Reference< frame::XUntitledNumbers > xNumberedControllers;
2080 
2081     TNumberedController::iterator aFind = m_aNumberedControllers.find(sModuleId);
2082     if ( aFind == m_aNumberedControllers.end() )
2083     {
2084         uno::Reference< frame::XModel > xThis(static_cast< frame::XModel* >(this), uno::UNO_QUERY_THROW);
2085         ::comphelper::NumberedCollection* pHelper = new ::comphelper::NumberedCollection();
2086         xNumberedControllers.set(static_cast< ::cppu::OWeakObject* >(pHelper), uno::UNO_QUERY_THROW);
2087 
2088         pHelper->setOwner          (xThis);
2089         //pHelper->setUntitledPrefix (::rtl::OUString::createFromAscii(" : "));
2090 
2091         m_aNumberedControllers.insert(TNumberedController::value_type(sModuleId,xNumberedControllers));
2092     }
2093     else
2094         xNumberedControllers = aFind->second;
2095 
2096     return xNumberedControllers;
2097 }
2098 
2099 //=============================================================================
2100 // css.frame.XTitle
2101 ::rtl::OUString SAL_CALL ODatabaseDocument::getTitle()
2102     throw (uno::RuntimeException)
2103 {
2104     // SYNCHRONIZED ->
2105     DocumentGuard aGuard( *this, DocumentGuard::MethodUsedDuringInit );
2106     return impl_getTitleHelper_throw()->getTitle();
2107 }
2108 
2109 //=============================================================================
2110 // css.frame.XTitle
2111 void SAL_CALL ODatabaseDocument::setTitle( const ::rtl::OUString& sTitle )
2112     throw (uno::RuntimeException)
2113 {
2114     // SYNCHRONIZED ->
2115     DocumentGuard aGuard( *this );
2116     impl_getTitleHelper_throw()->setTitle( sTitle );
2117     m_aEventNotifier.notifyDocumentEventAsync( "OnTitleChanged" );
2118     // <- SYNCHRONIZED
2119 }
2120 
2121 //=============================================================================
2122 // css.frame.XTitleChangeBroadcaster
2123 void SAL_CALL ODatabaseDocument::addTitleChangeListener( const uno::Reference< frame::XTitleChangeListener >& xListener )
2124     throw (uno::RuntimeException)
2125 {
2126     // SYNCHRONIZED ->
2127     DocumentGuard aGuard( *this );
2128 
2129     uno::Reference< frame::XTitleChangeBroadcaster > xBroadcaster( impl_getTitleHelper_throw(), uno::UNO_QUERY_THROW );
2130     xBroadcaster->addTitleChangeListener( xListener );
2131 }
2132 
2133 //=============================================================================
2134 // css.frame.XTitleChangeBroadcaster
2135 void SAL_CALL ODatabaseDocument::removeTitleChangeListener( const uno::Reference< frame::XTitleChangeListener >& xListener )
2136     throw (uno::RuntimeException)
2137 {
2138     // SYNCHRONIZED ->
2139     DocumentGuard aGuard( *this );
2140 
2141     uno::Reference< frame::XTitleChangeBroadcaster > xBroadcaster( impl_getTitleHelper_throw(), uno::UNO_QUERY_THROW );
2142     xBroadcaster->removeTitleChangeListener( xListener );
2143 }
2144 
2145 //=============================================================================
2146 // css.frame.XUntitledNumbers
2147 ::sal_Int32 SAL_CALL ODatabaseDocument::leaseNumber( const uno::Reference< uno::XInterface >& xComponent )
2148     throw (lang::IllegalArgumentException,
2149            uno::RuntimeException         )
2150 {
2151     DocumentGuard aGuard( *this );
2152     return impl_getUntitledHelper_throw(xComponent)->leaseNumber (xComponent);
2153 }
2154 
2155 //=============================================================================
2156 // css.frame.XUntitledNumbers
2157 void SAL_CALL ODatabaseDocument::releaseNumber( ::sal_Int32 nNumber )
2158     throw (lang::IllegalArgumentException,
2159            uno::RuntimeException         )
2160 {
2161     DocumentGuard aGuard( *this );
2162     impl_getUntitledHelper_throw()->releaseNumber (nNumber);
2163 }
2164 
2165 //=============================================================================
2166 // css.frame.XUntitledNumbers
2167 void SAL_CALL ODatabaseDocument::releaseNumberForComponent( const uno::Reference< uno::XInterface >& xComponent )
2168     throw (lang::IllegalArgumentException,
2169            uno::RuntimeException         )
2170 {
2171     DocumentGuard aGuard( *this );
2172     impl_getUntitledHelper_throw(xComponent)->releaseNumberForComponent (xComponent);
2173 }
2174 
2175 //=============================================================================
2176 // css.frame.XUntitledNumbers
2177 ::rtl::OUString SAL_CALL ODatabaseDocument::getUntitledPrefix()    throw (uno::RuntimeException)
2178 {
2179     return ::rtl::OUString();/*RTL_CONSTASCII_USTRINGPARAM(" : "));*/
2180 }
2181 
2182 //------------------------------------------------------------------
2183 //........................................................................
2184 }	// namespace dbaccess
2185 //........................................................................
2186 
2187 
2188