Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "documentdefinition.hxx"
21 : #include "dbastrings.hrc"
22 : #include "sdbcoretools.hxx"
23 : #include <tools/debug.hxx>
24 : #include <tools/diagnose_ex.h>
25 : #include <osl/diagnose.h>
26 : #include <comphelper/property.hxx>
27 : #include <comphelper/sequence.hxx>
28 : #include <comphelper/namedvaluecollection.hxx>
29 : #include <comphelper/classids.hxx>
30 : #include <com/sun/star/frame/XUntitledNumbers.hpp>
31 : #include <com/sun/star/awt/XTopWindow.hpp>
32 : #include <com/sun/star/awt/Size.hpp>
33 : #include <com/sun/star/lang/DisposedException.hpp>
34 : #include <com/sun/star/beans/PropertyAttribute.hpp>
35 : #include <com/sun/star/frame/Desktop.hpp>
36 : #include <com/sun/star/frame/XModel.hpp>
37 : #include <com/sun/star/frame/XTitle.hpp>
38 : #include <com/sun/star/frame/XController.hpp>
39 : #include <com/sun/star/task/XJobExecutor.hpp>
40 : #include <com/sun/star/frame/XDispatchProviderInterception.hpp>
41 : #include <com/sun/star/frame/XFramesSupplier.hpp>
42 : #include <com/sun/star/ucb/InsertCommandArgument.hpp>
43 : #include <com/sun/star/report/XReportDefinition.hpp>
44 : #include <com/sun/star/report/XReportEngine.hpp>
45 : #include <com/sun/star/ucb/OpenMode.hpp>
46 : #include <com/sun/star/embed/XEmbedObjectFactory.hpp>
47 : #include <com/sun/star/embed/EmbeddedObjectCreator.hpp>
48 : #include <com/sun/star/embed/Aspects.hpp>
49 : #include <com/sun/star/embed/OOoEmbeddedObjectFactory.hpp>
50 : #include <ucbhelper/cancelcommandexecution.hxx>
51 : #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
52 : #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
53 : #include <com/sun/star/embed/ElementModes.hpp>
54 : #include <com/sun/star/embed/XEmbedPersist.hpp>
55 : #include <com/sun/star/embed/EmbedStates.hpp>
56 : #include <com/sun/star/embed/XComponentSupplier.hpp>
57 : #include <com/sun/star/embed/EntryInitModes.hpp>
58 : #include <com/sun/star/ucb/MissingPropertiesException.hpp>
59 : #include <com/sun/star/ucb/MissingInputStreamException.hpp>
60 : #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
61 : #include <com/sun/star/util/XCloseBroadcaster.hpp>
62 : #include <com/sun/star/frame/XModule.hpp>
63 : #include <com/sun/star/datatransfer/DataFlavor.hpp>
64 : #include <com/sun/star/datatransfer/XTransferable.hpp>
65 : #include <com/sun/star/container/XNameContainer.hpp>
66 : #include <com/sun/star/embed/XTransactedObject.hpp>
67 : #include <com/sun/star/embed/XCommonEmbedPersist.hpp>
68 : #include "intercept.hxx"
69 : #include <com/sun/star/sdb/ErrorCondition.hpp>
70 : #include <com/sun/star/sdb/XInteractionDocumentSave.hpp>
71 : #include <com/sun/star/task/InteractionHandler.hpp>
72 : #include <com/sun/star/sdb/DocumentSaveRequest.hpp>
73 : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
74 : #include <com/sun/star/document/MacroExecMode.hpp>
75 : #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
76 : #include <com/sun/star/container/XIndexContainer.hpp>
77 : #include <com/sun/star/form/XFormsSupplier.hpp>
78 : #include <com/sun/star/form/XForm.hpp>
79 : #include <comphelper/interaction.hxx>
80 : #include <connectivity/dbtools.hxx>
81 : #include <vcl/svapp.hxx>
82 : #include <osl/mutex.hxx>
83 : #include <sal/macros.h>
84 : #include <com/sun/star/view/XViewSettingsSupplier.hpp>
85 : #include "core_resource.hxx"
86 : #include "core_resource.hrc"
87 : #include "datasource.hxx"
88 : #include <com/sun/star/embed/XStateChangeBroadcaster.hpp>
89 : #include <com/sun/star/task/XInteractionApprove.hpp>
90 : #include <com/sun/star/task/XInteractionDisapprove.hpp>
91 : #include <com/sun/star/frame/XLayoutManager.hpp>
92 : #include <cppuhelper/compbase1.hxx>
93 : #include <cppuhelper/exc_hlp.hxx>
94 : #include <com/sun/star/frame/FrameSearchFlag.hpp>
95 : #include <comphelper/sequenceashashmap.hxx>
96 : #include <comphelper/mimeconfighelper.hxx>
97 : #include <comphelper/storagehelper.hxx>
98 : #include <com/sun/star/container/XContentEnumerationAccess.hpp>
99 : #include <com/sun/star/io/WrongFormatException.hpp>
100 : #include <com/sun/star/sdb/application/XDatabaseDocumentUI.hpp>
101 : #include <com/sun/star/sdb/application/DatabaseObject.hpp>
102 : #include <com/sun/star/util/XModifiable2.hpp>
103 :
104 : using namespace ::com::sun::star;
105 : using namespace view;
106 : using namespace uno;
107 : using namespace util;
108 : using namespace ucb;
109 : using namespace beans;
110 : using namespace lang;
111 : using namespace awt;
112 : using namespace embed;
113 : using namespace frame;
114 : using namespace document;
115 : using namespace sdbc;
116 : using namespace sdb;
117 : using namespace io;
118 : using namespace container;
119 : using namespace datatransfer;
120 : using namespace task;
121 : using namespace form;
122 : using namespace drawing;
123 : using namespace ::osl;
124 : using namespace ::comphelper;
125 : using namespace ::cppu;
126 :
127 : using sdb::application::XDatabaseDocumentUI;
128 : namespace DatabaseObject = sdb::application::DatabaseObject;
129 :
130 : #define DEFAULT_WIDTH 10000
131 : #define DEFAULT_HEIGHT 7500
132 :
133 : namespace dbaccess
134 : {
135 :
136 : typedef ::boost::optional< bool > optional_bool;
137 :
138 : // helper
139 : namespace
140 : {
141 0 : OUString lcl_determineContentType_nothrow( const Reference< XStorage >& _rxContainerStorage,
142 : const OUString& _rEntityName )
143 : {
144 0 : OUString sContentType;
145 : try
146 : {
147 : ::utl::SharedUNOComponent< XPropertySet > xStorageProps(
148 0 : _rxContainerStorage->openStorageElement( _rEntityName, ElementModes::READ ), UNO_QUERY_THROW );
149 0 : OSL_VERIFY( xStorageProps->getPropertyValue( INFO_MEDIATYPE ) >>= sContentType );
150 : }
151 0 : catch( const Exception& )
152 : {
153 : DBG_UNHANDLED_EXCEPTION();
154 : }
155 0 : return sContentType;
156 : }
157 : }
158 :
159 : // OEmbedObjectHolder
160 : typedef ::cppu::WeakComponentImplHelper1< embed::XStateChangeListener > TEmbedObjectHolder;
161 0 : class OEmbedObjectHolder : public ::comphelper::OBaseMutex
162 : ,public TEmbedObjectHolder
163 : {
164 : Reference< XEmbeddedObject > m_xBroadCaster;
165 : ODocumentDefinition* m_pDefinition;
166 : bool m_bInStateChange;
167 : bool m_bInChangingState;
168 : protected:
169 : virtual void SAL_CALL disposing() SAL_OVERRIDE;
170 : public:
171 0 : OEmbedObjectHolder(const Reference< XEmbeddedObject >& _xBroadCaster,ODocumentDefinition* _pDefinition)
172 : : TEmbedObjectHolder(m_aMutex)
173 : ,m_xBroadCaster(_xBroadCaster)
174 : ,m_pDefinition(_pDefinition)
175 : ,m_bInStateChange(false)
176 0 : ,m_bInChangingState(false)
177 : {
178 0 : osl_atomic_increment( &m_refCount );
179 : {
180 0 : if ( m_xBroadCaster.is() )
181 0 : m_xBroadCaster->addStateChangeListener(this);
182 : }
183 0 : osl_atomic_decrement( &m_refCount );
184 0 : }
185 :
186 : virtual void SAL_CALL changingState( const lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (embed::WrongStateException, uno::RuntimeException, std::exception) SAL_OVERRIDE;
187 : virtual void SAL_CALL stateChanged( const lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE;
188 : virtual void SAL_CALL disposing( const lang::EventObject& Source ) throw (uno::RuntimeException, std::exception) SAL_OVERRIDE;
189 : };
190 :
191 0 : void SAL_CALL OEmbedObjectHolder::disposing()
192 : {
193 0 : if ( m_xBroadCaster.is() )
194 0 : m_xBroadCaster->removeStateChangeListener(this);
195 0 : m_xBroadCaster = NULL;
196 0 : m_pDefinition = NULL;
197 0 : }
198 :
199 0 : void SAL_CALL OEmbedObjectHolder::changingState( const lang::EventObject& /*aEvent*/, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (embed::WrongStateException, uno::RuntimeException, std::exception)
200 : {
201 0 : if ( !m_bInChangingState && nNewState == EmbedStates::RUNNING && nOldState == EmbedStates::ACTIVE && m_pDefinition )
202 : {
203 0 : m_bInChangingState = true;
204 0 : m_bInChangingState = false;
205 : }
206 0 : }
207 :
208 0 : void SAL_CALL OEmbedObjectHolder::stateChanged( const lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (uno::RuntimeException, std::exception)
209 : {
210 0 : if ( !m_bInStateChange && nNewState == EmbedStates::RUNNING && nOldState == EmbedStates::ACTIVE && m_pDefinition )
211 : {
212 0 : m_bInStateChange = true;
213 0 : Reference<XInterface> xInt(static_cast< ::cppu::OWeakObject* >(m_pDefinition),UNO_QUERY);
214 : {
215 0 : Reference<XEmbeddedObject> xEmbeddedObject(aEvent.Source,UNO_QUERY);
216 0 : if ( xEmbeddedObject.is() )
217 0 : xEmbeddedObject->changeState(EmbedStates::LOADED);
218 : }
219 0 : m_bInStateChange = false;
220 : }
221 0 : }
222 :
223 0 : void SAL_CALL OEmbedObjectHolder::disposing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException, std::exception)
224 : {
225 0 : m_xBroadCaster = NULL;
226 0 : }
227 :
228 : // OEmbeddedClientHelper
229 : typedef ::cppu::WeakImplHelper1 < XEmbeddedClient
230 : > EmbeddedClientHelper_BASE;
231 0 : class OEmbeddedClientHelper : public EmbeddedClientHelper_BASE
232 : {
233 : ODocumentDefinition* m_pClient;
234 : public:
235 0 : OEmbeddedClientHelper(ODocumentDefinition* _pClient) :m_pClient(_pClient) {}
236 :
237 0 : virtual void SAL_CALL saveObject( ) throw (ObjectSaveVetoException, Exception, RuntimeException, std::exception) SAL_OVERRIDE
238 : {
239 0 : }
240 0 : virtual void SAL_CALL onShowWindow( bool /*bVisible*/ ) throw (RuntimeException)
241 : {
242 0 : }
243 : // XComponentSupplier
244 0 : virtual Reference< util::XCloseable > SAL_CALL getComponent( ) throw (RuntimeException, std::exception) SAL_OVERRIDE
245 : {
246 0 : return Reference< css::util::XCloseable >();
247 : }
248 :
249 : // XEmbeddedClient
250 0 : virtual void SAL_CALL visibilityChanged( sal_Bool /*bVisible*/ ) throw (WrongStateException, RuntimeException, std::exception) SAL_OVERRIDE
251 : {
252 0 : }
253 0 : inline void resetClient(ODocumentDefinition* _pClient) { m_pClient = _pClient; }
254 : };
255 :
256 : // LockModifiable
257 : class LockModifiable
258 : {
259 : public:
260 0 : LockModifiable( const Reference< XInterface >& i_rModifiable )
261 0 : :m_xModifiable( i_rModifiable, UNO_QUERY )
262 : {
263 : OSL_ENSURE( m_xModifiable.is(), "LockModifiable::LockModifiable: invalid component!" );
264 0 : if ( m_xModifiable.is() )
265 : {
266 0 : if ( !m_xModifiable->isSetModifiedEnabled() )
267 : {
268 : // somebody already locked that, no need to lock it, again, and no need to unlock it later
269 0 : m_xModifiable.clear();
270 : }
271 : else
272 : {
273 0 : m_xModifiable->disableSetModified();
274 : }
275 : }
276 0 : }
277 :
278 0 : ~LockModifiable()
279 0 : {
280 0 : if ( m_xModifiable.is() )
281 0 : m_xModifiable->enableSetModified();
282 0 : }
283 :
284 : private:
285 : Reference< XModifiable2 > m_xModifiable;
286 : };
287 :
288 : // LifetimeCoupler
289 : typedef ::cppu::WeakImplHelper1 < css::lang::XEventListener
290 : > LifetimeCoupler_Base;
291 : /** helper class which couples the lifetime of a component to the lifetime
292 : of another component
293 :
294 : Instances of this class are constructed with two components. The first is
295 : simply held by reference, and thus kept alive. The second one is observed
296 : for <code>disposing</code> calls - if they occur, i.e. if the component dies,
297 : the reference to the first component is cleared.
298 :
299 : This way, you can ensure that a certain component is kept alive as long
300 : as a second component is not disposed.
301 : */
302 0 : class LifetimeCoupler : public LifetimeCoupler_Base
303 : {
304 : private:
305 : Reference< XInterface > m_xClient;
306 :
307 : public:
308 0 : inline static void couple( const Reference< XInterface >& _rxClient, const Reference< XComponent >& _rxActor )
309 : {
310 0 : Reference< css::lang::XEventListener > xEnsureDelete( new LifetimeCoupler( _rxClient, _rxActor ) );
311 0 : }
312 :
313 : private:
314 0 : inline LifetimeCoupler( const Reference< XInterface >& _rxClient, const Reference< XComponent >& _rxActor )
315 0 : :m_xClient( _rxClient )
316 : {
317 : OSL_ENSURE( _rxActor.is(), "LifetimeCoupler::LifetimeCoupler: this will crash!" );
318 0 : osl_atomic_increment( &m_refCount );
319 : {
320 0 : _rxActor->addEventListener( this );
321 : }
322 0 : osl_atomic_decrement( &m_refCount );
323 : OSL_ENSURE( m_refCount, "LifetimeCoupler::LifetimeCoupler: the actor is not holding us by hard ref - this won't work!" );
324 0 : }
325 :
326 : virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
327 : protected:
328 : };
329 :
330 0 : void SAL_CALL LifetimeCoupler::disposing( const css::lang::EventObject& /*Source*/ ) throw (RuntimeException, std::exception)
331 : {
332 0 : m_xClient.clear();
333 0 : }
334 :
335 : // ODocumentSaveContinuation
336 0 : class ODocumentSaveContinuation : public OInteraction< XInteractionDocumentSave >
337 : {
338 : OUString m_sName;
339 : Reference<XContent> m_xParentContainer;
340 :
341 : public:
342 0 : ODocumentSaveContinuation() { }
343 :
344 0 : inline Reference<XContent> getContent() const { return m_xParentContainer; }
345 0 : inline OUString getName() const { return m_sName; }
346 :
347 : // XInteractionDocumentSave
348 : virtual void SAL_CALL setName( const OUString& _sName,const Reference<XContent>& _xParent) throw(RuntimeException, std::exception) SAL_OVERRIDE;
349 : };
350 :
351 0 : void SAL_CALL ODocumentSaveContinuation::setName( const OUString& _sName,const Reference<XContent>& _xParent) throw(RuntimeException, std::exception)
352 : {
353 0 : m_sName = _sName;
354 0 : m_xParentContainer = _xParent;
355 0 : }
356 :
357 0 : OUString ODocumentDefinition::GetDocumentServiceFromMediaType( const Reference< XStorage >& _rxContainerStorage,
358 : const OUString& _rEntityName, const Reference< XComponentContext >& _rContext,
359 : Sequence< sal_Int8 >& _rClassId )
360 : {
361 : return GetDocumentServiceFromMediaType(
362 : lcl_determineContentType_nothrow( _rxContainerStorage, _rEntityName ),
363 0 : _rContext, _rClassId );
364 : }
365 :
366 0 : OUString ODocumentDefinition::GetDocumentServiceFromMediaType( const OUString& _rMediaType,
367 : const Reference< XComponentContext >& _rContext, Sequence< sal_Int8 >& _rClassId )
368 : {
369 0 : OUString sResult;
370 : try
371 : {
372 0 : ::comphelper::MimeConfigurationHelper aConfigHelper( _rContext );
373 0 : sResult = aConfigHelper.GetDocServiceNameFromMediaType( _rMediaType );
374 0 : _rClassId = comphelper::MimeConfigurationHelper::GetSequenceClassIDRepresentation(aConfigHelper.GetExplicitlyRegisteredObjClassID( _rMediaType ));
375 0 : if ( !_rClassId.getLength() && !sResult.isEmpty() )
376 : {
377 0 : Reference< XNameAccess > xObjConfig = aConfigHelper.GetObjConfiguration();
378 0 : if ( xObjConfig.is() )
379 : {
380 0 : Sequence< OUString > aClassIDs = xObjConfig->getElementNames();
381 0 : for ( sal_Int32 nInd = 0; nInd < aClassIDs.getLength(); nInd++ )
382 : {
383 0 : Reference< XNameAccess > xObjectProps;
384 0 : OUString aEntryDocName;
385 :
386 0 : if ( ( xObjConfig->getByName( aClassIDs[nInd] ) >>= xObjectProps ) && xObjectProps.is()
387 0 : && ( xObjectProps->getByName("ObjectDocumentServiceName") >>= aEntryDocName )
388 0 : && aEntryDocName.equals( sResult ) )
389 : {
390 0 : _rClassId = comphelper::MimeConfigurationHelper::GetSequenceClassIDRepresentation(aClassIDs[nInd]);
391 0 : break;
392 : }
393 0 : }
394 0 : }
395 0 : }
396 : #if OSL_DEBUG_LEVEL > 0
397 : // alternative, shorter approach
398 : const Sequence< NamedValue > aProps( aConfigHelper.GetObjectPropsByMediaType( _rMediaType ) );
399 : const ::comphelper::NamedValueCollection aMediaTypeProps( aProps );
400 : const OUString sAlternativeResult = aMediaTypeProps.getOrDefault( "ObjectDocumentServiceName", OUString() );
401 : OSL_ENSURE( sAlternativeResult == sResult, "ODocumentDefinition::GetDocumentServiceFromMediaType: failed, this approach is *not* equivalent (1)!" );
402 : const Sequence< sal_Int8 > aAlternativeClassID = aMediaTypeProps.getOrDefault( "ClassID", Sequence< sal_Int8 >() );
403 : OSL_ENSURE( aAlternativeClassID == _rClassId, "ODocumentDefinition::GetDocumentServiceFromMediaType: failed, this approach is *not* equivalent (2)!" );
404 : #endif
405 : }
406 0 : catch ( const Exception& )
407 : {
408 : DBG_UNHANDLED_EXCEPTION();
409 : }
410 0 : return sResult;
411 : }
412 :
413 : // ODocumentDefinition
414 :
415 24 : ODocumentDefinition::ODocumentDefinition( const Reference< XInterface >& _rxContainer, const Reference< XComponentContext >& _xORB,
416 : const TContentPtr& _pImpl, bool _bForm )
417 : :OContentHelper(_xORB,_rxContainer,_pImpl)
418 : ,OPropertyStateContainer(OContentHelper::rBHelper)
419 : ,m_pInterceptor(NULL)
420 : ,m_bForm(_bForm)
421 : ,m_bOpenInDesign(false)
422 : ,m_bInExecute(false)
423 : ,m_bRemoveListener(false)
424 24 : ,m_pClientHelper(NULL)
425 : {
426 24 : registerProperties();
427 24 : }
428 :
429 0 : void ODocumentDefinition::initialLoad( const Sequence< sal_Int8 >& i_rClassID, const Sequence< PropertyValue >& i_rCreationArgs,
430 : const Reference< XConnection >& i_rConnection )
431 : {
432 : OSL_ENSURE( i_rClassID.getLength(), "ODocumentDefinition::initialLoad: illegal class ID!" );
433 0 : if ( !i_rClassID.getLength() )
434 0 : return;
435 :
436 0 : loadEmbeddedObject( i_rConnection, i_rClassID, i_rCreationArgs, false, false );
437 : }
438 :
439 72 : ODocumentDefinition::~ODocumentDefinition()
440 : {
441 24 : if ( !OContentHelper::rBHelper.bInDispose && !OContentHelper::rBHelper.bDisposed )
442 : {
443 0 : acquire();
444 0 : dispose();
445 : }
446 :
447 24 : if ( m_pInterceptor )
448 : {
449 0 : m_pInterceptor->dispose();
450 0 : m_pInterceptor->release();
451 0 : m_pInterceptor = NULL;
452 : }
453 48 : }
454 :
455 24 : void ODocumentDefinition::closeObject()
456 : {
457 24 : ::osl::MutexGuard aGuard(m_aMutex);
458 24 : if ( m_xEmbeddedObject.is() )
459 : {
460 : try
461 : {
462 0 : Reference< com::sun::star::util::XCloseable> xCloseable(m_xEmbeddedObject,UNO_QUERY);
463 0 : if ( xCloseable.is() )
464 0 : xCloseable->close(sal_True);
465 : }
466 0 : catch(const Exception&)
467 : {
468 : }
469 0 : m_xEmbeddedObject = NULL;
470 0 : if ( m_pClientHelper )
471 : {
472 0 : m_pClientHelper->resetClient(NULL);
473 0 : m_pClientHelper->release();
474 0 : m_pClientHelper = NULL;
475 : }
476 24 : }
477 24 : }
478 :
479 24 : void SAL_CALL ODocumentDefinition::disposing()
480 : {
481 24 : OContentHelper::disposing();
482 24 : ::osl::MutexGuard aGuard(m_aMutex);
483 24 : closeObject();
484 24 : ::comphelper::disposeComponent(m_xListener);
485 24 : if ( m_bRemoveListener )
486 : {
487 0 : Reference<util::XCloseable> xCloseable(m_pImpl->m_pDataSource->getModel_noCreate(),UNO_QUERY);
488 0 : if ( xCloseable.is() )
489 0 : xCloseable->removeCloseListener(this);
490 24 : }
491 24 : }
492 :
493 0 : css::uno::Sequence<sal_Int8> ODocumentDefinition::getImplementationId()
494 : throw (css::uno::RuntimeException, std::exception)
495 : {
496 0 : return css::uno::Sequence<sal_Int8>();
497 : }
498 :
499 0 : IMPLEMENT_GETTYPES3(ODocumentDefinition,OContentHelper,OPropertyStateContainer,ODocumentDefinition_Base);
500 960 : IMPLEMENT_FORWARD_XINTERFACE3( ODocumentDefinition,OContentHelper,OPropertyStateContainer,ODocumentDefinition_Base)
501 0 : IMPLEMENT_SERVICE_INFO1(ODocumentDefinition,"com.sun.star.comp.dba.ODocumentDefinition",SERVICE_SDB_DOCUMENTDEFINITION)
502 :
503 24 : void ODocumentDefinition::registerProperties()
504 : {
505 : #define REGISTER_PROPERTY( name, location ) \
506 : registerProperty( PROPERTY_##name, PROPERTY_ID_##name, PropertyAttribute::READONLY, &location, ::getCppuType( &location ) );
507 :
508 : #define REGISTER_PROPERTY_BV( name, location ) \
509 : registerProperty( PROPERTY_##name, PROPERTY_ID_##name, PropertyAttribute::CONSTRAINED | PropertyAttribute::BOUND | PropertyAttribute::READONLY, &location, ::getCppuType( &location ) );
510 :
511 24 : REGISTER_PROPERTY_BV( NAME, m_pImpl->m_aProps.aTitle );
512 24 : REGISTER_PROPERTY ( AS_TEMPLATE, m_pImpl->m_aProps.bAsTemplate );
513 24 : REGISTER_PROPERTY ( PERSISTENT_NAME, m_pImpl->m_aProps.sPersistentName );
514 24 : REGISTER_PROPERTY ( IS_FORM, m_bForm );
515 24 : }
516 :
517 48 : void SAL_CALL ODocumentDefinition::getFastPropertyValue( Any& o_rValue, sal_Int32 i_nHandle ) const
518 : {
519 48 : if ( i_nHandle == PROPERTY_ID_PERSISTENT_PATH )
520 : {
521 0 : OUString sPersistentPath;
522 0 : if ( !m_pImpl->m_aProps.sPersistentName.isEmpty() )
523 : {
524 0 : OUStringBuffer aBuffer;
525 0 : aBuffer.append( ODatabaseModelImpl::getObjectContainerStorageName( m_bForm ? ODatabaseModelImpl::E_FORM : ODatabaseModelImpl::E_REPORT ) );
526 0 : aBuffer.append( '/' );
527 0 : aBuffer.append( m_pImpl->m_aProps.sPersistentName );
528 0 : sPersistentPath = aBuffer.makeStringAndClear();
529 : }
530 0 : o_rValue <<= sPersistentPath;
531 48 : return;
532 : }
533 :
534 48 : OPropertyStateContainer::getFastPropertyValue( o_rValue, i_nHandle );
535 : }
536 :
537 0 : Reference< XPropertySetInfo > SAL_CALL ODocumentDefinition::getPropertySetInfo( ) throw(RuntimeException, std::exception)
538 : {
539 0 : Reference<XPropertySetInfo> xInfo( createPropertySetInfo( getInfoHelper() ) );
540 0 : return xInfo;
541 : }
542 :
543 144 : IPropertyArrayHelper& ODocumentDefinition::getInfoHelper()
544 : {
545 144 : return *getArrayHelper();
546 : }
547 :
548 24 : IPropertyArrayHelper* ODocumentDefinition::createArrayHelper( ) const
549 : {
550 : // properties maintained by our base class (see registerProperties)
551 24 : Sequence< Property > aProps;
552 24 : describeProperties( aProps );
553 :
554 : // properties not maintained by our base class
555 48 : Sequence< Property > aManualProps( 1 );
556 24 : aManualProps[0].Name = PROPERTY_PERSISTENT_PATH;
557 24 : aManualProps[0].Handle = PROPERTY_ID_PERSISTENT_PATH;
558 24 : aManualProps[0].Type = ::cppu::UnoType<OUString>::get();
559 24 : aManualProps[0].Attributes = PropertyAttribute::READONLY;
560 :
561 48 : return new OPropertyArrayHelper( ::comphelper::concatSequences( aProps, aManualProps ) );
562 : }
563 :
564 : class OExecuteImpl
565 : {
566 : bool& m_rbSet;
567 : public:
568 0 : OExecuteImpl(bool& _rbSet) : m_rbSet(_rbSet){ m_rbSet=true; }
569 0 : ~OExecuteImpl(){ m_rbSet = false; }
570 : };
571 :
572 : namespace
573 : {
574 0 : bool lcl_extractOpenMode( const Any& _rValue, sal_Int32& _out_rMode )
575 : {
576 0 : OpenCommandArgument aOpenCommand;
577 0 : if ( _rValue >>= aOpenCommand )
578 0 : _out_rMode = aOpenCommand.Mode;
579 : else
580 : {
581 0 : OpenCommandArgument2 aOpenCommand2;
582 0 : if ( _rValue >>= aOpenCommand2 )
583 0 : _out_rMode = aOpenCommand2.Mode;
584 : else
585 0 : return false;
586 : }
587 0 : return true;
588 : }
589 : }
590 :
591 0 : void ODocumentDefinition::impl_removeFrameFromDesktop_throw( const Reference<XComponentContext> & _rxContext, const Reference< XFrame >& _rxFrame )
592 : {
593 0 : Reference< XDesktop2 > xDesktop = Desktop::create( _rxContext );
594 0 : Reference< XFrames > xFrames( xDesktop->getFrames(), UNO_QUERY_THROW );
595 0 : xFrames->remove( _rxFrame );
596 0 : }
597 :
598 0 : void ODocumentDefinition::impl_onActivateEmbeddedObject_nothrow( const bool i_bReactivated )
599 : {
600 : try
601 : {
602 0 : Reference< XModel > xModel( getComponent(), UNO_QUERY );
603 0 : Reference< XController > xController( xModel.is() ? xModel->getCurrentController() : Reference< XController >() );
604 0 : if ( !xController.is() )
605 0 : return;
606 :
607 0 : if ( !m_xListener.is() )
608 : // it's the first time the embedded object has been activated
609 : // create an OEmbedObjectHolder
610 0 : m_xListener = new OEmbedObjectHolder( m_xEmbeddedObject, this );
611 :
612 : // raise the window to top (especially necessary if this is not the first activation)
613 0 : Reference< XFrame > xFrame( xController->getFrame(), UNO_SET_THROW );
614 0 : Reference< XTopWindow > xTopWindow( xFrame->getContainerWindow(), UNO_QUERY_THROW );
615 0 : xTopWindow->toFront();
616 :
617 : // remove the frame from the desktop's frame collection because we need full control of it.
618 0 : impl_removeFrameFromDesktop_throw( m_aContext, xFrame );
619 :
620 : // ensure that we ourself are kept alive as long as the embedded object's frame is
621 : // opened
622 0 : LifetimeCoupler::couple( *this, xFrame.get() );
623 :
624 : // init the edit view
625 0 : if ( m_bForm && m_bOpenInDesign && !i_bReactivated )
626 0 : impl_initFormEditView( xController );
627 : }
628 0 : catch( const RuntimeException& )
629 : {
630 : DBG_UNHANDLED_EXCEPTION();
631 : }
632 : }
633 :
634 : namespace
635 : {
636 : // PreserveVisualAreaSize
637 : /** stack-guard for preserving the size of the VisArea of an XModel
638 : */
639 : class PreserveVisualAreaSize
640 : {
641 : private:
642 : Reference< XVisualObject > m_xVisObject;
643 : awt::Size m_aOriginalSize;
644 :
645 : public:
646 0 : inline PreserveVisualAreaSize( const Reference< XModel >& _rxModel )
647 0 : :m_xVisObject( _rxModel, UNO_QUERY )
648 : {
649 0 : if ( m_xVisObject.is() )
650 : {
651 : try
652 : {
653 0 : m_aOriginalSize = m_xVisObject->getVisualAreaSize( Aspects::MSOLE_CONTENT );
654 : }
655 0 : catch ( const Exception& )
656 : {
657 : OSL_FAIL( "PreserveVisualAreaSize::PreserveVisualAreaSize: caught an exception!" );
658 : }
659 : }
660 0 : }
661 :
662 0 : inline ~PreserveVisualAreaSize()
663 0 : {
664 0 : if ( m_xVisObject.is() && m_aOriginalSize.Width && m_aOriginalSize.Height )
665 : {
666 : try
667 : {
668 0 : m_xVisObject->setVisualAreaSize( Aspects::MSOLE_CONTENT, m_aOriginalSize );
669 : }
670 0 : catch ( const Exception& )
671 : {
672 : OSL_FAIL( "PreserveVisualAreaSize::~PreserveVisualAreaSize: caught an exception!" );
673 : }
674 : }
675 0 : }
676 : };
677 :
678 : // LayoutManagerLock
679 : /** helper class for stack-usage which during its lifetime locks a layout manager
680 : */
681 : class LayoutManagerLock
682 : {
683 : private:
684 : Reference< XLayoutManager > m_xLayoutManager;
685 :
686 : public:
687 0 : inline LayoutManagerLock( const Reference< XController >& _rxController )
688 0 : {
689 : OSL_ENSURE( _rxController.is(), "LayoutManagerLock::LayoutManagerLock: this will crash!" );
690 0 : Reference< XFrame > xFrame( _rxController->getFrame() );
691 : try
692 : {
693 0 : Reference< XPropertySet > xPropSet( xFrame, UNO_QUERY_THROW );
694 : m_xLayoutManager.set(
695 0 : xPropSet->getPropertyValue( "LayoutManager" ),
696 0 : UNO_QUERY_THROW );
697 0 : m_xLayoutManager->lock();
698 :
699 : }
700 0 : catch( const Exception& )
701 : {
702 : OSL_FAIL( "LayoutManagerLock::LayoutManagerLock: caught an exception!" );
703 0 : }
704 0 : }
705 :
706 0 : inline ~LayoutManagerLock()
707 0 : {
708 : try
709 : {
710 : // unlock the layout manager
711 0 : if ( m_xLayoutManager.is() )
712 0 : m_xLayoutManager->unlock();
713 : }
714 0 : catch( const Exception& )
715 : {
716 : OSL_FAIL( "LayoutManagerLock::~LayoutManagerLock: caught an exception!" );
717 : }
718 0 : }
719 : };
720 : }
721 :
722 0 : void ODocumentDefinition::impl_initFormEditView( const Reference< XController >& _rxController )
723 : {
724 : try
725 : {
726 0 : Reference< XViewSettingsSupplier > xSettingsSupplier( _rxController, UNO_QUERY_THROW );
727 0 : Reference< XPropertySet > xViewSettings( xSettingsSupplier->getViewSettings(), UNO_QUERY_THROW );
728 :
729 : // the below code could indirectly tamper with the "modified" flag of the model, temporarily disable this
730 0 : LockModifiable aLockModify( _rxController->getModel() );
731 :
732 : // The visual area size can be changed by the setting of the following properties
733 : // so it should be restored later
734 0 : PreserveVisualAreaSize aPreserveVisAreaSize( _rxController->getModel() );
735 :
736 : // Layout manager should not layout while the size is still not restored
737 : // so it will stay locked for this time
738 0 : LayoutManagerLock aLockLayout( _rxController );
739 :
740 : // setting of the visual properties
741 0 : xViewSettings->setPropertyValue("ShowRulers",makeAny(sal_True));
742 0 : xViewSettings->setPropertyValue("ShowVertRuler",makeAny(sal_True));
743 0 : xViewSettings->setPropertyValue("ShowHoriRuler",makeAny(sal_True));
744 0 : xViewSettings->setPropertyValue("IsRasterVisible",makeAny(sal_True));
745 0 : xViewSettings->setPropertyValue("IsSnapToRaster",makeAny(sal_True));
746 0 : xViewSettings->setPropertyValue("ShowOnlineLayout",makeAny(sal_True));
747 0 : xViewSettings->setPropertyValue("RasterSubdivisionX",makeAny(sal_Int32(5)));
748 0 : xViewSettings->setPropertyValue("RasterSubdivisionY",makeAny(sal_Int32(5)));
749 : }
750 0 : catch( const Exception& )
751 : {
752 : DBG_UNHANDLED_EXCEPTION();
753 : }
754 0 : }
755 :
756 0 : void ODocumentDefinition::impl_showOrHideComponent_throw( const bool i_bShow )
757 : {
758 0 : const sal_Int32 nCurrentState = m_xEmbeddedObject.is() ? m_xEmbeddedObject->getCurrentState() : EmbedStates::LOADED;
759 0 : switch ( nCurrentState )
760 : {
761 : default:
762 : case EmbedStates::LOADED:
763 0 : throw embed::WrongStateException( OUString(), *this );
764 :
765 : case EmbedStates::RUNNING:
766 0 : if ( !i_bShow )
767 : // fine, a running (and not yet active) object is never visible
768 0 : return;
769 : {
770 0 : LockModifiable aLockModify( impl_getComponent_throw() );
771 0 : m_xEmbeddedObject->changeState( EmbedStates::ACTIVE );
772 0 : impl_onActivateEmbeddedObject_nothrow( false );
773 : }
774 0 : break;
775 :
776 : case EmbedStates::ACTIVE:
777 : {
778 0 : Reference< XModel > xEmbeddedDoc( impl_getComponent_throw( true ), UNO_QUERY_THROW );
779 0 : Reference< XController > xEmbeddedController( xEmbeddedDoc->getCurrentController(), UNO_SET_THROW );
780 0 : Reference< XFrame > xEmbeddedFrame( xEmbeddedController->getFrame(), UNO_SET_THROW );
781 0 : Reference< XWindow > xEmbeddedWindow( xEmbeddedFrame->getContainerWindow(), UNO_SET_THROW );
782 0 : xEmbeddedWindow->setVisible( i_bShow );
783 : }
784 0 : break;
785 : }
786 : }
787 :
788 0 : Any ODocumentDefinition::onCommandOpenSomething( const Any& _rOpenArgument, const bool _bActivate,
789 : const Reference< XCommandEnvironment >& _rxEnvironment )
790 : {
791 0 : OExecuteImpl aExecuteGuard( m_bInExecute );
792 :
793 0 : Reference< XConnection > xConnection;
794 0 : sal_Int32 nOpenMode = OpenMode::DOCUMENT;
795 :
796 0 : ::comphelper::NamedValueCollection aDocumentArgs;
797 :
798 : // for the document, default to the interaction handler as used for loading the DB doc
799 : // This might be overwritten below, when examining _rOpenArgument.
800 0 : const ::comphelper::NamedValueCollection& aDBDocArgs( m_pImpl->m_pDataSource->getMediaDescriptor() );
801 0 : Reference< XInteractionHandler > xHandler( aDBDocArgs.getOrDefault( "InteractionHandler", Reference< XInteractionHandler >() ) );
802 0 : if ( xHandler.is() )
803 0 : aDocumentArgs.put( "InteractionHandler", xHandler );
804 :
805 0 : ::boost::optional< sal_Int16 > aDocumentMacroMode;
806 :
807 0 : if ( !lcl_extractOpenMode( _rOpenArgument, nOpenMode ) )
808 : {
809 0 : Sequence< PropertyValue > aArguments;
810 0 : if ( _rOpenArgument >>= aArguments )
811 : {
812 0 : const PropertyValue* pIter = aArguments.getConstArray();
813 0 : const PropertyValue* pEnd = pIter + aArguments.getLength();
814 0 : for ( ;pIter != pEnd; ++pIter )
815 : {
816 0 : if ( pIter->Name == PROPERTY_ACTIVE_CONNECTION )
817 : {
818 0 : xConnection.set( pIter->Value, UNO_QUERY );
819 0 : continue;
820 : }
821 :
822 0 : if ( lcl_extractOpenMode( pIter->Value, nOpenMode ) )
823 0 : continue;
824 :
825 0 : if ( pIter->Name == "MacroExecutionMode" )
826 : {
827 0 : sal_Int16 nMacroExecMode( !aDocumentMacroMode ? MacroExecMode::USE_CONFIG : *aDocumentMacroMode );
828 0 : OSL_VERIFY( pIter->Value >>= nMacroExecMode );
829 0 : aDocumentMacroMode.reset( nMacroExecMode );
830 0 : continue;
831 : }
832 :
833 : // unknown argument -> pass to the loaded document
834 0 : aDocumentArgs.put( pIter->Name, pIter->Value );
835 : }
836 0 : }
837 : }
838 :
839 0 : bool bExecuteDBDocMacros = m_pImpl->m_pDataSource->checkMacrosOnLoading();
840 : // Note that this call implies the user might be asked for the macro execution mode.
841 : // Normally, this would happen when the database document is loaded, and subsequent calls
842 : // will simply use the user's decision from this point in time.
843 : // However, it is possible to programmatically load forms/reports, without actually
844 : // loading the database document into a frame. In this case, the user will be asked
845 : // here and now.
846 : // #i87741#
847 :
848 : // allow the command arguments to downgrade the macro execution mode, but not to upgrade
849 : // it
850 0 : if ( ( m_pImpl->m_pDataSource->getImposedMacroExecMode() == MacroExecMode::USE_CONFIG )
851 0 : && bExecuteDBDocMacros
852 : )
853 : {
854 : // while loading the whole database document, USE_CONFIG, was passed.
855 : // Additionally, *by now* executing macros from the DB doc is allowed (this is what bExecuteDBDocMacros
856 : // indicates). This means either one of:
857 : // 1. The DB doc or one of the sub docs contained macros and
858 : // 1a. the user explicitly allowed executing them
859 : // 1b. the configuration allows executing them without asking the user
860 : // 2. Neither the DB doc nor the sub docs contained macros, thus macro
861 : // execution was silently enabled, assuming that any macro will be a
862 : // user-created macro
863 : //
864 : // The problem with this: If the to-be-opened sub document has macros embedded in
865 : // the content.xml (which is valid ODF, but normally not produced by OOo itself),
866 : // then this has not been detected while loading the database document - it would
867 : // be too expensive, as it effectively would require loading all forms/reports.
868 : //
869 : // So, in such a case, and with 2. above, we would silently execute those macros,
870 : // regardless of the global security settings - which would be a security issue, of
871 : // course.
872 0 : if ( m_pImpl->m_pDataSource->determineEmbeddedMacros() == ODatabaseModelImpl::eNoMacros )
873 : {
874 : // this is case 2. from above
875 : // So, pass a USE_CONFIG to the to-be-loaded document. This means that
876 : // the user will be prompted with a security message upon opening this
877 : // sub document, in case the settings require this, *and* the document
878 : // contains scripts in the content.xml. But this is better than the security
879 : // issue we had before ...
880 0 : aDocumentMacroMode.reset( MacroExecMode::USE_CONFIG );
881 : }
882 : }
883 :
884 0 : if ( !aDocumentMacroMode )
885 : {
886 : // nobody so far felt responsible for setting it
887 : // => use the DBDoc-wide macro exec mode for the document, too
888 0 : aDocumentMacroMode.reset( bExecuteDBDocMacros ? MacroExecMode::ALWAYS_EXECUTE_NO_WARN : MacroExecMode::NEVER_EXECUTE );
889 : }
890 0 : aDocumentArgs.put( "MacroExecutionMode", *aDocumentMacroMode );
891 :
892 0 : if ( ( nOpenMode == OpenMode::ALL )
893 0 : || ( nOpenMode == OpenMode::FOLDERS )
894 0 : || ( nOpenMode == OpenMode::DOCUMENTS )
895 0 : || ( nOpenMode == OpenMode::DOCUMENT_SHARE_DENY_NONE )
896 0 : || ( nOpenMode == OpenMode::DOCUMENT_SHARE_DENY_WRITE )
897 : )
898 : {
899 : // not supported
900 : ucbhelper::cancelCommandExecution(
901 : makeAny( UnsupportedOpenModeException(
902 : OUString(),
903 : static_cast< cppu::OWeakObject * >( this ),
904 : sal_Int16( nOpenMode ) ) ),
905 0 : _rxEnvironment );
906 : // Unreachable
907 : OSL_FAIL( "unreachable" );
908 : }
909 :
910 : OSL_ENSURE( !m_pImpl->m_aProps.sPersistentName.isEmpty(),
911 : "ODocumentDefinition::onCommandOpenSomething: no persistent name - cannot load!" );
912 0 : if ( m_pImpl->m_aProps.sPersistentName.isEmpty() )
913 0 : return Any();
914 :
915 : // embedded objects themself do not support the hidden flag. We implement support for
916 : // it by changing the STATE to RUNNING only, instead of ACTIVE.
917 0 : bool bOpenHidden = aDocumentArgs.getOrDefault( "Hidden", false );
918 0 : aDocumentArgs.remove( "Hidden" );
919 :
920 0 : loadEmbeddedObject( xConnection, Sequence< sal_Int8 >(), aDocumentArgs.getPropertyValues(), false, !m_bOpenInDesign );
921 : OSL_ENSURE( m_xEmbeddedObject.is(), "ODocumentDefinition::onCommandOpenSomething: what's this?" );
922 0 : if ( !m_xEmbeddedObject.is() )
923 0 : return Any();
924 :
925 0 : Reference< XModel > xModel( getComponent(), UNO_QUERY );
926 0 : Reference< report::XReportDefinition > xReportDefinition(xModel,UNO_QUERY);
927 :
928 0 : Reference< XModule > xModule( xModel, UNO_QUERY );
929 0 : if ( xModule.is() )
930 : {
931 0 : if ( m_bForm )
932 0 : xModule->setIdentifier( "com.sun.star.sdb.FormDesign" );
933 0 : else if ( !xReportDefinition.is() )
934 0 : xModule->setIdentifier( "com.sun.star.text.TextDocument" );
935 :
936 0 : updateDocumentTitle();
937 : }
938 :
939 0 : bool bIsAliveNewStyleReport = ( !m_bOpenInDesign && xReportDefinition.is() );
940 0 : if ( bIsAliveNewStyleReport )
941 : {
942 : // we are in ReadOnly mode
943 : // we would like to open the Writer or Calc with the report direct, without design it.
944 0 : Reference< report::XReportEngine > xReportEngine( m_aContext->getServiceManager()->createInstanceWithContext("com.sun.star.comp.report.OReportEngineJFree", m_aContext), UNO_QUERY_THROW );
945 :
946 0 : xReportEngine->setReportDefinition(xReportDefinition);
947 0 : xReportEngine->setActiveConnection(m_xLastKnownConnection);
948 0 : if ( bOpenHidden )
949 0 : return makeAny( xReportEngine->createDocumentModel() );
950 0 : return makeAny( xReportEngine->createDocumentAlive( NULL ) );
951 : }
952 :
953 0 : if ( _bActivate && !bOpenHidden )
954 : {
955 0 : LockModifiable aLockModify( impl_getComponent_throw() );
956 0 : m_xEmbeddedObject->changeState( EmbedStates::ACTIVE );
957 0 : impl_onActivateEmbeddedObject_nothrow( false );
958 : }
959 : else
960 : {
961 : // ensure that we ourself are kept alive as long as the document is open
962 0 : LifetimeCoupler::couple( *this, xModel.get() );
963 : }
964 :
965 0 : if ( !m_bForm && m_pImpl->m_aProps.bAsTemplate && !m_bOpenInDesign )
966 0 : ODocumentDefinition::fillReportData( m_aContext, getComponent(), xConnection );
967 :
968 0 : return makeAny( xModel );
969 : }
970 :
971 0 : Any SAL_CALL ODocumentDefinition::execute( const Command& aCommand, sal_Int32 CommandId, const Reference< XCommandEnvironment >& Environment ) throw (Exception, CommandAbortedException, RuntimeException, std::exception)
972 : {
973 0 : Any aRet;
974 :
975 0 : bool bOpen = aCommand.Name == "open";
976 0 : bool bOpenInDesign = aCommand.Name == "openDesign";
977 0 : bool bOpenForMail = aCommand.Name == "openForMail";
978 0 : if ( bOpen || bOpenInDesign || bOpenForMail )
979 : {
980 : // opening the document involves a lot of VCL code, which is not thread-safe, but needs the SolarMutex locked.
981 : // Unfortunately, the DocumentDefinition, as well as the EmbeddedObject implementation, calls into VCL-dependent
982 : // components *without* releasing the own mutex, which is a guaranteed recipe for deadlocks.
983 : // We have control over this implementation here, and in modifying it to release the own mutex before calling into
984 : // the VCL-dependent components is not too difficult (was there, seen it).
985 : // However, we do /not/ have control over the EmbeddedObject implementation, and from a first look, it seems as
986 : // making it release the own mutex before calling SolarMutex-code is ... difficult, at least.
987 : // So, to be on the same side, we lock the SolarMutex here. Yes, it sucks.
988 0 : ::SolarMutexGuard aSolarGuard;
989 0 : ::osl::ClearableMutexGuard aGuard(m_aMutex);
990 0 : if ( m_bInExecute )
991 0 : return aRet;
992 :
993 0 : bool bActivateObject = true;
994 0 : if ( bOpenForMail )
995 : {
996 : OSL_FAIL( "ODocumentDefinition::execute: 'openForMail' should not be used anymore - use the 'Hidden' parameter instead!" );
997 0 : bActivateObject = false;
998 : }
999 :
1000 : // if the object is already opened, do nothing
1001 0 : if ( m_xEmbeddedObject.is() )
1002 : {
1003 0 : sal_Int32 nCurrentState = m_xEmbeddedObject->getCurrentState();
1004 0 : bool bIsActive = ( nCurrentState == EmbedStates::ACTIVE );
1005 :
1006 0 : if ( bIsActive )
1007 : {
1008 : // exception: new-style reports always create a new document when "open" is executed
1009 0 : Reference< report::XReportDefinition > xReportDefinition( impl_getComponent_throw( false ), UNO_QUERY );
1010 0 : bool bIsAliveNewStyleReport = ( xReportDefinition.is() && ( bOpen || bOpenForMail ) );
1011 :
1012 0 : if ( !bIsAliveNewStyleReport )
1013 : {
1014 0 : impl_onActivateEmbeddedObject_nothrow( true );
1015 0 : return makeAny( getComponent() );
1016 0 : }
1017 : }
1018 : }
1019 :
1020 0 : m_bOpenInDesign = bOpenInDesign || bOpenForMail;
1021 0 : return onCommandOpenSomething( aCommand.Argument, bActivateObject, Environment );
1022 : }
1023 :
1024 0 : ::osl::ClearableMutexGuard aGuard(m_aMutex);
1025 0 : if ( m_bInExecute )
1026 0 : return aRet;
1027 :
1028 0 : if ( aCommand.Name == "copyTo" )
1029 : {
1030 0 : Sequence<Any> aIni;
1031 0 : aCommand.Argument >>= aIni;
1032 0 : if ( aIni.getLength() != 2 )
1033 : {
1034 : OSL_FAIL( "Wrong argument type!" );
1035 : ucbhelper::cancelCommandExecution(
1036 : makeAny( IllegalArgumentException(
1037 : OUString(),
1038 : static_cast< cppu::OWeakObject * >( this ),
1039 : -1 ) ),
1040 0 : Environment );
1041 : // Unreachable
1042 : }
1043 0 : Reference< XStorage> xDest(aIni[0],UNO_QUERY);
1044 0 : OUString sPersistentName;
1045 0 : aIni[1] >>= sPersistentName;
1046 0 : Reference< XStorage> xStorage = getContainerStorage();
1047 :
1048 0 : xStorage->copyElementTo(m_pImpl->m_aProps.sPersistentName,xDest,sPersistentName);
1049 : }
1050 0 : else if ( aCommand.Name == "preview" )
1051 : {
1052 0 : onCommandPreview(aRet);
1053 : }
1054 0 : else if ( aCommand.Name == "insert" )
1055 : {
1056 0 : Sequence<Any> aIni;
1057 0 : aCommand.Argument >>= aIni;
1058 0 : if ( !aIni.getLength() )
1059 : {
1060 : OSL_FAIL( "Wrong argument count!" );
1061 : ucbhelper::cancelCommandExecution(
1062 : makeAny( IllegalArgumentException(
1063 : OUString(),
1064 : static_cast< cppu::OWeakObject * >( this ),
1065 : -1 ) ),
1066 0 : Environment );
1067 : // Unreachable
1068 : }
1069 0 : OUString sURL;
1070 0 : aIni[0] >>= sURL;
1071 0 : onCommandInsert( sURL, Environment );
1072 : }
1073 0 : else if ( aCommand.Name == "getdocumentinfo" // compatibility
1074 0 : || aCommand.Name == "getDocumentInfo" )
1075 : {
1076 0 : onCommandGetDocumentProperties( aRet );
1077 : }
1078 0 : else if ( aCommand.Name == "delete" )
1079 : {
1080 : // delete
1081 0 : closeObject();
1082 0 : Reference< XStorage> xStorage = getContainerStorage();
1083 0 : if ( xStorage.is() )
1084 0 : xStorage->removeElement(m_pImpl->m_aProps.sPersistentName);
1085 :
1086 0 : dispose();
1087 :
1088 : }
1089 0 : else if ( aCommand.Name.equalsAscii( "storeOwn" ) // compatibility
1090 0 : || aCommand.Name.equalsAscii( "store" )
1091 : )
1092 : {
1093 0 : impl_store_throw();
1094 : }
1095 0 : else if ( aCommand.Name.equalsAscii( "shutdown" ) // compatibility
1096 0 : || aCommand.Name.equalsAscii( "close" )
1097 : )
1098 : {
1099 0 : aRet <<= impl_close_throw();
1100 : }
1101 0 : else if ( aCommand.Name == "show" )
1102 : {
1103 0 : impl_showOrHideComponent_throw( true );
1104 : }
1105 0 : else if ( aCommand.Name == "hide" )
1106 : {
1107 0 : impl_showOrHideComponent_throw( false );
1108 : }
1109 : else
1110 : {
1111 0 : aRet = OContentHelper::execute(aCommand,CommandId,Environment);
1112 : }
1113 :
1114 0 : return aRet;
1115 : }
1116 :
1117 : namespace
1118 : {
1119 0 : void lcl_resetChildFormsToEmptyDataSource( const Reference< XIndexAccess>& _rxFormsContainer )
1120 : {
1121 : OSL_PRECOND( _rxFormsContainer.is(), "lcl_resetChildFormsToEmptyDataSource: illegal call!" );
1122 0 : sal_Int32 count = _rxFormsContainer->getCount();
1123 0 : for ( sal_Int32 i = 0; i < count; ++i )
1124 : {
1125 0 : Reference< XForm > xForm( _rxFormsContainer->getByIndex( i ), UNO_QUERY );
1126 0 : if ( !xForm.is() )
1127 0 : continue;
1128 :
1129 : // if the element is a form, reset its DataSourceName property to an empty string
1130 : try
1131 : {
1132 0 : Reference< XPropertySet > xFormProps( xForm, UNO_QUERY_THROW );
1133 0 : xFormProps->setPropertyValue( PROPERTY_DATASOURCENAME, makeAny( OUString() ) );
1134 : }
1135 0 : catch( const Exception& )
1136 : {
1137 : DBG_UNHANDLED_EXCEPTION();
1138 : }
1139 :
1140 : // if the element is a container itself, step down the component hierarchy
1141 0 : Reference< XIndexAccess > xContainer( xForm, UNO_QUERY );
1142 0 : if ( xContainer.is() )
1143 0 : lcl_resetChildFormsToEmptyDataSource( xContainer );
1144 0 : }
1145 0 : }
1146 :
1147 0 : void lcl_resetFormsToEmptyDataSource( const Reference< XEmbeddedObject>& _rxEmbeddedObject )
1148 : {
1149 : try
1150 : {
1151 0 : Reference< XDrawPageSupplier > xSuppPage( _rxEmbeddedObject->getComponent(), UNO_QUERY_THROW );
1152 : // if this interface does not exist, then either getComponent returned NULL,
1153 : // or the document is a multi-page document. The latter is allowed, but currently
1154 : // simply not handled by this code, as it would not normally happen.
1155 :
1156 0 : Reference< XFormsSupplier > xSuppForms( xSuppPage->getDrawPage(), UNO_QUERY_THROW );
1157 0 : Reference< XIndexAccess > xForms( xSuppForms->getForms(), UNO_QUERY_THROW );
1158 0 : lcl_resetChildFormsToEmptyDataSource( xForms );
1159 : }
1160 0 : catch( const Exception& )
1161 : {
1162 : DBG_UNHANDLED_EXCEPTION();
1163 : }
1164 :
1165 0 : }
1166 : }
1167 :
1168 0 : void ODocumentDefinition::onCommandInsert( const OUString& _sURL, const Reference< XCommandEnvironment >& Environment )
1169 : throw( Exception )
1170 : {
1171 0 : osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
1172 :
1173 : // Check, if all required properties were set.
1174 0 : if ( _sURL.isEmpty() || m_xEmbeddedObject.is() )
1175 : {
1176 : OSL_FAIL( "Content::onCommandInsert - property value missing!" );
1177 :
1178 0 : Sequence< OUString > aProps( 1 );
1179 0 : aProps[ 0 ] = PROPERTY_URL;
1180 : ucbhelper::cancelCommandExecution(
1181 : makeAny( MissingPropertiesException(
1182 : OUString(),
1183 : static_cast< cppu::OWeakObject * >( this ),
1184 : aProps ) ),
1185 0 : Environment );
1186 : // Unreachable
1187 : }
1188 :
1189 0 : if ( !m_xEmbeddedObject.is() )
1190 : {
1191 0 : Reference< XStorage> xStorage = getContainerStorage();
1192 0 : if ( xStorage.is() )
1193 : {
1194 0 : Reference< XEmbeddedObjectCreator> xEmbedFactory = EmbeddedObjectCreator::create(m_aContext);
1195 0 : Sequence<PropertyValue> aEmpty,aMediaDesc(1);
1196 0 : aMediaDesc[0].Name = PROPERTY_URL;
1197 0 : aMediaDesc[0].Value <<= _sURL;
1198 0 : m_xEmbeddedObject.set(xEmbedFactory->createInstanceInitFromMediaDescriptor( xStorage
1199 0 : ,m_pImpl->m_aProps.sPersistentName
1200 : ,aMediaDesc
1201 0 : ,aEmpty),UNO_QUERY);
1202 :
1203 0 : lcl_resetFormsToEmptyDataSource( m_xEmbeddedObject );
1204 : // #i57669#
1205 :
1206 0 : Reference<XEmbedPersist> xPersist(m_xEmbeddedObject,UNO_QUERY);
1207 0 : if ( xPersist.is() )
1208 : {
1209 0 : xPersist->storeOwn();
1210 : }
1211 : try
1212 : {
1213 0 : Reference< com::sun::star::util::XCloseable> xCloseable(m_xEmbeddedObject,UNO_QUERY);
1214 0 : if ( xCloseable.is() )
1215 0 : xCloseable->close(sal_True);
1216 : }
1217 0 : catch(const Exception&)
1218 : {
1219 : }
1220 0 : m_xEmbeddedObject = NULL;
1221 0 : }
1222 : }
1223 :
1224 0 : aGuard.clear();
1225 0 : }
1226 :
1227 0 : bool ODocumentDefinition::save(bool _bApprove)
1228 : {
1229 : // default handling: instantiate an interaction handler and let it handle the parameter request
1230 0 : if ( !m_bOpenInDesign )
1231 0 : return false;
1232 : try
1233 : {
1234 :
1235 : {
1236 0 : ::SolarMutexGuard aSolarGuard;
1237 :
1238 : // the request
1239 0 : Reference<XNameAccess> xName(m_xParentContainer,UNO_QUERY);
1240 0 : DocumentSaveRequest aRequest;
1241 0 : aRequest.Name = m_pImpl->m_aProps.aTitle;
1242 0 : if ( aRequest.Name.isEmpty() )
1243 : {
1244 0 : if ( m_bForm )
1245 0 : aRequest.Name = DBACORE_RESSTRING( RID_STR_FORM );
1246 : else
1247 0 : aRequest.Name = DBACORE_RESSTRING( RID_STR_REPORT );
1248 0 : aRequest.Name = ::dbtools::createUniqueName(xName,aRequest.Name);
1249 : }
1250 :
1251 0 : aRequest.Content.set(m_xParentContainer,UNO_QUERY);
1252 0 : OInteractionRequest* pRequest = new OInteractionRequest(makeAny(aRequest));
1253 0 : Reference< XInteractionRequest > xRequest(pRequest);
1254 : // some knittings
1255 : // two continuations allowed: OK and Cancel
1256 0 : ODocumentSaveContinuation* pDocuSave = NULL;
1257 :
1258 0 : if ( m_pImpl->m_aProps.aTitle.isEmpty() )
1259 : {
1260 0 : pDocuSave = new ODocumentSaveContinuation;
1261 0 : pRequest->addContinuation(pDocuSave);
1262 : }
1263 0 : if ( _bApprove )
1264 : {
1265 0 : OInteraction< XInteractionApprove >* pApprove = new OInteraction< XInteractionApprove >;
1266 0 : pRequest->addContinuation(pApprove);
1267 : }
1268 :
1269 0 : OInteraction< XInteractionDisapprove >* pDisApprove = new OInteraction< XInteractionDisapprove >;
1270 0 : pRequest->addContinuation(pDisApprove);
1271 :
1272 0 : OInteractionAbort* pAbort = new OInteractionAbort;
1273 0 : pRequest->addContinuation(pAbort);
1274 :
1275 : // create the handler, let it handle the request
1276 0 : Reference< XInteractionHandler2 > xHandler( InteractionHandler::createWithParent(m_aContext, 0) );
1277 0 : xHandler->handle(xRequest);
1278 :
1279 0 : if ( pAbort->wasSelected() )
1280 0 : return false;
1281 0 : if ( pDisApprove->wasSelected() )
1282 0 : return true;
1283 0 : if ( pDocuSave && pDocuSave->wasSelected() )
1284 : {
1285 0 : Reference<XNameContainer> xNC( pDocuSave->getContent(), UNO_QUERY_THROW );
1286 :
1287 0 : ::osl::ResettableMutexGuard aGuard( m_aMutex );
1288 0 : NameChangeNotifier aNameChangeAndNotify( *this, pDocuSave->getName(), aGuard );
1289 0 : m_pImpl->m_aProps.aTitle = pDocuSave->getName();
1290 :
1291 0 : Reference< XContent> xContent = this;
1292 0 : xNC->insertByName(pDocuSave->getName(),makeAny(xContent));
1293 :
1294 0 : updateDocumentTitle();
1295 0 : }
1296 : }
1297 :
1298 0 : ::osl::MutexGuard aGuard(m_aMutex);
1299 0 : Reference<XEmbedPersist> xPersist(m_xEmbeddedObject,UNO_QUERY);
1300 0 : if ( xPersist.is() )
1301 : {
1302 0 : xPersist->storeOwn();
1303 0 : notifyDataSourceModified();
1304 0 : }
1305 : }
1306 0 : catch(const Exception&)
1307 : {
1308 : OSL_FAIL("ODocumentDefinition::save: caught an Exception (tried to let the InteractionHandler handle it)!");
1309 : }
1310 0 : return true;
1311 : }
1312 :
1313 0 : bool ODocumentDefinition::saveAs()
1314 : {
1315 : // default handling: instantiate an interaction handler and let it handle the parameter request
1316 0 : if ( !m_bOpenInDesign )
1317 0 : return false;
1318 :
1319 : {
1320 0 : osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
1321 0 : if ( m_pImpl->m_aProps.aTitle.isEmpty() )
1322 : {
1323 0 : aGuard.clear();
1324 0 : return save(false); // (sal_False) : we don't want an approve dialog
1325 0 : }
1326 : }
1327 : try
1328 : {
1329 : {
1330 0 : ::SolarMutexGuard aSolarGuard;
1331 :
1332 : // the request
1333 0 : Reference<XNameAccess> xName(m_xParentContainer,UNO_QUERY);
1334 0 : DocumentSaveRequest aRequest;
1335 0 : aRequest.Name = m_pImpl->m_aProps.aTitle;
1336 :
1337 0 : aRequest.Content.set(m_xParentContainer,UNO_QUERY);
1338 0 : OInteractionRequest* pRequest = new OInteractionRequest(makeAny(aRequest));
1339 0 : Reference< XInteractionRequest > xRequest(pRequest);
1340 : // some knittings
1341 : // two continuations allowed: OK and Cancel
1342 0 : ODocumentSaveContinuation* pDocuSave = new ODocumentSaveContinuation;
1343 0 : pRequest->addContinuation(pDocuSave);
1344 0 : OInteraction< XInteractionDisapprove >* pDisApprove = new OInteraction< XInteractionDisapprove >;
1345 0 : pRequest->addContinuation(pDisApprove);
1346 0 : OInteractionAbort* pAbort = new OInteractionAbort;
1347 0 : pRequest->addContinuation(pAbort);
1348 :
1349 : // create the handler, let it handle the request
1350 0 : Reference< XInteractionHandler2 > xHandler( InteractionHandler::createWithParent(m_aContext, 0) );
1351 0 : xHandler->handle(xRequest);
1352 :
1353 0 : if ( pAbort->wasSelected() )
1354 0 : return false;
1355 0 : if ( pDisApprove->wasSelected() )
1356 0 : return true;
1357 0 : if ( pDocuSave->wasSelected() )
1358 : {
1359 0 : ::osl::MutexGuard aGuard(m_aMutex);
1360 0 : Reference<XNameContainer> xNC(pDocuSave->getContent(),UNO_QUERY);
1361 0 : if ( xNC.is() )
1362 : {
1363 0 : if ( m_pImpl->m_aProps.aTitle != pDocuSave->getName() )
1364 : {
1365 : try
1366 : {
1367 0 : Reference< XStorage> xStorage = getContainerStorage();
1368 0 : const static OUString sBaseName("Obj");
1369 :
1370 0 : OUString sPersistentName = ::dbtools::createUniqueName(xStorage,sBaseName);
1371 0 : xStorage->copyElementTo(m_pImpl->m_aProps.sPersistentName,xStorage,sPersistentName);
1372 :
1373 0 : OUString sOldName = m_pImpl->m_aProps.aTitle;
1374 0 : rename(pDocuSave->getName());
1375 0 : updateDocumentTitle();
1376 :
1377 0 : Sequence< Any > aArguments(3);
1378 0 : PropertyValue aValue;
1379 : // set as folder
1380 0 : aValue.Name = PROPERTY_NAME;
1381 0 : aValue.Value <<= sOldName;
1382 0 : aArguments[0] <<= aValue;
1383 :
1384 0 : aValue.Name = PROPERTY_PERSISTENT_NAME;
1385 0 : aValue.Value <<= sPersistentName;
1386 0 : aArguments[1] <<= aValue;
1387 :
1388 0 : aValue.Name = PROPERTY_AS_TEMPLATE;
1389 0 : aValue.Value <<= m_pImpl->m_aProps.bAsTemplate;
1390 0 : aArguments[2] <<= aValue;
1391 :
1392 0 : Reference< XMultiServiceFactory > xORB( m_xParentContainer, UNO_QUERY_THROW );
1393 0 : Reference< XInterface > xComponent( xORB->createInstanceWithArguments( SERVICE_SDB_DOCUMENTDEFINITION, aArguments ) );
1394 0 : Reference< XNameContainer > xNameContainer( m_xParentContainer, UNO_QUERY_THROW );
1395 0 : xNameContainer->insertByName( sOldName, makeAny( xComponent ) );
1396 : }
1397 0 : catch(const Exception&)
1398 : {
1399 : DBG_UNHANDLED_EXCEPTION();
1400 : }
1401 : }
1402 0 : Reference<XEmbedPersist> xPersist(m_xEmbeddedObject,UNO_QUERY);
1403 0 : if ( xPersist.is() )
1404 : {
1405 0 : xPersist->storeOwn();
1406 0 : notifyDataSourceModified();
1407 0 : }
1408 0 : }
1409 0 : }
1410 : }
1411 :
1412 : }
1413 0 : catch(const Exception&)
1414 : {
1415 : OSL_FAIL("ODocumentDefinition::save: caught an Exception (tried to let the InteractionHandler handle it)!");
1416 : }
1417 0 : return true;
1418 : }
1419 :
1420 : namespace
1421 : {
1422 0 : void lcl_putLoadArgs( ::comphelper::NamedValueCollection& _io_rArgs, const optional_bool _bSuppressMacros, const optional_bool _bReadOnly )
1423 : {
1424 0 : if ( !!_bSuppressMacros )
1425 : {
1426 0 : if ( *_bSuppressMacros )
1427 : {
1428 : // if we're to suppress macros, do exactly this
1429 0 : _io_rArgs.put( "MacroExecutionMode", MacroExecMode::NEVER_EXECUTE );
1430 : }
1431 : else
1432 : {
1433 : // otherwise, put the setting only if not already present
1434 0 : if ( !_io_rArgs.has( "MacroExecutionMode" ) )
1435 : {
1436 0 : _io_rArgs.put( "MacroExecutionMode", MacroExecMode::USE_CONFIG );
1437 : }
1438 : }
1439 : }
1440 :
1441 0 : if ( !!_bReadOnly )
1442 0 : _io_rArgs.put( "ReadOnly", *_bReadOnly );
1443 0 : }
1444 : }
1445 :
1446 : namespace
1447 : {
1448 0 : Reference< XFrame > lcl_getDatabaseDocumentFrame( ODatabaseModelImpl& _rImpl )
1449 : {
1450 0 : Reference< XModel > xDatabaseDocumentModel( _rImpl.getModel_noCreate() );
1451 :
1452 0 : Reference< XController > xDatabaseDocumentController;
1453 0 : if ( xDatabaseDocumentModel.is() )
1454 0 : xDatabaseDocumentController = xDatabaseDocumentModel->getCurrentController();
1455 :
1456 0 : Reference< XFrame > xFrame;
1457 0 : if ( xDatabaseDocumentController.is() )
1458 0 : xFrame = xDatabaseDocumentController->getFrame();
1459 :
1460 0 : return xFrame;
1461 : }
1462 : }
1463 :
1464 0 : bool ODocumentDefinition::objectSupportsEmbeddedScripts() const
1465 : {
1466 0 : bool bAllowDocumentMacros = !m_pImpl->m_pDataSource
1467 0 : || ( m_pImpl->m_pDataSource->determineEmbeddedMacros() == ODatabaseModelImpl::eSubDocumentMacros );
1468 :
1469 : // if *any* of the objects of the database document already has macros, we
1470 : // continue to allow it to have them, until the user does a migration.
1471 : // If there are no macros, we don't allow them to be created.
1472 :
1473 0 : return bAllowDocumentMacros;
1474 : }
1475 :
1476 0 : OUString ODocumentDefinition::determineContentType() const
1477 : {
1478 0 : return lcl_determineContentType_nothrow( getContainerStorage(), m_pImpl->m_aProps.sPersistentName );
1479 : }
1480 :
1481 0 : void ODocumentDefinition::separateOpenCommandArguments( const Sequence< PropertyValue >& i_rOpenCommandArguments,
1482 : ::comphelper::NamedValueCollection& o_rDocumentLoadArgs, ::comphelper::NamedValueCollection& o_rEmbeddedObjectDescriptor )
1483 : {
1484 0 : ::comphelper::NamedValueCollection aOpenCommandArguments( i_rOpenCommandArguments );
1485 :
1486 : const sal_Char* pObjectDescriptorArgs[] =
1487 : {
1488 : "RecoveryStorage"
1489 0 : };
1490 0 : for ( size_t i=0; i < sizeof( pObjectDescriptorArgs ) / sizeof( pObjectDescriptorArgs[0] ); ++i )
1491 : {
1492 0 : if ( aOpenCommandArguments.has( pObjectDescriptorArgs[i] ) )
1493 : {
1494 0 : o_rEmbeddedObjectDescriptor.put( pObjectDescriptorArgs[i], aOpenCommandArguments.get( pObjectDescriptorArgs[i] ) );
1495 0 : aOpenCommandArguments.remove( pObjectDescriptorArgs[i] );
1496 : }
1497 : }
1498 :
1499 0 : o_rDocumentLoadArgs.merge( aOpenCommandArguments, false );
1500 0 : }
1501 :
1502 0 : Sequence< PropertyValue > ODocumentDefinition::fillLoadArgs( const Reference< XConnection>& _xConnection, const bool _bSuppressMacros, const bool _bReadOnly,
1503 : const Sequence< PropertyValue >& i_rOpenCommandArguments, Sequence< PropertyValue >& _out_rEmbeddedObjectDescriptor )
1504 : {
1505 : // (re-)create interceptor, and put it into the descriptor of the embedded object
1506 0 : if ( m_pInterceptor )
1507 : {
1508 0 : m_pInterceptor->dispose();
1509 0 : m_pInterceptor->release();
1510 0 : m_pInterceptor = NULL;
1511 : }
1512 :
1513 0 : m_pInterceptor = new OInterceptor( this );
1514 0 : m_pInterceptor->acquire();
1515 0 : Reference<XDispatchProviderInterceptor> xInterceptor = m_pInterceptor;
1516 :
1517 0 : ::comphelper::NamedValueCollection aEmbeddedDescriptor;
1518 0 : aEmbeddedDescriptor.put( "OutplaceDispatchInterceptor", xInterceptor );
1519 :
1520 0 : ::comphelper::NamedValueCollection aMediaDesc;
1521 0 : separateOpenCommandArguments( i_rOpenCommandArguments, aMediaDesc, aEmbeddedDescriptor );
1522 :
1523 : // create the OutplaceFrameProperties, and put them into the descriptor of the embedded object
1524 0 : ::comphelper::NamedValueCollection OutplaceFrameProperties;
1525 0 : OutplaceFrameProperties.put( "TopWindow", true );
1526 0 : OutplaceFrameProperties.put( "SupportPersistentWindowState", true );
1527 :
1528 0 : Reference< XFrame > xParentFrame;
1529 0 : if ( m_pImpl->m_pDataSource )
1530 0 : xParentFrame = lcl_getDatabaseDocumentFrame( *m_pImpl->m_pDataSource );
1531 0 : if ( !xParentFrame.is() )
1532 : { // i87957 we need a parent frame
1533 0 : Reference< XDesktop2 > xDesktop = Desktop::create( m_aContext );
1534 0 : xParentFrame.set( xDesktop, UNO_QUERY_THROW );
1535 0 : Reference<util::XCloseable> xCloseable(m_pImpl->m_pDataSource->getModel_noCreate(),UNO_QUERY);
1536 0 : if ( xCloseable.is() )
1537 : {
1538 0 : xCloseable->addCloseListener(this);
1539 0 : m_bRemoveListener = true;
1540 0 : }
1541 : }
1542 : OSL_ENSURE( xParentFrame.is(), "ODocumentDefinition::fillLoadArgs: no parent frame!" );
1543 0 : if ( xParentFrame.is() )
1544 0 : OutplaceFrameProperties.put( "ParentFrame", xParentFrame );
1545 :
1546 0 : aEmbeddedDescriptor.put( "OutplaceFrameProperties", OutplaceFrameProperties.getNamedValues() );
1547 :
1548 : // tell the embedded object to have (or not have) script support
1549 0 : aEmbeddedDescriptor.put( "EmbeddedScriptSupport", objectSupportsEmbeddedScripts() );
1550 :
1551 : // tell the embedded object to not participate in the document recovery game - the DB doc will handle it
1552 0 : aEmbeddedDescriptor.put( "DocumentRecoverySupport", false );
1553 :
1554 : // pass the descriptor of the embedded object to the caller
1555 0 : aEmbeddedDescriptor >>= _out_rEmbeddedObjectDescriptor;
1556 :
1557 : // create the ComponentData, and put it into the document's media descriptor
1558 : {
1559 0 : ::comphelper::NamedValueCollection aComponentData;
1560 0 : aComponentData.put( "ActiveConnection", _xConnection );
1561 0 : aComponentData.put( "ApplyFormDesignMode", !_bReadOnly );
1562 0 : aMediaDesc.put( "ComponentData", aComponentData.getPropertyValues() );
1563 : }
1564 :
1565 0 : if ( !m_pImpl->m_aProps.aTitle.isEmpty() )
1566 0 : aMediaDesc.put( "DocumentTitle", m_pImpl->m_aProps.aTitle );
1567 :
1568 0 : aMediaDesc.put( "DocumentBaseURL", m_pImpl->m_pDataSource->getURL() );
1569 :
1570 : // put the common load arguments into the document's media descriptor
1571 0 : lcl_putLoadArgs( aMediaDesc, optional_bool( _bSuppressMacros ), optional_bool( _bReadOnly ) );
1572 :
1573 0 : return aMediaDesc.getPropertyValues();
1574 : }
1575 :
1576 0 : void ODocumentDefinition::loadEmbeddedObject( const Reference< XConnection >& i_rConnection, const Sequence< sal_Int8 >& _aClassID,
1577 : const Sequence< PropertyValue >& i_rOpenCommandArguments, const bool _bSuppressMacros, const bool _bReadOnly )
1578 : {
1579 0 : if ( !m_xEmbeddedObject.is() )
1580 : {
1581 0 : Reference< XStorage> xStorage = getContainerStorage();
1582 0 : if ( xStorage.is() )
1583 : {
1584 0 : Reference< XEmbeddedObjectCreator> xEmbedFactory = OOoEmbeddedObjectFactory::create(m_aContext);
1585 0 : OUString sDocumentService;
1586 0 : bool bSetSize = false;
1587 0 : sal_Int32 nEntryConnectionMode = EntryInitModes::DEFAULT_INIT;
1588 0 : Sequence< sal_Int8 > aClassID = _aClassID;
1589 0 : if ( aClassID.getLength() )
1590 : {
1591 0 : nEntryConnectionMode = EntryInitModes::TRUNCATE_INIT;
1592 0 : bSetSize = true;
1593 : }
1594 : else
1595 : {
1596 0 : sDocumentService = GetDocumentServiceFromMediaType( getContentType(), m_aContext, aClassID );
1597 : // check if we are not a form and
1598 : // the org.libreoffice.report.pentaho.SOReportJobFactory is not present.
1599 0 : if ( !m_bForm && !(sDocumentService == "com.sun.star.text.TextDocument"))
1600 : {
1601 : // we seem to be a "new style" report, check if report extension is present.
1602 0 : Reference< XContentEnumerationAccess > xEnumAccess( m_aContext->getServiceManager(), UNO_QUERY );
1603 0 : const OUString sReportEngineServiceName = ::dbtools::getDefaultReportEngineServiceName(m_aContext);
1604 0 : Reference< XEnumeration > xEnumDrivers = xEnumAccess->createContentEnumeration(sReportEngineServiceName);
1605 0 : if ( !xEnumDrivers.is() || !xEnumDrivers->hasMoreElements() )
1606 : {
1607 0 : com::sun::star::io::WrongFormatException aWFE;
1608 0 : aWFE.Message = DBACORE_RESSTRING( RID_STR_MISSING_EXTENSION );
1609 0 : throw aWFE;
1610 0 : }
1611 : }
1612 0 : if ( !aClassID.getLength() )
1613 : {
1614 0 : if ( m_bForm )
1615 0 : aClassID = MimeConfigurationHelper::GetSequenceClassID(SO3_SW_CLASSID);
1616 : else
1617 : {
1618 0 : aClassID = MimeConfigurationHelper::GetSequenceClassID(SO3_RPT_CLASSID_90);
1619 : }
1620 : }
1621 : }
1622 :
1623 : OSL_ENSURE( aClassID.getLength(),"No Class ID" );
1624 :
1625 0 : Sequence< PropertyValue > aEmbeddedObjectDescriptor;
1626 : Sequence< PropertyValue > aLoadArgs( fillLoadArgs(
1627 0 : i_rConnection, _bSuppressMacros, _bReadOnly, i_rOpenCommandArguments, aEmbeddedObjectDescriptor ) );
1628 :
1629 0 : m_xEmbeddedObject.set(xEmbedFactory->createInstanceUserInit(aClassID
1630 : ,sDocumentService
1631 : ,xStorage
1632 0 : ,m_pImpl->m_aProps.sPersistentName
1633 : ,nEntryConnectionMode
1634 : ,aLoadArgs
1635 : ,aEmbeddedObjectDescriptor
1636 0 : ),UNO_QUERY);
1637 0 : if ( m_xEmbeddedObject.is() )
1638 : {
1639 0 : if ( !m_pClientHelper )
1640 : {
1641 0 : m_pClientHelper = new OEmbeddedClientHelper(this);
1642 0 : m_pClientHelper->acquire();
1643 : }
1644 0 : Reference<XEmbeddedClient> xClient = m_pClientHelper;
1645 0 : m_xEmbeddedObject->setClientSite(xClient);
1646 0 : m_xEmbeddedObject->changeState(EmbedStates::RUNNING);
1647 0 : if ( bSetSize )
1648 : {
1649 0 : LockModifiable aLockModify( impl_getComponent_throw( false ) );
1650 :
1651 0 : awt::Size aSize( DEFAULT_WIDTH, DEFAULT_HEIGHT );
1652 0 : m_xEmbeddedObject->setVisualAreaSize(Aspects::MSOLE_CONTENT,aSize);
1653 0 : }
1654 0 : }
1655 0 : }
1656 : }
1657 : else
1658 : {
1659 0 : sal_Int32 nCurrentState = m_xEmbeddedObject->getCurrentState();
1660 0 : if ( nCurrentState == EmbedStates::LOADED )
1661 : {
1662 0 : if ( !m_pClientHelper )
1663 : {
1664 0 : m_pClientHelper = new OEmbeddedClientHelper(this);
1665 0 : m_pClientHelper->acquire();
1666 : }
1667 0 : Reference<XEmbeddedClient> xClient = m_pClientHelper;
1668 0 : m_xEmbeddedObject->setClientSite(xClient);
1669 :
1670 0 : Sequence< PropertyValue > aEmbeddedObjectDescriptor;
1671 : Sequence< PropertyValue > aLoadArgs( fillLoadArgs(
1672 0 : i_rConnection, _bSuppressMacros, _bReadOnly, i_rOpenCommandArguments, aEmbeddedObjectDescriptor ) );
1673 :
1674 0 : Reference<XCommonEmbedPersist> xCommon(m_xEmbeddedObject,UNO_QUERY);
1675 : OSL_ENSURE(xCommon.is(),"unsupported interface!");
1676 0 : if ( xCommon.is() )
1677 0 : xCommon->reload( aLoadArgs, aEmbeddedObjectDescriptor );
1678 0 : m_xEmbeddedObject->changeState(EmbedStates::RUNNING);
1679 : }
1680 : else
1681 : {
1682 : OSL_ENSURE( ( nCurrentState == EmbedStates::RUNNING ) || ( nCurrentState == EmbedStates::ACTIVE ),
1683 : "ODocumentDefinition::loadEmbeddedObject: unexpected state!" );
1684 :
1685 : // if the document was already loaded (which means the embedded object is in state RUNNING or ACTIVE),
1686 : // then just re-set some model parameters
1687 : try
1688 : {
1689 : // ensure the media descriptor doesn't contain any values which are intended for the
1690 : // EmbeddedObjectDescriptor only
1691 0 : ::comphelper::NamedValueCollection aEmbeddedObjectDescriptor;
1692 0 : ::comphelper::NamedValueCollection aNewMediaDesc;
1693 0 : separateOpenCommandArguments( i_rOpenCommandArguments, aNewMediaDesc, aEmbeddedObjectDescriptor );
1694 :
1695 : // merge the new media descriptor into the existing media descriptor
1696 0 : const Reference< XModel > xModel( getComponent(), UNO_QUERY_THROW );
1697 0 : const Sequence< PropertyValue > aArgs = xModel->getArgs();
1698 0 : ::comphelper::NamedValueCollection aExistentMediaDesc( aArgs );
1699 0 : aExistentMediaDesc.merge( aNewMediaDesc, false );
1700 :
1701 0 : lcl_putLoadArgs( aExistentMediaDesc, optional_bool(), optional_bool() );
1702 : // don't put _bSuppressMacros and _bReadOnly here - if the document was already
1703 : // loaded, we should not tamper with its settings.
1704 : // #i88977# #i86872#
1705 :
1706 0 : xModel->attachResource( xModel->getURL(), aExistentMediaDesc.getPropertyValues() );
1707 : }
1708 0 : catch( const Exception& )
1709 : {
1710 : DBG_UNHANDLED_EXCEPTION();
1711 : }
1712 : }
1713 : }
1714 :
1715 : // set the OfficeDatabaseDocument instance as parent of the embedded document
1716 : // #i40358#
1717 0 : Reference< XChild > xDepdendDocAsChild( getComponent(), UNO_QUERY );
1718 0 : if ( xDepdendDocAsChild.is() )
1719 : {
1720 : try
1721 : {
1722 0 : if ( !xDepdendDocAsChild->getParent().is() )
1723 : { // first encounter
1724 0 : xDepdendDocAsChild->setParent( getDataSource( m_xParentContainer ) );
1725 : }
1726 : }
1727 0 : catch( const Exception& )
1728 : {
1729 : DBG_UNHANDLED_EXCEPTION();
1730 : }
1731 : }
1732 :
1733 0 : if ( i_rConnection.is() )
1734 0 : m_xLastKnownConnection = i_rConnection;
1735 0 : }
1736 :
1737 0 : void ODocumentDefinition::onCommandPreview(Any& _rImage)
1738 : {
1739 0 : loadEmbeddedObjectForPreview();
1740 0 : if ( m_xEmbeddedObject.is() )
1741 : {
1742 : try
1743 : {
1744 0 : Reference<XTransferable> xTransfer(getComponent(),UNO_QUERY);
1745 0 : if ( xTransfer.is() )
1746 : {
1747 0 : DataFlavor aFlavor;
1748 0 : aFlavor.MimeType = "image/png";
1749 0 : aFlavor.HumanPresentableName = "Portable Network Graphics";
1750 0 : aFlavor.DataType = ::getCppuType(static_cast< const Sequence < sal_Int8 >* >(NULL));
1751 :
1752 0 : _rImage = xTransfer->getTransferData( aFlavor );
1753 0 : }
1754 : }
1755 0 : catch( const Exception& )
1756 : {
1757 : }
1758 : }
1759 0 : }
1760 :
1761 0 : void ODocumentDefinition::getPropertyDefaultByHandle( sal_Int32 /*_nHandle*/, Any& _rDefault ) const
1762 : {
1763 0 : _rDefault.clear();
1764 0 : }
1765 :
1766 0 : void ODocumentDefinition::onCommandGetDocumentProperties( Any& _rProps )
1767 : {
1768 0 : loadEmbeddedObjectForPreview();
1769 0 : if ( m_xEmbeddedObject.is() )
1770 : {
1771 : try
1772 : {
1773 : Reference<XDocumentPropertiesSupplier> xDocSup(
1774 0 : getComponent(), UNO_QUERY );
1775 0 : if ( xDocSup.is() )
1776 0 : _rProps <<= xDocSup->getDocumentProperties();
1777 : }
1778 0 : catch( const Exception& )
1779 : {
1780 : DBG_UNHANDLED_EXCEPTION();
1781 : }
1782 : }
1783 0 : }
1784 :
1785 0 : Reference< util::XCloseable > ODocumentDefinition::impl_getComponent_throw( const bool i_ForceCreate )
1786 : {
1787 : OSL_ENSURE(m_xEmbeddedObject.is(),"Illegal call for embeddedObject");
1788 0 : Reference< util::XCloseable > xComp;
1789 0 : if ( m_xEmbeddedObject.is() )
1790 : {
1791 0 : int nState = m_xEmbeddedObject->getCurrentState();
1792 0 : if ( ( nState == EmbedStates::LOADED ) && i_ForceCreate )
1793 : {
1794 0 : m_xEmbeddedObject->changeState( EmbedStates::RUNNING );
1795 0 : nState = m_xEmbeddedObject->getCurrentState();
1796 : OSL_ENSURE( nState == EmbedStates::RUNNING, "ODocumentDefinition::impl_getComponent_throw: could not switch to RUNNING!" );
1797 : }
1798 :
1799 0 : if ( nState == EmbedStates::ACTIVE || nState == EmbedStates::RUNNING )
1800 : {
1801 0 : Reference<XComponentSupplier> xCompProv(m_xEmbeddedObject,UNO_QUERY);
1802 0 : if ( xCompProv.is() )
1803 : {
1804 0 : xComp = xCompProv->getComponent();
1805 : OSL_ENSURE(xComp.is(),"No valid component");
1806 0 : }
1807 : }
1808 : }
1809 0 : return xComp;
1810 : }
1811 :
1812 0 : Reference< util::XCloseable > ODocumentDefinition::getComponent() throw (RuntimeException, std::exception)
1813 : {
1814 0 : ::osl::MutexGuard aGuard( m_aMutex );
1815 0 : return impl_getComponent_throw( true );
1816 : }
1817 :
1818 : namespace
1819 : {
1820 0 : Reference< XDatabaseDocumentUI > lcl_getDatabaseDocumentUI( ODatabaseModelImpl& _rModelImpl )
1821 : {
1822 0 : Reference< XDatabaseDocumentUI > xUI;
1823 :
1824 0 : Reference< XModel > xModel( _rModelImpl.getModel_noCreate() );
1825 0 : if ( xModel.is() )
1826 0 : xUI.set( xModel->getCurrentController(), UNO_QUERY );
1827 0 : return xUI;
1828 : }
1829 : }
1830 :
1831 0 : Reference< XComponent > ODocumentDefinition::impl_openUI_nolck_throw( bool _bForEditing )
1832 : {
1833 0 : ::osl::ClearableMutexGuard aGuard( m_aMutex );
1834 0 : if ( !m_pImpl || !m_pImpl->m_pDataSource )
1835 0 : throw DisposedException();
1836 :
1837 0 : Reference< XComponent > xComponent;
1838 : try
1839 : {
1840 0 : Reference< XDatabaseDocumentUI > xUI( lcl_getDatabaseDocumentUI( *m_pImpl->m_pDataSource ) );
1841 0 : if ( !xUI.is() )
1842 : {
1843 : // no XDatabaseDocumentUI -> just execute the respective command
1844 0 : m_bOpenInDesign = _bForEditing;
1845 0 : xComponent = Reference<XComponent>(onCommandOpenSomething(Any(), true, NULL), UNO_QUERY);
1846 : OSL_ENSURE( xComponent.is(), "ODocumentDefinition::impl_openUI_nolck_throw: opening the thingie failed." );
1847 0 : return xComponent;
1848 : }
1849 :
1850 :
1851 0 : OUString sName( impl_getHierarchicalName( false ) );
1852 0 : sal_Int32 nObjectType = m_bForm ? DatabaseObject::FORM : DatabaseObject::REPORT;
1853 0 : aGuard.clear();
1854 :
1855 0 : xComponent = xUI->loadComponent(
1856 : nObjectType, sName, _bForEditing
1857 0 : );
1858 : }
1859 0 : catch( const RuntimeException& ) { throw; }
1860 0 : catch( const Exception& )
1861 : {
1862 : throw WrappedTargetException(
1863 0 : OUString(), *this, ::cppu::getCaughtException() );
1864 : }
1865 :
1866 0 : return xComponent;
1867 : }
1868 :
1869 0 : void ODocumentDefinition::impl_store_throw()
1870 : {
1871 0 : Reference<XEmbedPersist> xPersist( m_xEmbeddedObject, UNO_QUERY );
1872 0 : if ( xPersist.is() )
1873 : {
1874 0 : xPersist->storeOwn();
1875 0 : notifyDataSourceModified();
1876 0 : }
1877 0 : }
1878 :
1879 0 : bool ODocumentDefinition::impl_close_throw()
1880 : {
1881 0 : bool bSuccess = prepareClose();
1882 0 : if ( bSuccess && m_xEmbeddedObject.is() )
1883 : {
1884 0 : m_xEmbeddedObject->changeState( EmbedStates::LOADED );
1885 0 : bSuccess = m_xEmbeddedObject->getCurrentState() == EmbedStates::LOADED;
1886 : }
1887 0 : return bSuccess;
1888 : }
1889 :
1890 0 : Reference< XComponent > SAL_CALL ODocumentDefinition::open( ) throw (WrappedTargetException, RuntimeException, std::exception)
1891 : {
1892 0 : return impl_openUI_nolck_throw( false );
1893 : }
1894 :
1895 0 : Reference< XComponent > SAL_CALL ODocumentDefinition::openDesign( ) throw (WrappedTargetException, RuntimeException, std::exception)
1896 : {
1897 0 : return impl_openUI_nolck_throw( true );
1898 : }
1899 :
1900 0 : void SAL_CALL ODocumentDefinition::store( ) throw (WrappedTargetException, RuntimeException, std::exception)
1901 : {
1902 0 : ::osl::MutexGuard aGuard( m_aMutex );
1903 : try
1904 : {
1905 0 : impl_store_throw();
1906 : }
1907 0 : catch( const RuntimeException& ) { throw; }
1908 0 : catch( const Exception& )
1909 : {
1910 : throw WrappedTargetException(
1911 0 : OUString(), *this, ::cppu::getCaughtException() );
1912 0 : }
1913 0 : }
1914 :
1915 0 : sal_Bool SAL_CALL ODocumentDefinition::close( ) throw (WrappedTargetException, RuntimeException, std::exception)
1916 : {
1917 0 : ::osl::MutexGuard aGuard( m_aMutex );
1918 :
1919 0 : bool bSuccess = false;
1920 : try
1921 : {
1922 0 : bSuccess = impl_close_throw();
1923 : }
1924 0 : catch( const RuntimeException& ) { throw; }
1925 0 : catch( const Exception& )
1926 : {
1927 : throw WrappedTargetException(
1928 0 : OUString(), *this, ::cppu::getCaughtException() );
1929 : }
1930 0 : return bSuccess;
1931 : }
1932 :
1933 0 : OUString SAL_CALL ODocumentDefinition::getHierarchicalName() throw (RuntimeException, std::exception)
1934 : {
1935 0 : ::osl::MutexGuard aGuard( m_aMutex );
1936 0 : return impl_getHierarchicalName( false );
1937 : }
1938 :
1939 0 : OUString SAL_CALL ODocumentDefinition::composeHierarchicalName( const OUString& i_rRelativeName ) throw (IllegalArgumentException, NoSupportException, RuntimeException, std::exception)
1940 : {
1941 0 : OUStringBuffer aBuffer;
1942 0 : aBuffer.append( getHierarchicalName() );
1943 0 : aBuffer.append( '/' );
1944 0 : aBuffer.append( i_rRelativeName );
1945 0 : return aBuffer.makeStringAndClear();
1946 : }
1947 :
1948 0 : void SAL_CALL ODocumentDefinition::rename( const OUString& _rNewName ) throw (SQLException, ElementExistException, RuntimeException, std::exception)
1949 : {
1950 : try
1951 : {
1952 0 : ::osl::ResettableMutexGuard aGuard(m_aMutex);
1953 0 : if ( _rNewName.equals( m_pImpl->m_aProps.aTitle ) )
1954 0 : return;
1955 :
1956 : // document definitions are organized in a hierarchical way, so reject names
1957 : // which contain a /, as this is reserved for hierarchy level separation
1958 0 : if ( _rNewName.indexOf( '/' ) != -1 )
1959 0 : m_aErrorHelper.raiseException( ErrorCondition::DB_OBJECT_NAME_WITH_SLASHES, *this );
1960 :
1961 0 : NameChangeNotifier aNameChangeAndNotify( *this, _rNewName, aGuard );
1962 0 : m_pImpl->m_aProps.aTitle = _rNewName;
1963 :
1964 0 : if ( m_xEmbeddedObject.is() && m_xEmbeddedObject->getCurrentState() == EmbedStates::ACTIVE )
1965 0 : updateDocumentTitle();
1966 : }
1967 0 : catch(const PropertyVetoException&)
1968 : {
1969 0 : throw ElementExistException(_rNewName,*this);
1970 : }
1971 : }
1972 :
1973 0 : Reference< XStorage> ODocumentDefinition::getContainerStorage() const
1974 : {
1975 0 : return m_pImpl->m_pDataSource
1976 0 : ? m_pImpl->m_pDataSource->getStorage( m_bForm ? ODatabaseModelImpl::E_FORM : ODatabaseModelImpl::E_REPORT )
1977 0 : : Reference< XStorage>();
1978 : }
1979 :
1980 0 : bool ODocumentDefinition::isModified()
1981 : {
1982 0 : osl::ClearableGuard< osl::Mutex > aGuard(m_aMutex);
1983 0 : bool bRet = false;
1984 0 : if ( m_xEmbeddedObject.is() )
1985 : {
1986 0 : Reference<XModifiable> xModel(getComponent(),UNO_QUERY);
1987 0 : bRet = xModel.is() && xModel->isModified();
1988 : }
1989 0 : return bRet;
1990 : }
1991 :
1992 0 : bool ODocumentDefinition::prepareClose()
1993 : {
1994 0 : if ( !m_xEmbeddedObject.is() )
1995 0 : return true;
1996 :
1997 : try
1998 : {
1999 : // suspend the controller. Embedded objects are not allowed to raise
2000 : // own UI at their own discretion, instead, this has always to be triggered
2001 : // by the embedding component. Thus, we do the suspend call here.
2002 : // #i49370#
2003 :
2004 0 : Reference< util::XCloseable > xComponent( impl_getComponent_throw( false ) );
2005 0 : if ( !xComponent.is() )
2006 0 : return true;
2007 :
2008 0 : Reference< XModel > xModel( xComponent, UNO_QUERY );
2009 0 : Reference< XController > xController;
2010 0 : if ( xModel.is() )
2011 0 : xController = xModel->getCurrentController();
2012 :
2013 : OSL_ENSURE( xController.is() || ( m_xEmbeddedObject->getCurrentState() < EmbedStates::ACTIVE ),
2014 : "ODocumentDefinition::prepareClose: no controller!" );
2015 0 : if ( !xController.is() )
2016 : // document has not yet been activated, i.e. has no UI, yet
2017 0 : return true;
2018 :
2019 0 : bool bCouldSuspend = xController->suspend( sal_True );
2020 0 : if ( !bCouldSuspend )
2021 : // controller vetoed the closing
2022 0 : return false;
2023 :
2024 0 : if ( isModified() )
2025 : {
2026 0 : Reference< XFrame > xFrame( xController->getFrame() );
2027 0 : if ( xFrame.is() )
2028 : {
2029 0 : Reference< XTopWindow > xTopWindow( xFrame->getContainerWindow(), UNO_QUERY_THROW );
2030 0 : xTopWindow->toFront();
2031 : }
2032 0 : if ( !save( true ) )
2033 : {
2034 0 : if ( bCouldSuspend )
2035 : // revert suspension
2036 0 : xController->suspend( sal_False );
2037 : // saving failed or was cancelled
2038 0 : return false;
2039 0 : }
2040 0 : }
2041 : }
2042 0 : catch( const Exception& )
2043 : {
2044 : DBG_UNHANDLED_EXCEPTION();
2045 : }
2046 :
2047 0 : return true;
2048 : }
2049 :
2050 0 : void ODocumentDefinition::fillReportData( const Reference< XComponentContext >& _rContext,
2051 : const Reference< util::XCloseable >& _rxComponent,
2052 : const Reference< XConnection >& _rxActiveConnection )
2053 : {
2054 0 : Sequence< Any > aArgs(2);
2055 0 : PropertyValue aValue;
2056 0 : aValue.Name = "TextDocument";
2057 0 : aValue.Value <<= _rxComponent;
2058 0 : aArgs[0] <<= aValue;
2059 0 : aValue.Name = "ActiveConnection";
2060 0 : aValue.Value <<= _rxActiveConnection;
2061 0 : aArgs[1] <<= aValue;
2062 :
2063 : try
2064 : {
2065 : Reference< XJobExecutor > xExecuteable(
2066 0 : _rContext->getServiceManager()->createInstanceWithArgumentsAndContext("com.sun.star.wizards.report.CallReportWizard", aArgs, _rContext), UNO_QUERY_THROW );
2067 0 : xExecuteable->trigger( "fill" );
2068 : }
2069 0 : catch( const Exception& )
2070 : {
2071 : DBG_UNHANDLED_EXCEPTION();
2072 0 : }
2073 0 : }
2074 :
2075 0 : void ODocumentDefinition::updateDocumentTitle()
2076 : {
2077 0 : OUString sName = m_pImpl->m_aProps.aTitle;
2078 0 : if ( m_pImpl->m_pDataSource )
2079 : {
2080 0 : if ( sName.isEmpty() )
2081 : {
2082 0 : if ( m_bForm )
2083 0 : sName = DBACORE_RESSTRING( RID_STR_FORM );
2084 : else
2085 0 : sName = DBACORE_RESSTRING( RID_STR_REPORT );
2086 0 : Reference< XUntitledNumbers > xUntitledProvider(m_pImpl->m_pDataSource->getModel_noCreate(), UNO_QUERY );
2087 0 : if ( xUntitledProvider.is() )
2088 0 : sName += OUString::number( xUntitledProvider->leaseNumber(getComponent()) );
2089 : }
2090 :
2091 0 : Reference< XTitle > xDatabaseDocumentModel(m_pImpl->m_pDataSource->getModel_noCreate(),uno::UNO_QUERY);
2092 0 : if ( xDatabaseDocumentModel.is() )
2093 0 : sName = xDatabaseDocumentModel->getTitle() + " : " + sName;
2094 : }
2095 0 : Reference< XTitle> xTitle(getComponent(),UNO_QUERY);
2096 0 : if ( xTitle.is() )
2097 0 : xTitle->setTitle(sName);
2098 0 : }
2099 :
2100 0 : void SAL_CALL ODocumentDefinition::queryClosing( const lang::EventObject& Source, sal_Bool GetsOwnership ) throw (util::CloseVetoException, uno::RuntimeException, std::exception)
2101 : {
2102 : (void) Source;
2103 : (void) GetsOwnership;
2104 : try
2105 : {
2106 0 : if ( !close() )
2107 0 : throw util::CloseVetoException();
2108 : }
2109 0 : catch(const lang::WrappedTargetException&)
2110 : {
2111 0 : throw util::CloseVetoException();
2112 : }
2113 0 : }
2114 :
2115 0 : void SAL_CALL ODocumentDefinition::notifyClosing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException, std::exception)
2116 : {
2117 0 : }
2118 :
2119 0 : void SAL_CALL ODocumentDefinition::disposing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException, std::exception)
2120 : {
2121 0 : }
2122 :
2123 0 : void ODocumentDefinition::firePropertyChange( sal_Int32 i_nHandle, const Any& i_rNewValue, const Any& i_rOldValue,
2124 : bool i_bVetoable, const NotifierAccess )
2125 : {
2126 0 : fire( &i_nHandle, &i_rNewValue, &i_rOldValue, 1, i_bVetoable );
2127 0 : }
2128 :
2129 : // NameChangeNotifier
2130 0 : NameChangeNotifier::NameChangeNotifier( ODocumentDefinition& i_rDocumentDefinition, const OUString& i_rNewName,
2131 : ::osl::ResettableMutexGuard& i_rClearForNotify )
2132 : :m_rDocumentDefinition( i_rDocumentDefinition )
2133 0 : ,m_aOldValue( makeAny( i_rDocumentDefinition.getCurrentName() ) )
2134 : ,m_aNewValue( makeAny( i_rNewName ) )
2135 0 : ,m_rClearForNotify( i_rClearForNotify )
2136 : {
2137 0 : impl_fireEvent_throw( true );
2138 0 : }
2139 :
2140 0 : NameChangeNotifier::~NameChangeNotifier()
2141 : {
2142 0 : impl_fireEvent_throw( false );
2143 0 : }
2144 :
2145 0 : void NameChangeNotifier::impl_fireEvent_throw( const bool i_bVetoable )
2146 : {
2147 0 : m_rClearForNotify.clear();
2148 : m_rDocumentDefinition.firePropertyChange(
2149 0 : PROPERTY_ID_NAME, m_aNewValue, m_aOldValue, i_bVetoable, ODocumentDefinition::NotifierAccess() );
2150 0 : m_rClearForNotify.reset();
2151 0 : }
2152 :
2153 168 : } // namespace dbaccess
2154 :
2155 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
