?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
build fix
[LibreOffice.git] / embeddedobj / source / commonembedding / persistence.cxx
blob036dc026735d9ba48d5f53dd9ad055ffe7ea0571
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 <commonembobj.hxx>
21 #include <com/sun/star/embed/Aspects.hpp>
22 #include <com/sun/star/document/XStorageBasedDocument.hpp>
23 #include <com/sun/star/embed/EmbedStates.hpp>
24 #include <com/sun/star/embed/EmbedVerbs.hpp>
25 #include <com/sun/star/embed/EntryInitModes.hpp>
26 #include <com/sun/star/embed/XStorage.hpp>
27 #include <com/sun/star/embed/XOptimizedStorage.hpp>
28 #include <com/sun/star/embed/ElementModes.hpp>
29 #include <com/sun/star/embed/EmbedUpdateModes.hpp>
30 #include <com/sun/star/embed/StorageFactory.hpp>
31 #include <com/sun/star/io/TempFile.hpp>
32 #include <com/sun/star/frame/XModel.hpp>
33 #include <com/sun/star/frame/XStorable.hpp>
34 #include <com/sun/star/frame/XLoadable.hpp>
35 #include <com/sun/star/frame/XComponentLoader.hpp>
36 #include <com/sun/star/frame/XModule.hpp>
37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
38 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
39 #include <com/sun/star/lang/DisposedException.hpp>
40 #include <com/sun/star/util/XModifiable.hpp>
41
42 #include <com/sun/star/container/XNameAccess.hpp>
43 #include <com/sun/star/container/XChild.hpp>
44 #include <com/sun/star/util/XCloseable.hpp>
45 #include <com/sun/star/beans/XPropertySet.hpp>
46 #include <com/sun/star/beans/IllegalTypeException.hpp>
47 #include <com/sun/star/chart2/XChartDocument.hpp>
48
49 #include <comphelper/fileformat.h>
50 #include <comphelper/processfactory.hxx>
51 #include <comphelper/storagehelper.hxx>
52 #include <comphelper/mimeconfighelper.hxx>
53 #include <comphelper/namedvaluecollection.hxx>
54
55 #include <tools/diagnose_ex.h>
56 #include "persistence.hxx"
57
58 using namespace ::com::sun::star;
59
60
61 uno::Sequence< beans::PropertyValue > GetValuableArgs_Impl( const uno::Sequence< beans::PropertyValue >& aMedDescr,
62 bool bCanUseDocumentBaseURL )
63 {
64 uno::Sequence< beans::PropertyValue > aResult;
65 sal_Int32 nResLen = 0;
66
67 for ( sal_Int32 nInd = 0; nInd < aMedDescr.getLength(); nInd++ )
68 {
69 if ( aMedDescr[nInd].Name == "ComponentData" || aMedDescr[nInd].Name == "DocumentTitle"
70 || aMedDescr[nInd].Name == "InteractionHandler" || aMedDescr[nInd].Name == "JumpMark"
71 // || aMedDescr[nInd].Name == "Password" // makes no sense for embedded objects
72 || aMedDescr[nInd].Name == "Preview" || aMedDescr[nInd].Name == "ReadOnly"
73 || aMedDescr[nInd].Name == "StartPresentation" || aMedDescr[nInd].Name == "RepairPackage"
74 || aMedDescr[nInd].Name == "StatusIndicator" || aMedDescr[nInd].Name == "ViewData"
75 || aMedDescr[nInd].Name == "ViewId" || aMedDescr[nInd].Name == "MacroExecutionMode"
76 || aMedDescr[nInd].Name == "UpdateDocMode"
77 || (aMedDescr[nInd].Name == "DocumentBaseURL" && bCanUseDocumentBaseURL) )
78 {
79 aResult.realloc( ++nResLen );
80 aResult[nResLen-1] = aMedDescr[nInd];
81 }
82 }
83
84 return aResult;
85 }
86
87
88 uno::Sequence< beans::PropertyValue > addAsTemplate( const uno::Sequence< beans::PropertyValue >& aOrig )
89 {
90 bool bAsTemplateSet = false;
91 sal_Int32 nLength = aOrig.getLength();
92 uno::Sequence< beans::PropertyValue > aResult( nLength );
93
94 for ( sal_Int32 nInd = 0; nInd < nLength; nInd++ )
95 {
96 aResult[nInd].Name = aOrig[nInd].Name;
97 if ( aResult[nInd].Name == "AsTemplate" )
98 {
99 aResult[nInd].Value <<= true;
100 bAsTemplateSet = true;
101 }
102 else
103 aResult[nInd].Value = aOrig[nInd].Value;
104 }
105
106 if ( !bAsTemplateSet )
107 {
108 aResult.realloc( nLength + 1 );
109 aResult[nLength].Name = "AsTemplate";
110 aResult[nLength].Value <<= true;
111 }
112
113 return aResult;
114 }
115
116
117 uno::Reference< io::XInputStream > createTempInpStreamFromStor(
118 const uno::Reference< embed::XStorage >& xStorage,
119 const uno::Reference< uno::XComponentContext >& xContext )
120 {
121 SAL_WARN_IF( !xStorage.is(), "embeddedobj.common", "The storage can not be empty!" );
122
123 uno::Reference< io::XInputStream > xResult;
124
125 uno::Reference < io::XStream > xTempStream( io::TempFile::create(xContext), uno::UNO_QUERY_THROW );
126
127 uno::Reference < lang::XSingleServiceFactory > xStorageFactory( embed::StorageFactory::create(xContext) );
128
129 uno::Sequence< uno::Any > aArgs( 2 );
130 aArgs[0] <<= xTempStream;
131 aArgs[1] <<= embed::ElementModes::READWRITE;
132 uno::Reference< embed::XStorage > xTempStorage( xStorageFactory->createInstanceWithArguments( aArgs ),
133 uno::UNO_QUERY );
134 if ( !xTempStorage.is() )
135 throw uno::RuntimeException(); // TODO:
136
137 try
138 {
139 xStorage->copyToStorage( xTempStorage );
140 } catch( const uno::Exception& e )
141 {
142 throw embed::StorageWrappedTargetException(
143 "Can't copy storage!",
144 uno::Reference< uno::XInterface >(),
145 uno::makeAny( e ) );
146 }
147
148 try {
149 uno::Reference< lang::XComponent > xComponent( xTempStorage, uno::UNO_QUERY );
150 SAL_WARN_IF( !xComponent.is(), "embeddedobj.common", "Wrong storage implementation!" );
151 if ( xComponent.is() )
152 xComponent->dispose();
153 }
154 catch ( const uno::Exception& )
155 {
156 }
157
158 try {
159 uno::Reference< io::XOutputStream > xTempOut = xTempStream->getOutputStream();
160 if ( xTempOut.is() )
161 xTempOut->closeOutput();
162 }
163 catch ( const uno::Exception& )
164 {
165 }
166
167 xResult = xTempStream->getInputStream();
168
169 return xResult;
170
171 }
172
173
174 static void TransferMediaType( const uno::Reference< embed::XStorage >& i_rSource, const uno::Reference< embed::XStorage >& i_rTarget )
175 {
176 try
177 {
178 const uno::Reference< beans::XPropertySet > xSourceProps( i_rSource, uno::UNO_QUERY_THROW );
179 const uno::Reference< beans::XPropertySet > xTargetProps( i_rTarget, uno::UNO_QUERY_THROW );
180 const OUString sMediaTypePropName( "MediaType" );
181 xTargetProps->setPropertyValue( sMediaTypePropName, xSourceProps->getPropertyValue( sMediaTypePropName ) );
182 }
183 catch( const uno::Exception& )
184 {
185 DBG_UNHANDLED_EXCEPTION();
186 }
187 }
188
189
190 static uno::Reference< util::XCloseable > CreateDocument( const uno::Reference< uno::XComponentContext >& _rxContext,
191 const OUString& _rDocumentServiceName, bool _bEmbeddedScriptSupport, const bool i_bDocumentRecoverySupport )
192 {
193 ::comphelper::NamedValueCollection aArguments;
194 aArguments.put( "EmbeddedObject", true );
195 aArguments.put( "EmbeddedScriptSupport", _bEmbeddedScriptSupport );
196 aArguments.put( "DocumentRecoverySupport", i_bDocumentRecoverySupport );
197
198 uno::Reference< uno::XInterface > xDocument;
199 try
200 {
201 xDocument = _rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(
202 _rDocumentServiceName, aArguments.getWrappedPropertyValues(), _rxContext );
203 }
204 catch( const uno::Exception& )
205 {
206 // if an embedded object implementation does not support XInitialization,
207 // the default factory from cppuhelper will throw an
208 // IllegalArgumentException when we try to create the instance with arguments.
209 // Okay, so we fall back to creating the instance without any arguments.
210 OSL_FAIL("Consider implementing interface XInitialization to avoid duplicate construction");
211 xDocument = _rxContext->getServiceManager()->createInstanceWithContext( _rDocumentServiceName, _rxContext );
212 }
213
214 SAL_WARN_IF(!xDocument.is(), "embeddedobj.common", "Service " << _rDocumentServiceName << " is not available?");
215 return uno::Reference< util::XCloseable >( xDocument, uno::UNO_QUERY );
216 }
217
218
219 static void SetDocToEmbedded( const uno::Reference< frame::XModel >& rDocument, const OUString& aModuleName )
220 {
221 if (rDocument.is())
222 {
223 uno::Sequence< beans::PropertyValue > aSeq( 1 );
224 aSeq[0].Name = "SetEmbedded";
225 aSeq[0].Value <<= true;
226 rDocument->attachResource( OUString(), aSeq );
227
228 if ( !aModuleName.isEmpty() )
229 {
230 try
231 {
232 uno::Reference< frame::XModule > xModule( rDocument, uno::UNO_QUERY_THROW );
233 xModule->setIdentifier( aModuleName );
234 }
235 catch( const uno::Exception& )
236 {}
237 }
238 }
239 }
240
241
242 void OCommonEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,
243 const uno::Reference< embed::XStorage >& xNewObjectStorage,
244 const OUString& aNewName )
245 {
246 if ( xNewParentStorage == m_xParentStorage && aNewName.equals( m_aEntryName ) )
247 {
248 SAL_WARN_IF( xNewObjectStorage != m_xObjectStorage, "embeddedobj.common", "The storage must be the same!" );
249 return;
250 }
251
252 uno::Reference< lang::XComponent > xComponent( m_xObjectStorage, uno::UNO_QUERY );
253 OSL_ENSURE( !m_xObjectStorage.is() || xComponent.is(), "Wrong storage implementation!" );
254
255 m_xObjectStorage = xNewObjectStorage;
256 m_xParentStorage = xNewParentStorage;
257 m_aEntryName = aNewName;
258
259 // the linked document should not be switched
260 if ( !m_bIsLink )
261 {
262 uno::Reference< document::XStorageBasedDocument > xDoc( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
263 if ( xDoc.is() )
264 SwitchDocToStorage_Impl( xDoc, m_xObjectStorage );
265 }
266
267 try {
268 if ( xComponent.is() )
269 xComponent->dispose();
270 }
271 catch ( const uno::Exception& )
272 {
273 }
274 }
275
276
277 void OCommonEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,
278 const OUString& aNewName )
279 {
280 if ( xNewParentStorage == m_xParentStorage && aNewName.equals( m_aEntryName ) )
281 return;
282
283 sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE;
284
285 uno::Reference< embed::XStorage > xNewOwnStorage = xNewParentStorage->openStorageElement( aNewName, nStorageMode );
286 SAL_WARN_IF( !xNewOwnStorage.is(), "embeddedobj.common", "The method can not return empty reference!" );
287
288 SwitchOwnPersistence( xNewParentStorage, xNewOwnStorage, aNewName );
289 }
290
291
292 void OCommonEmbeddedObject::EmbedAndReparentDoc_Impl( const uno::Reference< util::XCloseable >& i_rxDocument ) const
293 {
294 SetDocToEmbedded( uno::Reference< frame::XModel >( i_rxDocument, uno::UNO_QUERY ), m_aModuleName );
295
296 try
297 {
298 uno::Reference < container::XChild > xChild( i_rxDocument, uno::UNO_QUERY );
299 if ( xChild.is() )
300 xChild->setParent( m_xParent );
301 }
302 catch( const lang::NoSupportException & )
303 {
304 SAL_WARN( "embeddedobj.common", "OCommonEmbeddedObject::EmbedAndReparentDoc: cannot set parent at document!" );
305 }
306 }
307
308
309 uno::Reference< util::XCloseable > OCommonEmbeddedObject::InitNewDocument_Impl()
310 {
311 uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),
312 m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );
313
314 uno::Reference< frame::XModel > xModel( xDocument, uno::UNO_QUERY );
315 uno::Reference< frame::XLoadable > xLoadable( xModel, uno::UNO_QUERY );
316 if ( !xLoadable.is() )
317 throw uno::RuntimeException();
318
319 try
320 {
321 // set the document mode to embedded as the first action on document!!!
322 EmbedAndReparentDoc_Impl( xDocument );
323
324 // if we have a storage to recover the document from, do not use initNew, but instead load from that storage
325 bool bInitNew = true;
326 if ( m_xRecoveryStorage.is() )
327 {
328 uno::Reference< document::XStorageBasedDocument > xDoc( xLoadable, uno::UNO_QUERY );
329 SAL_WARN_IF( !xDoc.is(), "embeddedobj.common", "OCommonEmbeddedObject::InitNewDocument_Impl: cannot recover from a storage when the document is not storage based!" );
330 if ( xDoc.is() )
331 {
332 ::comphelper::NamedValueCollection aLoadArgs;
333 FillDefaultLoadArgs_Impl( m_xRecoveryStorage, aLoadArgs );
334
335 xDoc->loadFromStorage( m_xRecoveryStorage, aLoadArgs.getPropertyValues() );
336 SwitchDocToStorage_Impl( xDoc, m_xObjectStorage );
337 bInitNew = false;
338 }
339 }
340
341 if ( bInitNew )
342 {
343 // init document as a new
344 xLoadable->initNew();
345 }
346 xModel->attachResource( xModel->getURL(), m_aDocMediaDescriptor );
347 }
348 catch( const uno::Exception& )
349 {
350 uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY );
351 if ( xCloseable.is() )
352 {
353 try
354 {
355 xCloseable->close( true );
356 }
357 catch( const uno::Exception& )
358 {
359 }
360 }
361
362 throw; // TODO
363 }
364
365 return xDocument;
366 }
367
368
369 uno::Reference< util::XCloseable > OCommonEmbeddedObject::LoadLink_Impl()
370 {
371 uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),
372 m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );
373
374 uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY );
375 if ( !xLoadable.is() )
376 throw uno::RuntimeException();
377
378 sal_Int32 nLen = 2;
379 uno::Sequence< beans::PropertyValue > aArgs( nLen );
380 aArgs[0].Name = "URL";
381 aArgs[0].Value <<= m_aLinkURL;
382 aArgs[1].Name = "FilterName";
383 aArgs[1].Value <<= m_aLinkFilterName;
384 if ( m_bLinkHasPassword )
385 {
386 aArgs.realloc( ++nLen );
387 aArgs[nLen-1].Name = "Password";
388 aArgs[nLen-1].Value <<= m_aLinkPassword;
389 }
390
391 aArgs.realloc( m_aDocMediaDescriptor.getLength() + nLen );
392 for ( sal_Int32 nInd = 0; nInd < m_aDocMediaDescriptor.getLength(); nInd++ )
393 {
394 aArgs[nInd+nLen].Name = m_aDocMediaDescriptor[nInd].Name;
395 aArgs[nInd+nLen].Value = m_aDocMediaDescriptor[nInd].Value;
396 }
397
398 try
399 {
400 // the document is not really an embedded one, it is a link
401 EmbedAndReparentDoc_Impl( xDocument );
402
403 // load the document
404 xLoadable->load( aArgs );
405
406 if ( !m_bLinkHasPassword )
407 {
408 // check if there is a password to cache
409 uno::Reference< frame::XModel > xModel( xLoadable, uno::UNO_QUERY_THROW );
410 uno::Sequence< beans::PropertyValue > aProps = xModel->getArgs();
411 for ( sal_Int32 nInd = 0; nInd < aProps.getLength(); nInd++ )
412 if ( aProps[nInd].Name == "Password" && ( aProps[nInd].Value >>= m_aLinkPassword ) )
413 {
414 m_bLinkHasPassword = true;
415 break;
416 }
417 }
418 }
419 catch( const uno::Exception& )
420 {
421 uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY );
422 if ( xCloseable.is() )
423 {
424 try
425 {
426 xCloseable->close( true );
427 }
428 catch( const uno::Exception& )
429 {
430 }
431 }
432
433 throw; // TODO
434 }
435
436 return xDocument;
437
438 }
439
440
441 OUString OCommonEmbeddedObject::GetFilterName( sal_Int32 nVersion ) const
442 {
443 OUString aFilterName = GetPresetFilterName();
444 if ( aFilterName.isEmpty() )
445 {
446 try {
447 ::comphelper::MimeConfigurationHelper aHelper( m_xContext );
448 aFilterName = aHelper.GetDefaultFilterFromServiceName( GetDocumentServiceName(), nVersion );
449
450 // If no filter is found, fall back to the FileFormatVersion=6200 filter, Base only has that.
451 if (aFilterName.isEmpty() && nVersion == SOFFICE_FILEFORMAT_CURRENT)
452 aFilterName = aHelper.GetDefaultFilterFromServiceName(GetDocumentServiceName(), SOFFICE_FILEFORMAT_60);
453 } catch( const uno::Exception& )
454 {}
455 }
456
457 return aFilterName;
458 }
459
460
461 void OCommonEmbeddedObject::FillDefaultLoadArgs_Impl( const uno::Reference< embed::XStorage >& i_rxStorage,
462 ::comphelper::NamedValueCollection& o_rLoadArgs ) const
463 {
464 o_rLoadArgs.put( "DocumentBaseURL", GetBaseURL_Impl() );
465 o_rLoadArgs.put( "HierarchicalDocumentName", m_aEntryName );
466 o_rLoadArgs.put( "ReadOnly", m_bReadOnly );
467
468 OUString aFilterName = GetFilterName( ::comphelper::OStorageHelper::GetXStorageFormat( i_rxStorage ) );
469 SAL_WARN_IF( aFilterName.isEmpty(), "embeddedobj.common", "OCommonEmbeddedObject::FillDefaultLoadArgs_Impl: Wrong document service name!" );
470 if ( aFilterName.isEmpty() )
471 throw io::IOException(); // TODO: error message/code
472
473 o_rLoadArgs.put( "FilterName", aFilterName );
474 }
475
476
477 uno::Reference< util::XCloseable > OCommonEmbeddedObject::LoadDocumentFromStorage_Impl()
478 {
479 ENSURE_OR_THROW( m_xObjectStorage.is(), "no object storage" );
480
481 const uno::Reference< embed::XStorage > xSourceStorage( m_xRecoveryStorage.is() ? m_xRecoveryStorage : m_xObjectStorage );
482
483 uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),
484 m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );
485
486 //#i103460# ODF: take the size given from the parent frame as default
487 uno::Reference< chart2::XChartDocument > xChart( xDocument, uno::UNO_QUERY );
488 if( xChart.is() )
489 {
490 uno::Reference< embed::XVisualObject > xChartVisualObject( xChart, uno::UNO_QUERY );
491 if( xChartVisualObject.is() )
492 xChartVisualObject->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, m_aDefaultSizeForChart_In_100TH_MM );
493 }
494
495 uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY );
496 uno::Reference< document::XStorageBasedDocument > xDoc( xDocument, uno::UNO_QUERY );
497 if ( !xDoc.is() && !xLoadable.is() ) ///BUG: This should be || instead of && ?
498 throw uno::RuntimeException();
499
500 ::comphelper::NamedValueCollection aLoadArgs;
501 FillDefaultLoadArgs_Impl( xSourceStorage, aLoadArgs );
502
503 uno::Reference< io::XInputStream > xTempInpStream;
504 if ( !xDoc.is() )
505 {
506 xTempInpStream = createTempInpStreamFromStor( xSourceStorage, m_xContext );
507 if ( !xTempInpStream.is() )
508 throw uno::RuntimeException();
509
510 OUString aTempFileURL;
511 try
512 {
513 // no need to let the file stay after the stream is removed since the embedded document
514 // can not be stored directly
515 uno::Reference< beans::XPropertySet > xTempStreamProps( xTempInpStream, uno::UNO_QUERY_THROW );
516 xTempStreamProps->getPropertyValue("Uri") >>= aTempFileURL;
517 }
518 catch( const uno::Exception& )
519 {
520 }
521
522 SAL_WARN_IF( aTempFileURL.isEmpty(), "embeddedobj.common", "Couldn't retrieve temporary file URL!" );
523
524 aLoadArgs.put( "URL", aTempFileURL );
525 aLoadArgs.put( "InputStream", xTempInpStream );
526 }
527
528
529 aLoadArgs.merge( m_aDocMediaDescriptor, true );
530
531 try
532 {
533 // set the document mode to embedded as the first step!!!
534 EmbedAndReparentDoc_Impl( xDocument );
535
536 if ( xDoc.is() )
537 {
538 xDoc->loadFromStorage( xSourceStorage, aLoadArgs.getPropertyValues() );
539 if ( xSourceStorage != m_xObjectStorage )
540 SwitchDocToStorage_Impl( xDoc, m_xObjectStorage );
541 }
542 else
543 xLoadable->load( aLoadArgs.getPropertyValues() );
544 }
545 catch( const uno::Exception& )
546 {
547 uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY );
548 if ( xCloseable.is() )
549 {
550 try
551 {
552 xCloseable->close( true );
553 }
554 catch( const uno::Exception& )
555 {
556 DBG_UNHANDLED_EXCEPTION();
557 }
558 }
559
560 throw; // TODO
561 }
562
563 return xDocument;
564 }
565
566
567 uno::Reference< io::XInputStream > OCommonEmbeddedObject::StoreDocumentToTempStream_Impl(
568 sal_Int32 nStorageFormat,
569 const OUString& aBaseURL,
570 const OUString& aHierarchName )
571 {
572 uno::Reference < io::XOutputStream > xTempOut(
573 io::TempFile::create(m_xContext),
574 uno::UNO_QUERY_THROW );
575 uno::Reference< io::XInputStream > aResult( xTempOut, uno::UNO_QUERY );
576
577 if ( !aResult.is() )
578 throw uno::RuntimeException(); // TODO:
579
580 uno::Reference< frame::XStorable > xStorable;
581 {
582 osl::MutexGuard aGuard( m_aMutex );
583 if ( m_pDocHolder )
584 xStorable.set( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
585 }
586
587 if( !xStorable.is() )
588 throw uno::RuntimeException(); // TODO:
589
590 OUString aFilterName = GetFilterName( nStorageFormat );
591
592 SAL_WARN_IF( aFilterName.isEmpty(), "embeddedobj.common", "Wrong document service name!" );
593 if ( aFilterName.isEmpty() )
594 throw io::IOException(); // TODO:
595
596 uno::Sequence< beans::PropertyValue > aArgs( 4 );
597 aArgs[0].Name = "FilterName";
598 aArgs[0].Value <<= aFilterName;
599 aArgs[1].Name = "OutputStream";
600 aArgs[1].Value <<= xTempOut;
601 aArgs[2].Name = "DocumentBaseURL";
602 aArgs[2].Value <<= aBaseURL;
603 aArgs[3].Name = "HierarchicalDocumentName";
604 aArgs[3].Value <<= aHierarchName;
605
606 xStorable->storeToURL( "private:stream", aArgs );
607 try
608 {
609 xTempOut->closeOutput();
610 }
611 catch( const uno::Exception& )
612 {
613 SAL_WARN( "embeddedobj.common", "Looks like stream was closed already" );
614 }
615
616 return aResult;
617 }
618
619
620 void OCommonEmbeddedObject::SaveObject_Impl()
621 {
622 if ( m_xClientSite.is() )
623 {
624 try
625 {
626 // check whether the component is modified,
627 // if not there is no need for storing
628 uno::Reference< util::XModifiable > xModifiable( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
629 if ( xModifiable.is() && !xModifiable->isModified() )
630 return;
631 }
632 catch( const uno::Exception& )
633 {}
634
635 try {
636 m_xClientSite->saveObject();
637 }
638 catch( const uno::Exception& )
639 {
640 SAL_WARN( "embeddedobj.common", "The object was not stored!" );
641 }
642 }
643 }
644
645
646 OUString OCommonEmbeddedObject::GetBaseURL_Impl() const
647 {
648 OUString aBaseURL;
649 sal_Int32 nInd = 0;
650
651 if ( m_xClientSite.is() )
652 {
653 try
654 {
655 uno::Reference< frame::XModel > xParentModel( m_xClientSite->getComponent(), uno::UNO_QUERY_THROW );
656 uno::Sequence< beans::PropertyValue > aModelProps = xParentModel->getArgs();
657 for ( nInd = 0; nInd < aModelProps.getLength(); nInd++ )
658 if ( aModelProps[nInd].Name == "DocumentBaseURL" )
659 {
660 aModelProps[nInd].Value >>= aBaseURL;
661 break;
662 }
663
664
665 }
666 catch( const uno::Exception& )
667 {}
668 }
669
670 if ( aBaseURL.isEmpty() )
671 {
672 for ( nInd = 0; nInd < m_aDocMediaDescriptor.getLength(); nInd++ )
673 if ( m_aDocMediaDescriptor[nInd].Name == "DocumentBaseURL" )
674 {
675 m_aDocMediaDescriptor[nInd].Value >>= aBaseURL;
676 break;
677 }
678 }
679
680 if ( aBaseURL.isEmpty() )
681 aBaseURL = m_aDefaultParentBaseURL;
682
683 return aBaseURL;
684 }
685
686
687 OUString OCommonEmbeddedObject::GetBaseURLFrom_Impl(
688 const uno::Sequence< beans::PropertyValue >& lArguments,
689 const uno::Sequence< beans::PropertyValue >& lObjArgs )
690 {
691 OUString aBaseURL;
692 sal_Int32 nInd = 0;
693
694 for ( nInd = 0; nInd < lArguments.getLength(); nInd++ )
695 if ( lArguments[nInd].Name == "DocumentBaseURL" )
696 {
697 lArguments[nInd].Value >>= aBaseURL;
698 break;
699 }
700
701 if ( aBaseURL.isEmpty() )
702 {
703 for ( nInd = 0; nInd < lObjArgs.getLength(); nInd++ )
704 if ( lObjArgs[nInd].Name == "DefaultParentBaseURL" )
705 {
706 lObjArgs[nInd].Value >>= aBaseURL;
707 break;
708 }
709 }
710
711 return aBaseURL;
712 }
713
714
715 void OCommonEmbeddedObject::SwitchDocToStorage_Impl( const uno::Reference< document::XStorageBasedDocument >& xDoc, const uno::Reference< embed::XStorage >& xStorage )
716 {
717 xDoc->switchToStorage( xStorage );
718
719 uno::Reference< util::XModifiable > xModif( xDoc, uno::UNO_QUERY );
720 if ( xModif.is() )
721 xModif->setModified( false );
722
723 if ( m_xRecoveryStorage.is() )
724 m_xRecoveryStorage.clear();
725 }
726
727 namespace {
728
729 OUString getStringPropertyValue( const uno::Sequence<beans::PropertyValue>& rProps, const OUString& rName )
730 {
731 OUString aStr;
732
733 for (sal_Int32 i = 0; i < rProps.getLength(); ++i)
734 {
735 if (rProps[i].Name == rName)
736 {
737 rProps[i].Value >>= aStr;
738 break;
739 }
740 }
741
742 return aStr;
743 }
744
745 }
746
747 void OCommonEmbeddedObject::StoreDocToStorage_Impl(
748 const uno::Reference<embed::XStorage>& xStorage,
749 const uno::Sequence<beans::PropertyValue>& rMediaArgs,
750 const uno::Sequence<beans::PropertyValue>& rObjArgs,
751 sal_Int32 nStorageFormat,
752 const OUString& aHierarchName,
753 bool bAttachToTheStorage )
754 {
755 SAL_WARN_IF( !xStorage.is(), "embeddedobj.common", "No storage is provided for storing!" );
756
757 if ( !xStorage.is() )
758 throw uno::RuntimeException(); // TODO:
759
760 uno::Reference< document::XStorageBasedDocument > xDoc;
761 {
762 osl::MutexGuard aGuard( m_aMutex );
763 if ( m_pDocHolder )
764 xDoc.set( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
765 }
766
767 OUString aBaseURL = GetBaseURLFrom_Impl(rMediaArgs, rObjArgs);
768
769 if ( xDoc.is() )
770 {
771 OUString aFilterName = GetFilterName( nStorageFormat );
772
773 // No filter found? Try the older format, e.g. Base has only that.
774 if (aFilterName.isEmpty() && nStorageFormat == SOFFICE_FILEFORMAT_CURRENT)
775 aFilterName = GetFilterName( SOFFICE_FILEFORMAT_60 );
776
777 SAL_WARN_IF( aFilterName.isEmpty(), "embeddedobj.common", "Wrong document service name!" );
778 if ( aFilterName.isEmpty() )
779 throw io::IOException(); // TODO:
780
781 uno::Sequence<beans::PropertyValue> aArgs(5);
782 aArgs[0].Name = "FilterName";
783 aArgs[0].Value <<= aFilterName;
784 aArgs[1].Name = "HierarchicalDocumentName";
785 aArgs[1].Value <<= aHierarchName;
786 aArgs[2].Name = "DocumentBaseURL";
787 aArgs[2].Value <<= aBaseURL;
788 aArgs[3].Name = "SourceShellID";
789 aArgs[3].Value <<= getStringPropertyValue(rObjArgs, "SourceShellID");
790 aArgs[4].Name = "DestinationShellID";
791 aArgs[4].Value <<= getStringPropertyValue(rObjArgs, "DestinationShellID");
792
793 xDoc->storeToStorage( xStorage, aArgs );
794 if ( bAttachToTheStorage )
795 SwitchDocToStorage_Impl( xDoc, xStorage );
796 }
797 else
798 {
799 // store document to temporary stream based on temporary file
800 uno::Reference < io::XInputStream > xTempIn = StoreDocumentToTempStream_Impl( nStorageFormat, aBaseURL, aHierarchName );
801
802 SAL_WARN_IF( !xTempIn.is(), "embeddedobj.common", "The stream reference can not be empty!" );
803
804 // open storage based on document temporary file for reading
805 uno::Reference < lang::XSingleServiceFactory > xStorageFactory = embed::StorageFactory::create(m_xContext);
806
807 uno::Sequence< uno::Any > aArgs(1);
808 aArgs[0] <<= xTempIn;
809 uno::Reference< embed::XStorage > xTempStorage( xStorageFactory->createInstanceWithArguments( aArgs ),
810 uno::UNO_QUERY );
811 if ( !xTempStorage.is() )
812 throw uno::RuntimeException(); // TODO:
813
814 // object storage must be committed automatically
815 xTempStorage->copyToStorage( xStorage );
816 }
817 }
818
819
820 uno::Reference< util::XCloseable > OCommonEmbeddedObject::CreateDocFromMediaDescr_Impl(
821 const uno::Sequence< beans::PropertyValue >& aMedDescr )
822 {
823 uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xContext, GetDocumentServiceName(),
824 m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) );
825
826 uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY );
827 if ( !xLoadable.is() )
828 throw uno::RuntimeException();
829
830 try
831 {
832 // set the document mode to embedded as the first action on the document!!!
833 EmbedAndReparentDoc_Impl( xDocument );
834
835 xLoadable->load( addAsTemplate( aMedDescr ) );
836 }
837 catch( const uno::Exception& )
838 {
839 uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY );
840 if ( xCloseable.is() )
841 {
842 try
843 {
844 xCloseable->close( true );
845 }
846 catch( const uno::Exception& )
847 {
848 }
849 }
850
851 throw; // TODO
852 }
853
854 return xDocument;
855 }
856
857
858 uno::Reference< util::XCloseable > OCommonEmbeddedObject::CreateTempDocFromLink_Impl()
859 {
860 uno::Reference< util::XCloseable > xResult;
861
862 SAL_WARN_IF( !m_bIsLink, "embeddedobj.common", "The object is not a linked one!" );
863
864 uno::Sequence< beans::PropertyValue > aTempMediaDescr;
865
866 sal_Int32 nStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
867 try {
868 nStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage );
869 }
870 catch ( const beans::IllegalTypeException& )
871 {
872 // the container just has an unknown type, use current file format
873 }
874 catch ( const uno::Exception& )
875 {
876 SAL_WARN( "embeddedobj.common", "Can not retrieve storage media type!" );
877 }
878
879 if ( m_pDocHolder->GetComponent().is() )
880 {
881 aTempMediaDescr.realloc( 4 );
882
883 // TODO/LATER: may be private:stream should be used as target URL
884 OUString aTempFileURL;
885 uno::Reference< io::XInputStream > xTempStream = StoreDocumentToTempStream_Impl( SOFFICE_FILEFORMAT_CURRENT,
886 OUString(),
887 OUString() );
888 try
889 {
890 // no need to let the file stay after the stream is removed since the embedded document
891 // can not be stored directly
892 uno::Reference< beans::XPropertySet > xTempStreamProps( xTempStream, uno::UNO_QUERY_THROW );
893 xTempStreamProps->getPropertyValue("Uri") >>= aTempFileURL;
894 }
895 catch( const uno::Exception& )
896 {
897 }
898
899 SAL_WARN_IF( aTempFileURL.isEmpty(), "embeddedobj.common", "Couldn't retrieve temporary file URL!" );
900
901 aTempMediaDescr[0].Name = "URL";
902 aTempMediaDescr[0].Value <<= aTempFileURL;
903 aTempMediaDescr[1].Name = "InputStream";
904 aTempMediaDescr[1].Value <<= xTempStream;
905 aTempMediaDescr[2].Name = "FilterName";
906 aTempMediaDescr[2].Value <<= GetFilterName( nStorageFormat );
907 aTempMediaDescr[3].Name = "AsTemplate";
908 aTempMediaDescr[3].Value <<= true;
909 }
910 else
911 {
912 aTempMediaDescr.realloc( 2 );
913 aTempMediaDescr[0].Name = "URL";
914 aTempMediaDescr[0].Value <<= m_aLinkURL;
915 aTempMediaDescr[1].Name = "FilterName";
916 aTempMediaDescr[1].Value <<= m_aLinkFilterName;
917 }
918
919 xResult = CreateDocFromMediaDescr_Impl( aTempMediaDescr );
920
921 return xResult;
922 }
923
924
925 void SAL_CALL OCommonEmbeddedObject::setPersistentEntry(
926 const uno::Reference< embed::XStorage >& xStorage,
927 const OUString& sEntName,
928 sal_Int32 nEntryConnectionMode,
929 const uno::Sequence< beans::PropertyValue >& lArguments,
930 const uno::Sequence< beans::PropertyValue >& lObjArgs )
931 throw ( lang::IllegalArgumentException,
932 embed::WrongStateException,
933 io::IOException,
934 uno::Exception,
935 uno::RuntimeException, std::exception )
936 {
937 // the type of the object must be already set
938 // a kind of typedetection should be done in the factory
939
940 ::osl::MutexGuard aGuard( m_aMutex );
941 if ( m_bDisposed )
942 throw lang::DisposedException(); // TODO
943
944 if ( !xStorage.is() )
945 throw lang::IllegalArgumentException( "No parent storage is provided!",
946 static_cast< ::cppu::OWeakObject* >(this),
947 1 );
948
949 if ( sEntName.isEmpty() )
950 throw lang::IllegalArgumentException( "Empty element name is provided!",
951 static_cast< ::cppu::OWeakObject* >(this),
952 2 );
953
954 // May be LOADED should be forbidden here ???
955 if ( ( m_nObjectState != -1 || nEntryConnectionMode == embed::EntryInitModes::NO_INIT )
956 && ( m_nObjectState == -1 || nEntryConnectionMode != embed::EntryInitModes::NO_INIT ) )
957 {
958 // if the object is not loaded
959 // it can not get persistent representation without initialization
960
961 // if the object is loaded
962 // it can switch persistent representation only without initialization
963
964 throw embed::WrongStateException(
965 "Can't change persistent representation of activated object!",
966 static_cast< ::cppu::OWeakObject* >(this) );
967 }
968
969 if ( m_bWaitSaveCompleted )
970 {
971 if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT )
972 {
973 // saveCompleted is expected, handle it accordingly
974 if ( m_xNewParentStorage == xStorage && m_aNewEntryName.equals( sEntName ) )
975 {
976 saveCompleted( true );
977 return;
978 }
979
980 // if a completely different entry is provided, switch first back to the old persistence in saveCompleted
981 // and then switch to the target persistence
982 bool bSwitchFurther = ( m_xParentStorage != xStorage || !m_aEntryName.equals( sEntName ) );
983 saveCompleted( false );
984 if ( !bSwitchFurther )
985 return;
986 }
987 else
988 throw embed::WrongStateException(
989 "The object waits for saveCompleted() call!",
990 static_cast< ::cppu::OWeakObject* >(this) );
991 }
992
993 // for now support of this interface is required to allow breaking of links and converting them to normal embedded
994 // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used )
995 // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" );
996 if ( m_bIsLink )
997 {
998 m_aEntryName = sEntName;
999 return;
1000 }
1001
1002 uno::Reference< container::XNameAccess > xNameAccess( xStorage, uno::UNO_QUERY );
1003 if ( !xNameAccess.is() )
1004 throw uno::RuntimeException(); //TODO
1005
1006 // detect entry existence
1007 bool bElExists = xNameAccess->hasByName( sEntName );
1008
1009 m_aDocMediaDescriptor = GetValuableArgs_Impl( lArguments,
1010 nEntryConnectionMode != embed::EntryInitModes::MEDIA_DESCRIPTOR_INIT );
1011
1012 m_bReadOnly = false;
1013 for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ )
1014 if ( lArguments[nInd].Name == "ReadOnly" )
1015 lArguments[nInd].Value >>= m_bReadOnly;
1016
1017 // TODO: use lObjArgs for StoreVisualReplacement
1018 for ( sal_Int32 nObjInd = 0; nObjInd < lObjArgs.getLength(); nObjInd++ )
1019 if ( lObjArgs[nObjInd].Name == "OutplaceDispatchInterceptor" )
1020 {
1021 uno::Reference< frame::XDispatchProviderInterceptor > xDispatchInterceptor;
1022 if ( lObjArgs[nObjInd].Value >>= xDispatchInterceptor )
1023 m_pDocHolder->SetOutplaceDispatchInterceptor( xDispatchInterceptor );
1024 }
1025 else if ( lObjArgs[nObjInd].Name == "DefaultParentBaseURL" )
1026 {
1027 lObjArgs[nObjInd].Value >>= m_aDefaultParentBaseURL;
1028 }
1029 else if ( lObjArgs[nObjInd].Name == "Parent" )
1030 {
1031 lObjArgs[nObjInd].Value >>= m_xParent;
1032 }
1033 else if ( lObjArgs[nObjInd].Name == "IndividualMiscStatus" )
1034 {
1035 sal_Int64 nMiscStatus=0;
1036 lObjArgs[nObjInd].Value >>= nMiscStatus;
1037 m_nMiscStatus |= nMiscStatus;
1038 }
1039 else if ( lObjArgs[nObjInd].Name == "CloneFrom" )
1040 {
1041 uno::Reference < embed::XEmbeddedObject > xObj;
1042 lObjArgs[nObjInd].Value >>= xObj;
1043 if ( xObj.is() )
1044 {
1045 m_bHasClonedSize = true;
1046 m_aClonedSize = xObj->getVisualAreaSize( embed::Aspects::MSOLE_CONTENT );
1047 m_nClonedMapUnit = xObj->getMapUnit( embed::Aspects::MSOLE_CONTENT );
1048 }
1049 }
1050 else if ( lObjArgs[nObjInd].Name == "OutplaceFrameProperties" )
1051 {
1052 uno::Sequence< uno::Any > aOutFrameProps;
1053 uno::Sequence< beans::NamedValue > aOutFramePropsTyped;
1054 if ( lObjArgs[nObjInd].Value >>= aOutFrameProps )
1055 {
1056 m_pDocHolder->SetOutplaceFrameProperties( aOutFrameProps );
1057 }
1058 else if ( lObjArgs[nObjInd].Value >>= aOutFramePropsTyped )
1059 {
1060 aOutFrameProps.realloc( aOutFramePropsTyped.getLength() );
1061 uno::Any* pProp = aOutFrameProps.getArray();
1062 for ( const beans::NamedValue* pTypedProp = aOutFramePropsTyped.getConstArray();
1063 pTypedProp != aOutFramePropsTyped.getConstArray() + aOutFramePropsTyped.getLength();
1064 ++pTypedProp, ++pProp
1065 )
1066 {
1067 *pProp <<= *pTypedProp;
1068 }
1069 m_pDocHolder->SetOutplaceFrameProperties( aOutFrameProps );
1070 }
1071 else
1072 SAL_WARN( "embeddedobj.common", "OCommonEmbeddedObject::setPersistentEntry: illegal type for argument 'OutplaceFrameProperties'!" );
1073 }
1074 else if ( lObjArgs[nObjInd].Name == "ModuleName" )
1075 {
1076 lObjArgs[nObjInd].Value >>= m_aModuleName;
1077 }
1078 else if ( lObjArgs[nObjInd].Name == "EmbeddedScriptSupport" )
1079 {
1080 OSL_VERIFY( lObjArgs[nObjInd].Value >>= m_bEmbeddedScriptSupport );
1081 }
1082 else if ( lObjArgs[nObjInd].Name == "DocumentRecoverySupport" )
1083 {
1084 OSL_VERIFY( lObjArgs[nObjInd].Value >>= m_bDocumentRecoverySupport );
1085 }
1086 else if ( lObjArgs[nObjInd].Name == "RecoveryStorage" )
1087 {
1088 OSL_VERIFY( lObjArgs[nObjInd].Value >>= m_xRecoveryStorage );
1089 }
1090
1091
1092 sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE;
1093
1094 SwitchOwnPersistence( xStorage, sEntName );
1095
1096 if ( nEntryConnectionMode == embed::EntryInitModes::DEFAULT_INIT )
1097 {
1098 if ( bElExists )
1099 {
1100 // the initialization from existing storage allows to leave object in loaded state
1101 m_nObjectState = embed::EmbedStates::LOADED;
1102 }
1103 else
1104 {
1105 m_pDocHolder->SetComponent( InitNewDocument_Impl(), m_bReadOnly );
1106 if ( !m_pDocHolder->GetComponent().is() )
1107 throw io::IOException(); // TODO: can not create document
1108
1109 m_nObjectState = embed::EmbedStates::RUNNING;
1110 }
1111 }
1112 else
1113 {
1114 if ( ( nStorageMode & embed::ElementModes::READWRITE ) != embed::ElementModes::READWRITE )
1115 throw io::IOException();
1116
1117 if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT )
1118 {
1119 // the document just already changed its storage to store to
1120 // the links to OOo documents for now ignore this call
1121 // TODO: OOo links will have persistence so it will be switched here
1122 }
1123 else if ( nEntryConnectionMode == embed::EntryInitModes::TRUNCATE_INIT )
1124 {
1125 if ( m_xRecoveryStorage.is() )
1126 TransferMediaType( m_xRecoveryStorage, m_xObjectStorage );
1127
1128 // TODO:
1129 m_pDocHolder->SetComponent( InitNewDocument_Impl(), m_bReadOnly );
1130
1131 if ( !m_pDocHolder->GetComponent().is() )
1132 throw io::IOException(); // TODO: can not create document
1133
1134 m_nObjectState = embed::EmbedStates::RUNNING;
1135 }
1136 else if ( nEntryConnectionMode == embed::EntryInitModes::MEDIA_DESCRIPTOR_INIT )
1137 {
1138 m_pDocHolder->SetComponent( CreateDocFromMediaDescr_Impl( lArguments ), m_bReadOnly );
1139 m_nObjectState = embed::EmbedStates::RUNNING;
1140 }
1141 //else if ( nEntryConnectionMode == embed::EntryInitModes::TRANSFERABLE_INIT )
1142 //{
1143 //TODO:
1144 //}
1145 else
1146 throw lang::IllegalArgumentException( "Wrong connection mode is provided!",
1147 static_cast< ::cppu::OWeakObject* >(this),
1148 3 );
1149 }
1150 }
1151
1152
1153 void SAL_CALL OCommonEmbeddedObject::storeToEntry( const uno::Reference< embed::XStorage >& xStorage,
1154 const OUString& sEntName,
1155 const uno::Sequence< beans::PropertyValue >& lArguments,
1156 const uno::Sequence< beans::PropertyValue >& lObjArgs )
1157 throw ( lang::IllegalArgumentException,
1158 embed::WrongStateException,
1159 io::IOException,
1160 uno::Exception,
1161 uno::RuntimeException, std::exception )
1162 {
1163 ::osl::ResettableMutexGuard aGuard( m_aMutex );
1164 if ( m_bDisposed )
1165 throw lang::DisposedException(); // TODO
1166
1167 if ( m_nObjectState == -1 )
1168 {
1169 // the object is still not loaded
1170 throw embed::WrongStateException( "Can't store object without persistence!",
1171 static_cast< ::cppu::OWeakObject* >(this) );
1172 }
1173
1174 if ( m_bWaitSaveCompleted )
1175 throw embed::WrongStateException(
1176 "The object waits for saveCompleted() call!",
1177 static_cast< ::cppu::OWeakObject* >(this) );
1178
1179 // for now support of this interface is required to allow breaking of links and converting them to normal embedded
1180 // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used )
1181 // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" );
1182 if ( m_bIsLink )
1183 return;
1184
1185 OSL_ENSURE( m_xParentStorage.is() && m_xObjectStorage.is(), "The object has no valid persistence!\n" );
1186
1187 sal_Int32 nTargetStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1188 sal_Int32 nOriginalStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1189 try {
1190 nTargetStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( xStorage );
1191 }
1192 catch ( const beans::IllegalTypeException& )
1193 {
1194 // the container just has an unknown type, use current file format
1195 }
1196 catch ( const uno::Exception& )
1197 {
1198 SAL_WARN( "embeddedobj.common", "Can not retrieve target storage media type!" );
1199 }
1200 if (nTargetStorageFormat == SOFFICE_FILEFORMAT_60)
1201 {
1202 SAL_INFO("embeddedobj.common", "fdo#78159: Storing OOoXML as ODF");
1203 nTargetStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1204 // setting MediaType is done later anyway, no need to do it here
1205 }
1206
1207 try
1208 {
1209 nOriginalStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage );
1210 }
1211 catch ( const beans::IllegalTypeException& )
1212 {
1213 // the container just has an unknown type, use current file format
1214 }
1215 catch ( const uno::Exception& )
1216 {
1217 SAL_WARN( "embeddedobj.common", "Can not retrieve own storage media type!" );
1218 }
1219
1220 bool bTryOptimization = false;
1221 for ( sal_Int32 nInd = 0; nInd < lObjArgs.getLength(); nInd++ )
1222 {
1223 // StoreVisualReplacement and VisualReplacement args have no sense here
1224 if ( lObjArgs[nInd].Name == "CanTryOptimization" )
1225 lObjArgs[nInd].Value >>= bTryOptimization;
1226 }
1227
1228 bool bSwitchBackToLoaded = false;
1229
1230 // Storing to different format can be done only in running state.
1231 if ( m_nObjectState == embed::EmbedStates::LOADED )
1232 {
1233 // TODO/LATER: copying is not legal for documents with relative links.
1234 if ( nTargetStorageFormat == nOriginalStorageFormat )
1235 {
1236 bool bOptimizationWorks = false;
1237 if ( bTryOptimization )
1238 {
1239 try
1240 {
1241 // try to use optimized copying
1242 uno::Reference< embed::XOptimizedStorage > xSource( m_xParentStorage, uno::UNO_QUERY_THROW );
1243 uno::Reference< embed::XOptimizedStorage > xTarget( xStorage, uno::UNO_QUERY_THROW );
1244 xSource->copyElementDirectlyTo( m_aEntryName, xTarget, sEntName );
1245 bOptimizationWorks = true;
1246 }
1247 catch( const uno::Exception& )
1248 {
1249 }
1250 }
1251
1252 if ( !bOptimizationWorks )
1253 m_xParentStorage->copyElementTo( m_aEntryName, xStorage, sEntName );
1254 }
1255 else
1256 {
1257 changeState( embed::EmbedStates::RUNNING );
1258 bSwitchBackToLoaded = true;
1259 }
1260 }
1261
1262 if ( m_nObjectState != embed::EmbedStates::LOADED )
1263 {
1264 uno::Reference< embed::XStorage > xSubStorage =
1265 xStorage->openStorageElement( sEntName, embed::ElementModes::READWRITE );
1266
1267 if ( !xSubStorage.is() )
1268 throw uno::RuntimeException(); //TODO
1269
1270 aGuard.clear();
1271 // TODO/LATER: support hierarchical name for embedded objects in embedded objects
1272 StoreDocToStorage_Impl(
1273 xSubStorage, lArguments, lObjArgs, nTargetStorageFormat, sEntName, false );
1274 aGuard.reset();
1275
1276 if ( bSwitchBackToLoaded )
1277 changeState( embed::EmbedStates::LOADED );
1278 }
1279
1280 // TODO: should the listener notification be done?
1281 }
1282
1283
1284 void SAL_CALL OCommonEmbeddedObject::storeAsEntry( const uno::Reference< embed::XStorage >& xStorage,
1285 const OUString& sEntName,
1286 const uno::Sequence< beans::PropertyValue >& lArguments,
1287 const uno::Sequence< beans::PropertyValue >& lObjArgs )
1288 throw ( lang::IllegalArgumentException,
1289 embed::WrongStateException,
1290 io::IOException,
1291 uno::Exception,
1292 uno::RuntimeException, std::exception )
1293 {
1294 // TODO: use lObjArgs
1295
1296 ::osl::ResettableMutexGuard aGuard( m_aMutex );
1297 if ( m_bDisposed )
1298 throw lang::DisposedException(); // TODO
1299
1300 if ( m_nObjectState == -1 )
1301 {
1302 // the object is still not loaded
1303 throw embed::WrongStateException( "Can't store object without persistence!",
1304 static_cast< ::cppu::OWeakObject* >(this) );
1305 }
1306
1307 if ( m_bWaitSaveCompleted )
1308 throw embed::WrongStateException(
1309 "The object waits for saveCompleted() call!",
1310 static_cast< ::cppu::OWeakObject* >(this) );
1311
1312 // for now support of this interface is required to allow breaking of links and converting them to normal embedded
1313 // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used )
1314 // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" );
1315 if ( m_bIsLink )
1316 {
1317 m_aNewEntryName = sEntName;
1318 return;
1319 }
1320
1321 OSL_ENSURE( m_xParentStorage.is() && m_xObjectStorage.is(), "The object has no valid persistence!\n" );
1322
1323 sal_Int32 nTargetStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1324 sal_Int32 nOriginalStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1325 try {
1326 nTargetStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( xStorage );
1327 }
1328 catch ( const beans::IllegalTypeException& )
1329 {
1330 // the container just has an unknown type, use current file format
1331 }
1332 catch ( const uno::Exception& )
1333 {
1334 SAL_WARN( "embeddedobj.common", "Can not retrieve target storage media type!" );
1335 }
1336 if (nTargetStorageFormat == SOFFICE_FILEFORMAT_60)
1337 {
1338 SAL_INFO("embeddedobj.common", "fdo#78159: Storing OOoXML as ODF");
1339 nTargetStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1340 // setting MediaType is done later anyway, no need to do it here
1341 }
1342
1343 try
1344 {
1345 nOriginalStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage );
1346 }
1347 catch ( const beans::IllegalTypeException& )
1348 {
1349 // the container just has an unknown type, use current file format
1350 }
1351 catch ( const uno::Exception& )
1352 {
1353 SAL_WARN( "embeddedobj.common", "Can not retrieve own storage media type!" );
1354 }
1355
1356 PostEvent_Impl( "OnSaveAs" );
1357
1358 bool bTryOptimization = false;
1359 for ( sal_Int32 nInd = 0; nInd < lObjArgs.getLength(); nInd++ )
1360 {
1361 // StoreVisualReplacement and VisualReplacement args have no sense here
1362 if ( lObjArgs[nInd].Name == "CanTryOptimization" )
1363 lObjArgs[nInd].Value >>= bTryOptimization;
1364 }
1365
1366 bool bSwitchBackToLoaded = false;
1367
1368 // Storing to different format can be done only in running state.
1369 if ( m_nObjectState == embed::EmbedStates::LOADED )
1370 {
1371 // TODO/LATER: copying is not legal for documents with relative links.
1372 if ( nTargetStorageFormat == nOriginalStorageFormat )
1373 {
1374 bool bOptimizationWorks = false;
1375 if ( bTryOptimization )
1376 {
1377 try
1378 {
1379 // try to use optimized copying
1380 uno::Reference< embed::XOptimizedStorage > xSource( m_xParentStorage, uno::UNO_QUERY_THROW );
1381 uno::Reference< embed::XOptimizedStorage > xTarget( xStorage, uno::UNO_QUERY_THROW );
1382 xSource->copyElementDirectlyTo( m_aEntryName, xTarget, sEntName );
1383 bOptimizationWorks = true;
1384 }
1385 catch( const uno::Exception& )
1386 {
1387 }
1388 }
1389
1390 if ( !bOptimizationWorks )
1391 m_xParentStorage->copyElementTo( m_aEntryName, xStorage, sEntName );
1392 }
1393 else
1394 {
1395 changeState( embed::EmbedStates::RUNNING );
1396 bSwitchBackToLoaded = true;
1397 }
1398 }
1399
1400 uno::Reference< embed::XStorage > xSubStorage =
1401 xStorage->openStorageElement( sEntName, embed::ElementModes::READWRITE );
1402
1403 if ( !xSubStorage.is() )
1404 throw uno::RuntimeException(); //TODO
1405
1406 if ( m_nObjectState != embed::EmbedStates::LOADED )
1407 {
1408 aGuard.clear();
1409 // TODO/LATER: support hierarchical name for embedded objects in embedded objects
1410 StoreDocToStorage_Impl(
1411 xSubStorage, lArguments, lObjArgs, nTargetStorageFormat, sEntName, false );
1412 aGuard.reset();
1413
1414 if ( bSwitchBackToLoaded )
1415 changeState( embed::EmbedStates::LOADED );
1416 }
1417
1418 m_bWaitSaveCompleted = true;
1419 m_xNewObjectStorage = xSubStorage;
1420 m_xNewParentStorage = xStorage;
1421 m_aNewEntryName = sEntName;
1422 m_aNewDocMediaDescriptor = GetValuableArgs_Impl( lArguments, true );
1423
1424 // TODO: register listeners for storages above, in case thay are disposed
1425 // an exception will be thrown on saveCompleted( true )
1426
1427 // TODO: should the listener notification be done here or in saveCompleted?
1428 }
1429
1430
1431 void SAL_CALL OCommonEmbeddedObject::saveCompleted( sal_Bool bUseNew )
1432 throw ( embed::WrongStateException,
1433 uno::Exception,
1434 uno::RuntimeException, std::exception )
1435 {
1436 ::osl::MutexGuard aGuard( m_aMutex );
1437 if ( m_bDisposed )
1438 throw lang::DisposedException(); // TODO
1439
1440 if ( m_nObjectState == -1 )
1441 {
1442 // the object is still not loaded
1443 throw embed::WrongStateException( "Can't store object without persistence!",
1444 static_cast< ::cppu::OWeakObject* >(this) );
1445 }
1446
1447 // for now support of this interface is required to allow breaking of links and converting them to normal embedded
1448 // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used )
1449 // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" );
1450 if ( m_bIsLink )
1451 {
1452 if ( bUseNew )
1453 m_aEntryName = m_aNewEntryName;
1454 m_aNewEntryName.clear();
1455 return;
1456 }
1457
1458 // it is allowed to call saveCompleted( false ) for nonstored objects
1459 if ( !m_bWaitSaveCompleted && !bUseNew )
1460 return;
1461
1462 SAL_WARN_IF( !m_bWaitSaveCompleted, "embeddedobj.common", "Unexpected saveCompleted() call!" );
1463 if ( !m_bWaitSaveCompleted )
1464 throw io::IOException(); // TODO: illegal call
1465
1466 OSL_ENSURE( m_xNewObjectStorage.is() && m_xNewParentStorage.is() , "Internal object information is broken!\n" );
1467 if ( !m_xNewObjectStorage.is() || !m_xNewParentStorage.is() )
1468 throw uno::RuntimeException(); // TODO: broken internal information
1469
1470 if ( bUseNew )
1471 {
1472 SwitchOwnPersistence( m_xNewParentStorage, m_xNewObjectStorage, m_aNewEntryName );
1473 m_aDocMediaDescriptor = m_aNewDocMediaDescriptor;
1474
1475 uno::Reference< util::XModifiable > xModif( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
1476 if ( xModif.is() )
1477 xModif->setModified( false );
1478
1479 PostEvent_Impl( "OnSaveAsDone");
1480 }
1481 else
1482 {
1483 try {
1484 uno::Reference< lang::XComponent > xComponent( m_xNewObjectStorage, uno::UNO_QUERY );
1485 SAL_WARN_IF( !xComponent.is(), "embeddedobj.common", "Wrong storage implementation!" );
1486 if ( xComponent.is() )
1487 xComponent->dispose();
1488 }
1489 catch ( const uno::Exception& )
1490 {
1491 }
1492 }
1493
1494 m_xNewObjectStorage.clear();
1495 m_xNewParentStorage.clear();
1496 m_aNewEntryName.clear();
1497 m_aNewDocMediaDescriptor.realloc( 0 );
1498 m_bWaitSaveCompleted = false;
1499
1500 if ( bUseNew )
1501 {
1502 // TODO: notify listeners
1503
1504 if ( m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE )
1505 {
1506 // TODO: update visual representation
1507 }
1508 }
1509 }
1510
1511
1512 sal_Bool SAL_CALL OCommonEmbeddedObject::hasEntry()
1513 throw ( embed::WrongStateException,
1514 uno::RuntimeException, std::exception )
1515 {
1516 ::osl::MutexGuard aGuard( m_aMutex );
1517 if ( m_bDisposed )
1518 throw lang::DisposedException(); // TODO
1519
1520 if ( m_bWaitSaveCompleted )
1521 throw embed::WrongStateException(
1522 "The object waits for saveCompleted() call!",
1523 static_cast< ::cppu::OWeakObject* >(this) );
1524
1525 if ( m_xObjectStorage.is() )
1526 return true;
1527
1528 return false;
1529 }
1530
1531
1532 OUString SAL_CALL OCommonEmbeddedObject::getEntryName()
1533 throw ( embed::WrongStateException,
1534 uno::RuntimeException, std::exception )
1535 {
1536 ::osl::MutexGuard aGuard( m_aMutex );
1537 if ( m_bDisposed )
1538 throw lang::DisposedException(); // TODO
1539
1540 if ( m_nObjectState == -1 )
1541 {
1542 // the object is still not loaded
1543 throw embed::WrongStateException( "The object persistence is not initialized!",
1544 static_cast< ::cppu::OWeakObject* >(this) );
1545 }
1546
1547 if ( m_bWaitSaveCompleted )
1548 throw embed::WrongStateException(
1549 "The object waits for saveCompleted() call!",
1550 static_cast< ::cppu::OWeakObject* >(this) );
1551
1552 return m_aEntryName;
1553 }
1554
1555
1556 void SAL_CALL OCommonEmbeddedObject::storeOwn()
1557 throw ( embed::WrongStateException,
1558 io::IOException,
1559 uno::Exception,
1560 uno::RuntimeException, std::exception )
1561 {
1562 // during switching from Activated to Running and from Running to Loaded states the object will
1563 // ask container to store the object, the container has to make decision
1564 // to do so or not
1565
1566 ::osl::ResettableMutexGuard aGuard( m_aMutex );
1567 if ( m_bDisposed )
1568 throw lang::DisposedException(); // TODO
1569
1570 if ( m_nObjectState == -1 )
1571 {
1572 // the object is still not loaded
1573 throw embed::WrongStateException( "Can't store object without persistence!",
1574 static_cast< ::cppu::OWeakObject* >(this) );
1575 }
1576
1577 if ( m_bWaitSaveCompleted )
1578 throw embed::WrongStateException(
1579 "The object waits for saveCompleted() call!",
1580 static_cast< ::cppu::OWeakObject* >(this) );
1581
1582 if ( m_bReadOnly )
1583 throw io::IOException(); // TODO: access denied
1584
1585 // nothing to do, if the object is in loaded state
1586 if ( m_nObjectState == embed::EmbedStates::LOADED )
1587 return;
1588
1589 PostEvent_Impl( "OnSave" );
1590
1591 SAL_WARN_IF( !m_pDocHolder->GetComponent().is(), "embeddedobj.common", "If an object is activated or in running state it must have a document!" );
1592 if ( !m_pDocHolder->GetComponent().is() )
1593 throw uno::RuntimeException();
1594
1595 if ( m_bIsLink )
1596 {
1597 // TODO: just store the document to its location
1598 uno::Reference< frame::XStorable > xStorable( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
1599 if ( !xStorable.is() )
1600 throw uno::RuntimeException(); // TODO
1601
1602 // free the main mutex for the storing time
1603 aGuard.clear();
1604
1605 xStorable->store();
1606
1607 aGuard.reset();
1608 }
1609 else
1610 {
1611 OSL_ENSURE( m_xParentStorage.is() && m_xObjectStorage.is(), "The object has no valid persistence!\n" );
1612
1613 if ( !m_xObjectStorage.is() )
1614 throw io::IOException(); //TODO: access denied
1615
1616 sal_Int32 nStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1617 try {
1618 nStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage );
1619 }
1620 catch ( const beans::IllegalTypeException& )
1621 {
1622 // the container just has an unknown type, use current file format
1623 }
1624 catch ( const uno::Exception& )
1625 {
1626 SAL_WARN( "embeddedobj.common", "Can not retrieve storage media type!" );
1627 }
1628 if (nStorageFormat == SOFFICE_FILEFORMAT_60)
1629 {
1630 SAL_INFO("embeddedobj.common", "fdo#78159: Storing OOoXML as ODF");
1631 nStorageFormat = SOFFICE_FILEFORMAT_CURRENT;
1632 // setting MediaType is done later anyway, no need to do it here
1633 }
1634
1635 aGuard.clear();
1636 uno::Sequence<beans::PropertyValue> aEmpty;
1637 uno::Sequence<beans::PropertyValue> aMediaArgs(1);
1638 aMediaArgs[0].Name = "DocumentBaseURL";
1639 aMediaArgs[0].Value <<= GetBaseURL_Impl();
1640 StoreDocToStorage_Impl( m_xObjectStorage, aMediaArgs, aEmpty, nStorageFormat, m_aEntryName, true );
1641 aGuard.reset();
1642 }
1643
1644 uno::Reference< util::XModifiable > xModif( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
1645 if ( xModif.is() )
1646 xModif->setModified( false );
1647
1648 PostEvent_Impl( "OnSaveDone" );
1649 }
1650
1651
1652 sal_Bool SAL_CALL OCommonEmbeddedObject::isReadonly()
1653 throw ( embed::WrongStateException,
1654 uno::RuntimeException, std::exception )
1655 {
1656 ::osl::MutexGuard aGuard( m_aMutex );
1657 if ( m_bDisposed )
1658 throw lang::DisposedException(); // TODO
1659
1660 if ( m_nObjectState == -1 )
1661 {
1662 // the object is still not loaded
1663 throw embed::WrongStateException( "The object persistence is not initialized!",
1664 static_cast< ::cppu::OWeakObject* >(this) );
1665 }
1666
1667 if ( m_bWaitSaveCompleted )
1668 throw embed::WrongStateException(
1669 "The object waits for saveCompleted() call!",
1670 static_cast< ::cppu::OWeakObject* >(this) );
1671
1672 return m_bReadOnly;
1673 }
1674
1675
1676 void SAL_CALL OCommonEmbeddedObject::reload(
1677 const uno::Sequence< beans::PropertyValue >& lArguments,
1678 const uno::Sequence< beans::PropertyValue >& lObjArgs )
1679 throw ( lang::IllegalArgumentException,
1680 embed::WrongStateException,
1681 io::IOException,
1682 uno::Exception,
1683 uno::RuntimeException, std::exception )
1684 {
1685 // TODO: use lObjArgs
1686 // for now this method is used only to switch readonly state
1687
1688 ::osl::MutexGuard aGuard( m_aMutex );
1689 if ( m_bDisposed )
1690 throw lang::DisposedException(); // TODO
1691
1692 if ( m_nObjectState == -1 )
1693 {
1694 // the object is still not loaded
1695 throw embed::WrongStateException( "The object persistence is not initialized!",
1696 static_cast< ::cppu::OWeakObject* >(this) );
1697 }
1698
1699 if ( m_nObjectState != embed::EmbedStates::LOADED )
1700 {
1701 // the object is still not loaded
1702 throw embed::WrongStateException(
1703 "The object must be in loaded state to be reloaded!",
1704 static_cast< ::cppu::OWeakObject* >(this) );
1705 }
1706
1707 if ( m_bWaitSaveCompleted )
1708 throw embed::WrongStateException(
1709 "The object waits for saveCompleted() call!",
1710 static_cast< ::cppu::OWeakObject* >(this) );
1711
1712 if ( m_bIsLink )
1713 {
1714 // reload of the link
1715 OUString aOldLinkFilter = m_aLinkFilterName;
1716
1717 OUString aNewLinkFilter;
1718 for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ )
1719 {
1720 if ( lArguments[nInd].Name == "URL" )
1721 {
1722 // the new URL
1723 lArguments[nInd].Value >>= m_aLinkURL;
1724 m_aLinkFilterName.clear();
1725 }
1726 else if ( lArguments[nInd].Name == "FilterName" )
1727 {
1728 lArguments[nInd].Value >>= aNewLinkFilter;
1729 m_aLinkFilterName.clear();
1730 }
1731 }
1732
1733 ::comphelper::MimeConfigurationHelper aHelper( m_xContext );
1734 if ( m_aLinkFilterName.isEmpty() )
1735 {
1736 if ( !aNewLinkFilter.isEmpty() )
1737 m_aLinkFilterName = aNewLinkFilter;
1738 else
1739 {
1740 uno::Sequence< beans::PropertyValue > aArgs( 1 );
1741 aArgs[0].Name = "URL";
1742 aArgs[0].Value <<= m_aLinkURL;
1743 m_aLinkFilterName = aHelper.UpdateMediaDescriptorWithFilterName( aArgs, false );
1744 }
1745 }
1746
1747 if ( !aOldLinkFilter.equals( m_aLinkFilterName ) )
1748 {
1749 uno::Sequence< beans::NamedValue > aObject = aHelper.GetObjectPropsByFilter( m_aLinkFilterName );
1750
1751 // TODO/LATER: probably the document holder could be cleaned explicitly as in the destructor
1752 m_pDocHolder->release();
1753 m_pDocHolder = nullptr;
1754
1755 LinkInit_Impl( aObject, lArguments, lObjArgs );
1756 }
1757 }
1758
1759 m_aDocMediaDescriptor = GetValuableArgs_Impl( lArguments, true );
1760
1761 // TODO: use lObjArgs for StoreVisualReplacement
1762 for ( sal_Int32 nObjInd = 0; nObjInd < lObjArgs.getLength(); nObjInd++ )
1763 if ( lObjArgs[nObjInd].Name == "OutplaceDispatchInterceptor" )
1764 {
1765 uno::Reference< frame::XDispatchProviderInterceptor > xDispatchInterceptor;
1766 if ( lObjArgs[nObjInd].Value >>= xDispatchInterceptor )
1767 m_pDocHolder->SetOutplaceDispatchInterceptor( xDispatchInterceptor );
1768
1769 break;
1770 }
1771
1772 // TODO:
1773 // when document allows reloading through API the object can be reloaded not only in loaded state
1774
1775 bool bOldReadOnlyValue = m_bReadOnly;
1776
1777 m_bReadOnly = false;
1778 for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ )
1779 if ( lArguments[nInd].Name == "ReadOnly" )
1780 lArguments[nInd].Value >>= m_bReadOnly;
1781
1782 if ( bOldReadOnlyValue != m_bReadOnly && !m_bIsLink )
1783 {
1784 // close own storage
1785 try {
1786 uno::Reference< lang::XComponent > xComponent( m_xObjectStorage, uno::UNO_QUERY );
1787 OSL_ENSURE( !m_xObjectStorage.is() || xComponent.is(), "Wrong storage implementation!" );
1788 if ( xComponent.is() )
1789 xComponent->dispose();
1790 }
1791 catch ( const uno::Exception& )
1792 {
1793 }
1794
1795 sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE;
1796 m_xObjectStorage = m_xParentStorage->openStorageElement( m_aEntryName, nStorageMode );
1797 }
1798 }
1799
1800 sal_Bool SAL_CALL OCommonEmbeddedObject::isStored() throw (css::uno::RuntimeException, std::exception)
1801 {
1802 uno::Reference<container::XNameAccess> xNA(m_xObjectStorage, uno::UNO_QUERY);
1803 if (!xNA.is())
1804 return false;
1805
1806 return xNA->getElementNames().getLength() > 0;
1807 }
1808
1809
1810 void SAL_CALL OCommonEmbeddedObject::breakLink( const uno::Reference< embed::XStorage >& xStorage,
1811 const OUString& sEntName )
1812 throw ( lang::IllegalArgumentException,
1813 embed::WrongStateException,
1814 io::IOException,
1815 uno::Exception,
1816 uno::RuntimeException, std::exception )
1817 {
1818 ::osl::ResettableMutexGuard aGuard( m_aMutex );
1819 if ( m_bDisposed )
1820 throw lang::DisposedException(); // TODO
1821
1822 if ( !m_bIsLink )
1823 {
1824 // it must be a linked initialized object
1825 throw embed::WrongStateException(
1826 "The object is not a valid linked object!",
1827 static_cast< ::cppu::OWeakObject* >(this) );
1828 }
1829 else
1830 {
1831 // the current implementation of OOo links does not implement this method since it does not implement
1832 // all the set of interfaces required for OOo embedded object ( XEmbedPersist is not supported ).
1833 }
1834
1835 if ( !xStorage.is() )
1836 throw lang::IllegalArgumentException( "No parent storage is provided!",
1837 static_cast< ::cppu::OWeakObject* >(this),
1838 1 );
1839
1840 if ( sEntName.isEmpty() )
1841 throw lang::IllegalArgumentException( "Empty element name is provided!",
1842 static_cast< ::cppu::OWeakObject* >(this),
1843 2 );
1844
1845 if ( !m_bIsLink || m_nObjectState == -1 )
1846 {
1847 // it must be a linked initialized object
1848 throw embed::WrongStateException(
1849 "The object is not a valid linked object!",
1850 static_cast< ::cppu::OWeakObject* >(this) );
1851 }
1852
1853 if ( m_bWaitSaveCompleted )
1854 throw embed::WrongStateException(
1855 "The object waits for saveCompleted() call!",
1856 static_cast< ::cppu::OWeakObject* >(this) );
1857
1858 uno::Reference< container::XNameAccess > xNameAccess( xStorage, uno::UNO_QUERY );
1859 if ( !xNameAccess.is() )
1860 throw uno::RuntimeException(); //TODO
1861
1862 m_bReadOnly = false;
1863
1864 if ( m_xParentStorage != xStorage || !m_aEntryName.equals( sEntName ) )
1865 SwitchOwnPersistence( xStorage, sEntName );
1866
1867 // for linked object it means that it becomes embedded object
1868 // the document must switch it's persistence also
1869
1870 // TODO/LATER: handle the case when temp doc can not be created
1871 // the document is a new embedded object so it must be marked as modified
1872 uno::Reference< util::XCloseable > xDocument = CreateTempDocFromLink_Impl();
1873 uno::Reference< util::XModifiable > xModif( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
1874 if ( !xModif.is() )
1875 throw uno::RuntimeException();
1876 try
1877 {
1878 xModif->setModified( true );
1879 }
1880 catch( const uno::Exception& )
1881 {}
1882
1883 m_pDocHolder->SetComponent( xDocument, m_bReadOnly );
1884 SAL_WARN_IF( !m_pDocHolder->GetComponent().is(), "embeddedobj.common", "If document can't be created, an exception must be thrown!" );
1885
1886 if ( m_nObjectState == embed::EmbedStates::LOADED )
1887 {
1888 // the state is changed and can not be switched to loaded state back without saving
1889 m_nObjectState = embed::EmbedStates::RUNNING;
1890 StateChangeNotification_Impl( false, embed::EmbedStates::LOADED, m_nObjectState, aGuard );
1891 }
1892 else if ( m_nObjectState == embed::EmbedStates::ACTIVE )
1893 m_pDocHolder->Show();
1894
1895 m_bIsLink = false;
1896 m_aLinkFilterName.clear();
1897 m_aLinkURL.clear();
1898 }
1899
1900
1901 sal_Bool SAL_CALL OCommonEmbeddedObject::isLink()
1902 throw ( embed::WrongStateException,
1903 uno::RuntimeException, std::exception )
1904 {
1905 ::osl::MutexGuard aGuard( m_aMutex );
1906 if ( m_bDisposed )
1907 throw lang::DisposedException(); // TODO
1908
1909 return m_bIsLink;
1910 }
1911
1912
1913 OUString SAL_CALL OCommonEmbeddedObject::getLinkURL()
1914 throw ( embed::WrongStateException,
1915 uno::Exception,
1916 uno::RuntimeException, std::exception )
1917 {
1918 ::osl::MutexGuard aGuard( m_aMutex );
1919 if ( m_bDisposed )
1920 throw lang::DisposedException(); // TODO
1921
1922 if ( !m_bIsLink )
1923 throw embed::WrongStateException(
1924 "The object is not a link object!",
1925 static_cast< ::cppu::OWeakObject* >(this) );
1926
1927 return m_aLinkURL;
1928 }
1929
1930 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE