1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_comphelper.hxx" 26 #include <com/sun/star/container/XChild.hpp> 27 #include <com/sun/star/container/XNameAccess.hpp> 28 #include <com/sun/star/embed/XEmbedObjectCreator.hpp> 29 #include <com/sun/star/embed/XLinkCreator.hpp> 30 #include <com/sun/star/embed/XEmbedPersist.hpp> 31 #include <com/sun/star/embed/XLinkageSupport.hpp> 32 #include <com/sun/star/embed/XTransactedObject.hpp> 33 #include <com/sun/star/embed/XOptimizedStorage.hpp> 34 #include <com/sun/star/embed/EntryInitModes.hpp> 35 #include <com/sun/star/util/XCloseable.hpp> 36 #include <com/sun/star/util/XModifiable.hpp> 37 #include <com/sun/star/embed/EmbedStates.hpp> 38 #include <com/sun/star/datatransfer/XTransferable.hpp> 39 #include <com/sun/star/beans/XPropertySetInfo.hpp> 40 #include <com/sun/star/beans/XPropertySet.hpp> 41 #include <com/sun/star/embed/Aspects.hpp> 42 #include <com/sun/star/embed/EmbedMisc.hpp> 43 44 #include <comphelper/seqstream.hxx> 45 #include <comphelper/processfactory.hxx> 46 #include <comphelper/storagehelper.hxx> 47 #include <comphelper/embeddedobjectcontainer.hxx> 48 #include <comphelper/sequence.hxx> 49 #include <cppuhelper/weakref.hxx> 50 #include <hash_map> 51 #include <algorithm> 52 53 #include <rtl/logfile.hxx> 54 55 using namespace ::com::sun::star; 56 57 namespace comphelper 58 { 59 60 struct hashObjectName_Impl 61 { 62 size_t operator()(const ::rtl::OUString Str) const 63 { 64 return (size_t)Str.hashCode(); 65 } 66 }; 67 68 struct eqObjectName_Impl 69 { 70 sal_Bool operator()(const ::rtl::OUString Str1, const ::rtl::OUString Str2) const 71 { 72 return ( Str1 == Str2 ); 73 } 74 }; 75 76 typedef std::hash_map 77 < 78 ::rtl::OUString, 79 ::com::sun::star::uno::Reference < com::sun::star::embed::XEmbeddedObject >, 80 hashObjectName_Impl, 81 eqObjectName_Impl 82 > 83 EmbeddedObjectContainerNameMap; 84 85 struct EmbedImpl 86 { 87 // TODO/LATER: remove objects from temp. Container storage when object is disposed 88 EmbeddedObjectContainerNameMap maObjectContainer; 89 uno::Reference < embed::XStorage > mxStorage; 90 EmbeddedObjectContainer* mpTempObjectContainer; 91 uno::Reference < embed::XStorage > mxImageStorage; 92 uno::WeakReference < uno::XInterface > m_xModel; 93 //EmbeddedObjectContainerNameMap maTempObjectContainer; 94 //uno::Reference < embed::XStorage > mxTempStorage; 95 96 /// bitfield 97 bool mbOwnsStorage : 1; 98 bool mbUserAllowsLinkUpdate : 1; 99 100 const uno::Reference < embed::XStorage >& GetReplacements(); 101 }; 102 103 const uno::Reference < embed::XStorage >& EmbedImpl::GetReplacements() 104 { 105 if ( !mxImageStorage.is() ) 106 { 107 try 108 { 109 mxImageStorage = mxStorage->openStorageElement( 110 ::rtl::OUString::createFromAscii( "ObjectReplacements" ), embed::ElementModes::READWRITE ); 111 } 112 catch ( uno::Exception& ) 113 { 114 mxImageStorage = mxStorage->openStorageElement( 115 ::rtl::OUString::createFromAscii( "ObjectReplacements" ), embed::ElementModes::READ ); 116 } 117 } 118 119 if ( !mxImageStorage.is() ) 120 throw io::IOException(); 121 122 return mxImageStorage; 123 } 124 125 EmbeddedObjectContainer::EmbeddedObjectContainer() 126 { 127 pImpl = new EmbedImpl; 128 pImpl->mxStorage = ::comphelper::OStorageHelper::GetTemporaryStorage(); 129 pImpl->mbOwnsStorage = true; 130 pImpl->mbUserAllowsLinkUpdate = true; 131 pImpl->mpTempObjectContainer = 0; 132 } 133 134 EmbeddedObjectContainer::EmbeddedObjectContainer( const uno::Reference < embed::XStorage >& rStor ) 135 { 136 pImpl = new EmbedImpl; 137 pImpl->mxStorage = rStor; 138 pImpl->mbOwnsStorage = false; 139 pImpl->mbUserAllowsLinkUpdate = true; 140 pImpl->mpTempObjectContainer = 0; 141 } 142 143 EmbeddedObjectContainer::EmbeddedObjectContainer( const uno::Reference < embed::XStorage >& rStor, const uno::Reference < uno::XInterface >& xModel ) 144 { 145 pImpl = new EmbedImpl; 146 pImpl->mxStorage = rStor; 147 pImpl->mbOwnsStorage = false; 148 pImpl->mbUserAllowsLinkUpdate = true; 149 pImpl->mpTempObjectContainer = 0; 150 pImpl->m_xModel = xModel; 151 } 152 153 void EmbeddedObjectContainer::SwitchPersistence( const uno::Reference < embed::XStorage >& rStor ) 154 { 155 ReleaseImageSubStorage(); 156 157 if ( pImpl->mbOwnsStorage ) 158 pImpl->mxStorage->dispose(); 159 160 pImpl->mxStorage = rStor; 161 pImpl->mbOwnsStorage = false; 162 } 163 164 sal_Bool EmbeddedObjectContainer::CommitImageSubStorage() 165 { 166 if ( pImpl->mxImageStorage.is() ) 167 { 168 try 169 { 170 sal_Bool bReadOnlyMode = sal_True; 171 uno::Reference < beans::XPropertySet > xSet(pImpl->mxImageStorage,uno::UNO_QUERY); 172 if ( xSet.is() ) 173 { 174 // get the open mode from the parent storage 175 sal_Int32 nMode = 0; 176 uno::Any aAny = xSet->getPropertyValue( ::rtl::OUString::createFromAscii("OpenMode") ); 177 if ( aAny >>= nMode ) 178 bReadOnlyMode = !(nMode & embed::ElementModes::WRITE ); 179 } // if ( xSet.is() ) 180 if ( !bReadOnlyMode ) 181 { 182 uno::Reference< embed::XTransactedObject > xTransact( pImpl->mxImageStorage, uno::UNO_QUERY_THROW ); 183 xTransact->commit(); 184 } 185 } 186 catch( uno::Exception& ) 187 { 188 return sal_False; 189 } 190 } 191 192 return sal_True; 193 } 194 195 void EmbeddedObjectContainer::ReleaseImageSubStorage() 196 { 197 CommitImageSubStorage(); 198 199 if ( pImpl->mxImageStorage.is() ) 200 { 201 try 202 { 203 pImpl->mxImageStorage->dispose(); 204 pImpl->mxImageStorage = uno::Reference< embed::XStorage >(); 205 } 206 catch( uno::Exception& ) 207 { 208 OSL_ASSERT( "Problems releasing image substorage!\n" ); 209 } 210 } 211 } 212 213 EmbeddedObjectContainer::~EmbeddedObjectContainer() 214 { 215 ReleaseImageSubStorage(); 216 217 if ( pImpl->mbOwnsStorage ) 218 pImpl->mxStorage->dispose(); 219 220 delete pImpl->mpTempObjectContainer; 221 delete pImpl; 222 } 223 224 void EmbeddedObjectContainer::CloseEmbeddedObjects() 225 { 226 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.begin(); 227 while ( aIt != pImpl->maObjectContainer.end() ) 228 { 229 uno::Reference < util::XCloseable > xClose( (*aIt).second, uno::UNO_QUERY ); 230 if ( xClose.is() ) 231 { 232 try 233 { 234 xClose->close( sal_True ); 235 } 236 catch ( uno::Exception& ) 237 { 238 } 239 } 240 241 aIt++; 242 } 243 } 244 245 ::rtl::OUString EmbeddedObjectContainer::CreateUniqueObjectName() 246 { 247 ::rtl::OUString aPersistName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Object ") ); 248 ::rtl::OUString aStr; 249 sal_Int32 i=1; 250 do 251 { 252 aStr = aPersistName; 253 aStr += ::rtl::OUString::valueOf( i++ ); 254 } 255 while( HasEmbeddedObject( aStr ) ); 256 // TODO/LATER: should we consider deleted objects? 257 258 return aStr; 259 } 260 261 uno::Sequence < ::rtl::OUString > EmbeddedObjectContainer::GetObjectNames() 262 { 263 uno::Sequence < ::rtl::OUString > aSeq( pImpl->maObjectContainer.size() ); 264 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.begin(); 265 sal_Int32 nIdx=0; 266 while ( aIt != pImpl->maObjectContainer.end() ) 267 aSeq[nIdx++] = (*aIt++).first; 268 return aSeq; 269 } 270 271 sal_Bool EmbeddedObjectContainer::HasEmbeddedObjects() 272 { 273 return pImpl->maObjectContainer.size() != 0; 274 } 275 276 sal_Bool EmbeddedObjectContainer::HasEmbeddedObject( const ::rtl::OUString& rName ) 277 { 278 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.find( rName ); 279 if ( aIt == pImpl->maObjectContainer.end() ) 280 { 281 uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY ); 282 return xAccess->hasByName(rName); 283 } 284 else 285 return sal_True; 286 } 287 288 sal_Bool EmbeddedObjectContainer::HasEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj ) 289 { 290 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.begin(); 291 while ( aIt != pImpl->maObjectContainer.end() ) 292 { 293 if ( (*aIt).second == xObj ) 294 return sal_True; 295 else 296 aIt++; 297 } 298 299 return sal_False; 300 } 301 302 sal_Bool EmbeddedObjectContainer::HasInstantiatedEmbeddedObject( const ::rtl::OUString& rName ) 303 { 304 // allows to detect whether the object was already instantiated 305 // currently the filter instantiate it on loading, so this method allows 306 // to avoid objects pointing to the same persistence 307 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.find( rName ); 308 return ( aIt != pImpl->maObjectContainer.end() ); 309 } 310 311 ::rtl::OUString EmbeddedObjectContainer::GetEmbeddedObjectName( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& xObj ) 312 { 313 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.begin(); 314 while ( aIt != pImpl->maObjectContainer.end() ) 315 { 316 if ( (*aIt).second == xObj ) 317 return (*aIt).first; 318 else 319 aIt++; 320 } 321 322 OSL_ENSURE( 0, "Unknown object!" ); 323 return ::rtl::OUString(); 324 } 325 326 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::GetEmbeddedObject( const ::rtl::OUString& rName ) 327 { 328 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::GetEmbeddedObject" ); 329 330 OSL_ENSURE( !rName.isEmpty(), "Empty object name!"); 331 332 uno::Reference < embed::XEmbeddedObject > xObj; 333 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.find( rName ); 334 335 #if OSL_DEBUG_LEVEL > 1 336 uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY ); 337 uno::Sequence< ::rtl::OUString> aSeq = xAccess->getElementNames(); 338 const ::rtl::OUString* pIter = aSeq.getConstArray(); 339 const ::rtl::OUString* pEnd = pIter + aSeq.getLength(); 340 for(;pIter != pEnd;++pIter) 341 { 342 (void)*pIter; 343 } 344 OSL_ENSURE( aIt != pImpl->maObjectContainer.end() || xAccess->hasByName(rName), "Could not return object!" ); 345 #endif 346 347 // check if object was already created 348 if ( aIt != pImpl->maObjectContainer.end() ) 349 xObj = (*aIt).second; 350 else 351 xObj = Get_Impl( rName, uno::Reference < embed::XEmbeddedObject >() ); 352 353 return xObj; 354 } 355 356 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::Get_Impl( const ::rtl::OUString& rName, const uno::Reference < embed::XEmbeddedObject >& xCopy ) 357 { 358 uno::Reference < embed::XEmbeddedObject > xObj; 359 try 360 { 361 // create the object from the storage 362 uno::Reference < beans::XPropertySet > xSet( pImpl->mxStorage, uno::UNO_QUERY ); 363 sal_Bool bReadOnlyMode = sal_True; 364 if ( xSet.is() ) 365 { 366 // get the open mode from the parent storage 367 sal_Int32 nMode = 0; 368 uno::Any aAny = xSet->getPropertyValue( ::rtl::OUString::createFromAscii("OpenMode") ); 369 if ( aAny >>= nMode ) 370 bReadOnlyMode = !(nMode & embed::ElementModes::WRITE ); 371 } 372 373 // object was not added until now - should happen only by calling this method from "inside" 374 //TODO/LATER: it would be good to detect an error when an object should be created already, but isn't (not an "inside" call) 375 uno::Reference < embed::XEmbedObjectCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance( 376 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator")) ), uno::UNO_QUERY ); 377 uno::Sequence< beans::PropertyValue > aObjDescr( xCopy.is() ? 2 : 1 ); 378 aObjDescr[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Parent" ) ); 379 aObjDescr[0].Value <<= pImpl->m_xModel.get(); 380 if ( xCopy.is() ) 381 { 382 aObjDescr[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CloneFrom" ) ); 383 aObjDescr[1].Value <<= xCopy; 384 } 385 386 uno::Sequence< beans::PropertyValue > aMediaDescr( 1 ); 387 aMediaDescr[0].Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReadOnly")); 388 aMediaDescr[0].Value <<= bReadOnlyMode; 389 xObj = uno::Reference < embed::XEmbeddedObject >( xFactory->createInstanceInitFromEntry( 390 pImpl->mxStorage, rName, 391 aMediaDescr, aObjDescr ), uno::UNO_QUERY ); 392 393 // insert object into my list 394 AddEmbeddedObject( xObj, rName ); 395 } 396 catch ( uno::Exception& ) 397 { 398 } 399 400 return xObj; 401 } 402 403 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::CreateEmbeddedObject( const uno::Sequence < sal_Int8 >& rClassId, 404 const uno::Sequence < beans::PropertyValue >& rArgs, ::rtl::OUString& rNewName ) 405 { 406 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::CreateEmbeddedObject" ); 407 408 if ( rNewName.isEmpty() ) 409 rNewName = CreateUniqueObjectName(); 410 411 OSL_ENSURE( !HasEmbeddedObject(rNewName), "Object to create already exists!"); 412 413 // create object from classid by inserting it into storage 414 uno::Reference < embed::XEmbeddedObject > xObj; 415 try 416 { 417 uno::Reference < embed::XEmbedObjectCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance( 418 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator")) ), uno::UNO_QUERY ); 419 420 uno::Sequence< beans::PropertyValue > aObjDescr( rArgs.getLength() + 1 ); 421 aObjDescr[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Parent" ) ); 422 aObjDescr[0].Value <<= pImpl->m_xModel.get(); 423 ::std::copy( rArgs.getConstArray(), rArgs.getConstArray() + rArgs.getLength(), aObjDescr.getArray() + 1 ); 424 xObj = uno::Reference < embed::XEmbeddedObject >( xFactory->createInstanceInitNew( 425 rClassId, ::rtl::OUString(), pImpl->mxStorage, rNewName, 426 aObjDescr ), uno::UNO_QUERY ); 427 428 AddEmbeddedObject( xObj, rNewName ); 429 430 OSL_ENSURE( !xObj.is() || xObj->getCurrentState() != embed::EmbedStates::LOADED, 431 "A freshly create object should be running always!\n" ); 432 } 433 catch ( uno::Exception& ) 434 { 435 } 436 437 return xObj; 438 } 439 440 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::CreateEmbeddedObject( const uno::Sequence < sal_Int8 >& rClassId, ::rtl::OUString& rNewName ) 441 { 442 return CreateEmbeddedObject( rClassId, uno::Sequence < beans::PropertyValue >(), rNewName ); 443 } 444 445 void EmbeddedObjectContainer::AddEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& xObj, const ::rtl::OUString& rName ) 446 { 447 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::AddEmbeddedObject" ); 448 449 #if OSL_DEBUG_LEVEL > 1 450 OSL_ENSURE( !rName.isEmpty(), "Added object doesn't have a name!"); 451 uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY ); 452 uno::Reference < embed::XEmbedPersist > xEmb( xObj, uno::UNO_QUERY ); 453 uno::Reference < embed::XLinkageSupport > xLink( xEmb, uno::UNO_QUERY ); 454 // if the object has a persistance and the object is not a link than it must have persistence entry in the storage 455 OSL_ENSURE( !( xEmb.is() && ( !xLink.is() || !xLink->isLink() ) ) || xAccess->hasByName(rName), 456 "Added element not in storage!" ); 457 #endif 458 459 // remember object - it needs to be in storage already 460 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.find( rName ); 461 OSL_ENSURE( aIt == pImpl->maObjectContainer.end(), "Element already inserted!" ); 462 pImpl->maObjectContainer[ rName ] = xObj; 463 uno::Reference < container::XChild > xChild( xObj, uno::UNO_QUERY ); 464 if ( xChild.is() && xChild->getParent() != pImpl->m_xModel.get() ) 465 xChild->setParent( pImpl->m_xModel.get() ); 466 467 // look for object in temorary container 468 if ( pImpl->mpTempObjectContainer ) 469 { 470 aIt = pImpl->mpTempObjectContainer->pImpl->maObjectContainer.begin(); 471 while ( aIt != pImpl->mpTempObjectContainer->pImpl->maObjectContainer.end() ) 472 { 473 if ( (*aIt).second == xObj ) 474 { 475 // copy replacement image from temporary container (if there is any) 476 ::rtl::OUString aTempName = (*aIt).first; 477 ::rtl::OUString aMediaType; 478 uno::Reference < io::XInputStream > xStream = pImpl->mpTempObjectContainer->GetGraphicStream( xObj, &aMediaType ); 479 if ( xStream.is() ) 480 { 481 InsertGraphicStream( xStream, rName, aMediaType ); 482 xStream = 0; 483 pImpl->mpTempObjectContainer->RemoveGraphicStream( aTempName ); 484 } 485 486 // remove object from storage of temporary container 487 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 488 if ( xPersist.is() ) 489 { 490 try 491 { 492 pImpl->mpTempObjectContainer->pImpl->mxStorage->removeElement( aTempName ); 493 } 494 catch ( uno::Exception& ) 495 { 496 } 497 } 498 499 // temp. container needs to forget the object 500 pImpl->mpTempObjectContainer->pImpl->maObjectContainer.erase( aIt ); 501 break; 502 } 503 else 504 aIt++; 505 } 506 } 507 } 508 509 sal_Bool EmbeddedObjectContainer::StoreEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj, ::rtl::OUString& rName, sal_Bool bCopy ) 510 { 511 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::StoreEmbeddedObject" ); 512 513 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 514 if ( rName.isEmpty() ) 515 rName = CreateUniqueObjectName(); 516 517 #if OSL_DEBUG_LEVEL > 1 518 uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY ); 519 OSL_ENSURE( !xPersist.is() || !xAccess->hasByName(rName), "Inserting element already present in storage!" ); 520 OSL_ENSURE( xPersist.is() || xObj->getCurrentState() == embed::EmbedStates::RUNNING, "Non persistent object inserted!"); 521 #endif 522 523 // insert objects' storage into the container storage (if object has one) 524 try 525 { 526 if ( xPersist.is() ) 527 { 528 uno::Sequence < beans::PropertyValue > aSeq; 529 if ( bCopy ) 530 xPersist->storeToEntry( pImpl->mxStorage, rName, aSeq, aSeq ); 531 else 532 { 533 //TODO/LATER: possible optimisation, don't store immediately 534 //xPersist->setPersistentEntry( pImpl->mxStorage, rName, embed::EntryInitModes::ENTRY_NO_INIT, aSeq, aSeq ); 535 xPersist->storeAsEntry( pImpl->mxStorage, rName, aSeq, aSeq ); 536 xPersist->saveCompleted( sal_True ); 537 } 538 } 539 } 540 catch ( uno::Exception& ) 541 { 542 // TODO/LATER: better error recovery should keep storage intact 543 return sal_False; 544 } 545 546 return sal_True; 547 } 548 549 sal_Bool EmbeddedObjectContainer::InsertEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj, ::rtl::OUString& rName ) 550 { 551 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::InsertEmbeddedObject( Object )" ); 552 // store it into the container storage 553 if ( StoreEmbeddedObject( xObj, rName, sal_False ) ) 554 { 555 // remember object 556 AddEmbeddedObject( xObj, rName ); 557 return sal_True; 558 } 559 else 560 return sal_False; 561 } 562 563 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::InsertEmbeddedObject( const uno::Reference < io::XInputStream >& xStm, ::rtl::OUString& rNewName ) 564 { 565 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::InsertEmbeddedObject( InputStream )" ); 566 567 if ( rNewName.isEmpty() ) 568 rNewName = CreateUniqueObjectName(); 569 570 // store it into the container storage 571 sal_Bool bIsStorage = sal_False; 572 try 573 { 574 // first try storage persistence 575 uno::Reference < embed::XStorage > xStore = ::comphelper::OStorageHelper::GetStorageFromInputStream( xStm ); 576 577 // storage was created from stream successfully 578 bIsStorage = sal_True; 579 580 uno::Reference < embed::XStorage > xNewStore = pImpl->mxStorage->openStorageElement( rNewName, embed::ElementModes::READWRITE ); 581 xStore->copyToStorage( xNewStore ); 582 } 583 catch ( uno::Exception& ) 584 { 585 if ( bIsStorage ) 586 // it is storage persistence, but opening of new substorage or copying to it failed 587 return uno::Reference < embed::XEmbeddedObject >(); 588 589 // stream didn't contain a storage, now try stream persistence 590 try 591 { 592 uno::Reference < io::XStream > xNewStream = pImpl->mxStorage->openStreamElement( rNewName, embed::ElementModes::READWRITE ); 593 ::comphelper::OStorageHelper::CopyInputToOutput( xStm, xNewStream->getOutputStream() ); 594 595 // No mediatype is provided so the default for OLE objects value is used 596 // it is correct so for now, but what if somebody introduces a new stream based embedded object? 597 // Probably introducing of such an object must be restricted ( a storage must be used! ). 598 uno::Reference< beans::XPropertySet > xProps( xNewStream, uno::UNO_QUERY_THROW ); 599 xProps->setPropertyValue( 600 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ), 601 uno::makeAny( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "application/vnd.sun.star.oleobject" ) ) ) ); 602 } 603 catch ( uno::Exception& ) 604 { 605 // complete disaster! 606 return uno::Reference < embed::XEmbeddedObject >(); 607 } 608 } 609 610 // stream was copied into the container storage in either way, now try to open something form it 611 uno::Reference < embed::XEmbeddedObject > xRet = GetEmbeddedObject( rNewName ); 612 try 613 { 614 if ( !xRet.is() ) 615 // no object could be created, so withdraw insertion 616 pImpl->mxStorage->removeElement( rNewName ); 617 } 618 catch ( uno::Exception& ) 619 { 620 } 621 622 return xRet; 623 } 624 625 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::InsertEmbeddedObject( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& aMedium, ::rtl::OUString& rNewName ) 626 { 627 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::InsertEmbeddedObject( MediaDescriptor )" ); 628 629 if ( rNewName.isEmpty() ) 630 rNewName = CreateUniqueObjectName(); 631 632 uno::Reference < embed::XEmbeddedObject > xObj; 633 try 634 { 635 uno::Reference < embed::XEmbedObjectCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance( 636 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator")) ), uno::UNO_QUERY ); 637 uno::Sequence< beans::PropertyValue > aObjDescr( 1 ); 638 aObjDescr[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Parent" ) ); 639 aObjDescr[0].Value <<= pImpl->m_xModel.get(); 640 xObj = uno::Reference < embed::XEmbeddedObject >( xFactory->createInstanceInitFromMediaDescriptor( 641 pImpl->mxStorage, rNewName, aMedium, aObjDescr ), uno::UNO_QUERY ); 642 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 643 644 OSL_ENSURE( !xObj.is() || xObj->getCurrentState() != embed::EmbedStates::LOADED, 645 "A freshly create object should be running always!\n" ); 646 647 // possible optimization: store later! 648 if ( xPersist.is()) 649 xPersist->storeOwn(); 650 651 AddEmbeddedObject( xObj, rNewName ); 652 } 653 catch ( uno::Exception& ) 654 { 655 } 656 657 return xObj; 658 } 659 660 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::InsertEmbeddedLink( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& aMedium, ::rtl::OUString& rNewName ) 661 { 662 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::InsertEmbeddedLink" ); 663 664 if ( rNewName.isEmpty() ) 665 rNewName = CreateUniqueObjectName(); 666 667 uno::Reference < embed::XEmbeddedObject > xObj; 668 try 669 { 670 uno::Reference < embed::XLinkCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance( 671 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator")) ), uno::UNO_QUERY ); 672 uno::Sequence< beans::PropertyValue > aObjDescr( 1 ); 673 aObjDescr[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Parent" ) ); 674 aObjDescr[0].Value <<= pImpl->m_xModel.get(); 675 xObj = uno::Reference < embed::XEmbeddedObject >( xFactory->createInstanceLink( 676 pImpl->mxStorage, rNewName, aMedium, aObjDescr ), uno::UNO_QUERY ); 677 678 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 679 680 OSL_ENSURE( !xObj.is() || xObj->getCurrentState() != embed::EmbedStates::LOADED, 681 "A freshly create object should be running always!\n" ); 682 683 // possible optimization: store later! 684 if ( xPersist.is()) 685 xPersist->storeOwn(); 686 687 AddEmbeddedObject( xObj, rNewName ); 688 } 689 catch ( uno::Exception& ) 690 { 691 } 692 693 return xObj; 694 } 695 696 sal_Bool EmbeddedObjectContainer::TryToCopyGraphReplacement( EmbeddedObjectContainer& rSrc, 697 const ::rtl::OUString& aOrigName, 698 const ::rtl::OUString& aTargetName ) 699 { 700 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::TryToCopyGraphReplacement" ); 701 702 sal_Bool bResult = sal_False; 703 704 if ( ( &rSrc != this || !aOrigName.equals( aTargetName ) ) && !aOrigName.isEmpty() && !aTargetName.isEmpty() ) 705 { 706 ::rtl::OUString aMediaType; 707 uno::Reference < io::XInputStream > xGrStream = rSrc.GetGraphicStream( aOrigName, &aMediaType ); 708 if ( xGrStream.is() ) 709 bResult = InsertGraphicStream( xGrStream, aTargetName, aMediaType ); 710 } 711 712 return bResult; 713 } 714 715 sal_Bool EmbeddedObjectContainer::CopyEmbeddedObject( EmbeddedObjectContainer& rSrc, const uno::Reference < embed::XEmbeddedObject >& xObj, ::rtl::OUString& rName ) 716 { 717 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::CopyEmbeddedObject" ); 718 719 OSL_ENSURE( sal_False, 720 "This method is depricated! Use EmbeddedObjectContainer::CopyAndGetEmbeddedObject() to copy object!\n" ); 721 722 // get the object name before(!) it is assigned to a new storage 723 ::rtl::OUString aOrigName; 724 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 725 if ( xPersist.is() ) 726 aOrigName = xPersist->getEntryName(); 727 728 if ( rName.isEmpty() ) 729 rName = CreateUniqueObjectName(); 730 731 if ( StoreEmbeddedObject( xObj, rName, sal_True ) ) 732 { 733 TryToCopyGraphReplacement( rSrc, aOrigName, rName ); 734 return sal_True; 735 } 736 737 return sal_False; 738 } 739 740 uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::CopyAndGetEmbeddedObject( EmbeddedObjectContainer& rSrc, const uno::Reference < embed::XEmbeddedObject >& xObj, ::rtl::OUString& rName ) 741 { 742 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::CopyAndGetEmbeddedObject" ); 743 744 uno::Reference< embed::XEmbeddedObject > xResult; 745 746 // TODO/LATER: For now only objects that implement XEmbedPersist have a replacement image, it might change in future 747 // do an incompatible change so that object name is provided in all the move and copy methods 748 ::rtl::OUString aOrigName; 749 try 750 { 751 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY_THROW ); 752 aOrigName = xPersist->getEntryName(); 753 } 754 catch( uno::Exception& ) 755 {} 756 757 if ( rName.isEmpty() ) 758 rName = CreateUniqueObjectName(); 759 760 // objects without persistance are not really stored by the method 761 if ( xObj.is() && StoreEmbeddedObject( xObj, rName, sal_True ) ) 762 { 763 xResult = Get_Impl( rName, xObj); 764 if ( !xResult.is() ) 765 { 766 // this is a case when object has no real persistence 767 // in such cases a new object should be explicitly created and initialized with the data of the old one 768 try 769 { 770 uno::Reference< embed::XLinkageSupport > xOrigLinkage( xObj, uno::UNO_QUERY ); 771 if ( xOrigLinkage.is() && xOrigLinkage->isLink() ) 772 { 773 // this is a OOo link, it has no persistence 774 ::rtl::OUString aURL = xOrigLinkage->getLinkURL(); 775 if ( aURL.isEmpty() ) 776 throw uno::RuntimeException(); 777 778 // create new linked object from the URL the link is based on 779 uno::Reference < embed::XLinkCreator > xCreator( 780 ::comphelper::getProcessServiceFactory()->createInstance( 781 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator") ) ), 782 uno::UNO_QUERY_THROW ); 783 784 uno::Sequence< beans::PropertyValue > aMediaDescr( 1 ); 785 aMediaDescr[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ); 786 aMediaDescr[0].Value <<= aURL; 787 uno::Sequence< beans::PropertyValue > aObjDescr( 1 ); 788 aObjDescr[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Parent" ) ); 789 aObjDescr[0].Value <<= pImpl->m_xModel.get(); 790 xResult = uno::Reference < embed::XEmbeddedObject >( 791 xCreator->createInstanceLink( 792 pImpl->mxStorage, 793 rName, 794 aMediaDescr, 795 aObjDescr ), 796 uno::UNO_QUERY_THROW ); 797 } 798 else 799 { 800 // the component is required for copying of this object 801 if ( xObj->getCurrentState() == embed::EmbedStates::LOADED ) 802 xObj->changeState( embed::EmbedStates::RUNNING ); 803 804 // this must be an object based on properties, otherwise we can not copy it currently 805 uno::Reference< beans::XPropertySet > xOrigProps( xObj->getComponent(), uno::UNO_QUERY_THROW ); 806 807 // use object class ID to create a new one and tranfer all the properties 808 uno::Reference < embed::XEmbedObjectCreator > xCreator( 809 ::comphelper::getProcessServiceFactory()->createInstance( 810 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator") ) ), 811 uno::UNO_QUERY_THROW ); 812 813 uno::Sequence< beans::PropertyValue > aObjDescr( 1 ); 814 aObjDescr[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Parent" ) ); 815 aObjDescr[0].Value <<= pImpl->m_xModel.get(); 816 xResult = uno::Reference < embed::XEmbeddedObject >( 817 xCreator->createInstanceInitNew( 818 xObj->getClassID(), 819 xObj->getClassName(), 820 pImpl->mxStorage, 821 rName, 822 aObjDescr ), 823 uno::UNO_QUERY_THROW ); 824 825 if ( xResult->getCurrentState() == embed::EmbedStates::LOADED ) 826 xResult->changeState( embed::EmbedStates::RUNNING ); 827 828 uno::Reference< beans::XPropertySet > xTargetProps( xResult->getComponent(), uno::UNO_QUERY_THROW ); 829 830 // copy all the properties from xOrigProps to xTargetProps 831 uno::Reference< beans::XPropertySetInfo > xOrigInfo = xOrigProps->getPropertySetInfo(); 832 if ( !xOrigInfo.is() ) 833 throw uno::RuntimeException(); 834 835 uno::Sequence< beans::Property > aPropertiesList = xOrigInfo->getProperties(); 836 for ( sal_Int32 nInd = 0; nInd < aPropertiesList.getLength(); nInd++ ) 837 { 838 try 839 { 840 xTargetProps->setPropertyValue( 841 aPropertiesList[nInd].Name, 842 xOrigProps->getPropertyValue( aPropertiesList[nInd].Name ) ); 843 } 844 catch( beans::PropertyVetoException& ) 845 { 846 // impossibility to copy readonly property is not treated as an error for now 847 // but the assertion is helpful to detect such scenarios and review them 848 OSL_ENSURE( sal_False, "Could not copy readonly property!\n" ); 849 } 850 } 851 } 852 853 if ( xResult.is() ) 854 AddEmbeddedObject( xResult, rName ); 855 } 856 catch( uno::Exception& ) 857 { 858 if ( xResult.is() ) 859 { 860 try 861 { 862 xResult->close( sal_True ); 863 } 864 catch( uno::Exception& ) 865 {} 866 xResult = uno::Reference< embed::XEmbeddedObject >(); 867 } 868 } 869 } 870 } 871 872 OSL_ENSURE( xResult.is(), "Can not copy embedded object that has no persistance!\n" ); 873 874 if ( xResult.is() ) 875 { 876 // the object is successfully copied, try to copy graphical replacement 877 if ( !aOrigName.isEmpty() ) 878 TryToCopyGraphReplacement( rSrc, aOrigName, rName ); 879 880 // the object might need the size to be set 881 try 882 { 883 if ( xResult->getStatus( embed::Aspects::MSOLE_CONTENT ) & embed::EmbedMisc::EMBED_NEEDSSIZEONLOAD ) 884 xResult->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, 885 xObj->getVisualAreaSize( embed::Aspects::MSOLE_CONTENT ) ); 886 } 887 catch( uno::Exception& ) 888 {} 889 } 890 891 return xResult; 892 } 893 894 sal_Bool EmbeddedObjectContainer::MoveEmbeddedObject( EmbeddedObjectContainer& rSrc, const uno::Reference < embed::XEmbeddedObject >& xObj, ::rtl::OUString& rName ) 895 { 896 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::MoveEmbeddedObject( Object )" ); 897 898 // get the object name before(!) it is assigned to a new storage 899 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 900 ::rtl::OUString aName; 901 if ( xPersist.is() ) 902 aName = xPersist->getEntryName(); 903 904 // now move the object to the new container; the returned name is the new persist name in this container 905 sal_Bool bRet; 906 907 try 908 { 909 bRet = InsertEmbeddedObject( xObj, rName ); 910 if ( bRet ) 911 TryToCopyGraphReplacement( rSrc, aName, rName ); 912 } 913 catch ( uno::Exception& e ) 914 { 915 (void)e; 916 OSL_ENSURE( sal_False, "Failed to insert embedded object into storage!" ); 917 bRet = sal_False; 918 } 919 920 if ( bRet ) 921 { 922 // now remove the object from the former container 923 bRet = sal_False; 924 EmbeddedObjectContainerNameMap::iterator aIt = rSrc.pImpl->maObjectContainer.begin(); 925 while ( aIt != rSrc.pImpl->maObjectContainer.end() ) 926 { 927 if ( (*aIt).second == xObj ) 928 { 929 rSrc.pImpl->maObjectContainer.erase( aIt ); 930 bRet = sal_True; 931 break; 932 } 933 934 aIt++; 935 } 936 937 OSL_ENSURE( bRet, "Object not found for removal!" ); 938 if ( xPersist.is() ) 939 { 940 // now it's time to remove the storage from the container storage 941 try 942 { 943 if ( xPersist.is() ) 944 rSrc.pImpl->mxStorage->removeElement( aName ); 945 } 946 catch ( uno::Exception& ) 947 { 948 OSL_ENSURE( sal_False, "Failed to remove object from storage!" ); 949 bRet = sal_False; 950 } 951 } 952 953 // rSrc.RemoveGraphicStream( aName ); 954 } 955 956 return bRet; 957 } 958 959 //sal_Bool EmbeddedObjectContainer::RemoveEmbeddedObject( const ::rtl::OUString& rName, sal_Bool bClose ) 960 // #i119941, bKeepToTempStorage: use to specify whether store the removed object to temporary storage+ 961 sal_Bool EmbeddedObjectContainer::RemoveEmbeddedObject( const ::rtl::OUString& rName, sal_Bool bClose, sal_Bool bKeepToTempStorage ) 962 { 963 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::RemoveEmbeddedObject( Name )" ); 964 965 uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( rName ); 966 if ( xObj.is() ) 967 //return RemoveEmbeddedObject( xObj, bClose ); 968 return RemoveEmbeddedObject( xObj, bClose, bKeepToTempStorage ); 969 else 970 return sal_False; 971 } 972 973 sal_Bool EmbeddedObjectContainer::MoveEmbeddedObject( const ::rtl::OUString& rName, EmbeddedObjectContainer& rCnt ) 974 { 975 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::MoveEmbeddedObject( Name )" ); 976 977 // find object entry 978 EmbeddedObjectContainerNameMap::iterator aIt2 = rCnt.pImpl->maObjectContainer.find( rName ); 979 OSL_ENSURE( aIt2 == rCnt.pImpl->maObjectContainer.end(), "Object does already exist in target container!" ); 980 981 if ( aIt2 != rCnt.pImpl->maObjectContainer.end() ) 982 return sal_False; 983 984 uno::Reference < embed::XEmbeddedObject > xObj; 985 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.find( rName ); 986 if ( aIt != pImpl->maObjectContainer.end() ) 987 { 988 xObj = (*aIt).second; 989 try 990 { 991 if ( xObj.is() ) 992 { 993 // move object 994 ::rtl::OUString aName( rName ); 995 rCnt.InsertEmbeddedObject( xObj, aName ); 996 pImpl->maObjectContainer.erase( aIt ); 997 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 998 if ( xPersist.is() ) 999 pImpl->mxStorage->removeElement( rName ); 1000 } 1001 else 1002 { 1003 // copy storages; object *must* have persistence! 1004 uno::Reference < embed::XStorage > xOld = pImpl->mxStorage->openStorageElement( rName, embed::ElementModes::READ ); 1005 uno::Reference < embed::XStorage > xNew = rCnt.pImpl->mxStorage->openStorageElement( rName, embed::ElementModes::READWRITE ); 1006 xOld->copyToStorage( xNew ); 1007 } 1008 1009 rCnt.TryToCopyGraphReplacement( *this, rName, rName ); 1010 // RemoveGraphicStream( rName ); 1011 1012 return sal_True; 1013 } 1014 catch ( uno::Exception& ) 1015 { 1016 OSL_ENSURE(0,"Could not move object!"); 1017 return sal_False; 1018 } 1019 1020 } 1021 else 1022 OSL_ENSURE(0,"Unknown object!"); 1023 return sal_False; 1024 } 1025 1026 //sal_Bool EmbeddedObjectContainer::RemoveEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj, sal_Bool bClose ) 1027 // #i119941, bKeepToTempStorage: use to specify whether store the removed object to temporary storage+ 1028 sal_Bool EmbeddedObjectContainer::RemoveEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj, sal_Bool bClose, sal_Bool bKeepToTempStorage ) 1029 { 1030 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::RemoveEmbeddedObject( Object )" ); 1031 1032 uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 1033 ::rtl::OUString aName; 1034 if ( xPersist.is() ) 1035 aName = xPersist->getEntryName(); 1036 1037 #if OSL_DEBUG_LEVEL > 1 1038 uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY ); 1039 uno::Reference < embed::XLinkageSupport > xLink( xPersist, uno::UNO_QUERY ); 1040 sal_Bool bIsNotEmbedded = !xPersist.is() || xLink.is() && xLink->isLink(); 1041 1042 // if the object has a persistance and the object is not a link than it must have persistence entry in the storage 1043 OSL_ENSURE( bIsNotEmbedded || xAccess->hasByName(aName), "Removing element not present in storage!" ); 1044 #endif 1045 1046 // try to close it if permitted 1047 if ( bClose ) 1048 { 1049 uno::Reference < ::util::XCloseable > xClose( xObj, uno::UNO_QUERY ); 1050 try 1051 { 1052 xClose->close( sal_True ); 1053 } 1054 catch ( util::CloseVetoException& ) 1055 { 1056 bClose = sal_False; 1057 } 1058 } 1059 1060 if ( !bClose ) 1061 { 1062 // somebody still needs the object, so we must assign a temporary persistence 1063 try 1064 { 1065 // if ( xPersist.is() ) 1066 if ( xPersist.is() && bKeepToTempStorage ) // #i119941 1067 { 1068 /* 1069 //TODO/LATER: needs storage handling! Why not letting the object do it?! 1070 if ( !pImpl->mxTempStorage.is() ) 1071 pImpl->mxTempStorage = ::comphelper::OStorageHelper::GetTemporaryStorage(); 1072 uno::Sequence < beans::PropertyValue > aSeq; 1073 1074 ::rtl::OUString aTmpPersistName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("Object ") ); 1075 aTmpPersistName += ::rtl::OUString::valueOf( (sal_Int32) pImpl->maTempObjectContainer.size() ); 1076 1077 xPersist->storeAsEntry( pImpl->mxTempStorage, aTmpPersistName, aSeq, aSeq ); 1078 xPersist->saveCompleted( sal_True ); 1079 1080 pImpl->maTempObjectContainer[ aTmpPersistName ] = uno::Reference < embed::XEmbeddedObject >(); 1081 */ 1082 1083 if ( !pImpl->mpTempObjectContainer ) 1084 { 1085 pImpl->mpTempObjectContainer = new EmbeddedObjectContainer(); 1086 try 1087 { 1088 // TODO/LATER: in future probably the temporary container will have two storages ( of two formats ) 1089 // the media type will be provided with object insertion 1090 ::rtl::OUString aOrigStorMediaType; 1091 uno::Reference< beans::XPropertySet > xStorProps( pImpl->mxStorage, uno::UNO_QUERY_THROW ); 1092 static const ::rtl::OUString s_sMediaType(RTL_CONSTASCII_USTRINGPARAM("MediaType")); 1093 xStorProps->getPropertyValue( s_sMediaType ) >>= aOrigStorMediaType; 1094 1095 OSL_ENSURE( !aOrigStorMediaType.isEmpty(), "No valuable media type in the storage!\n" ); 1096 1097 uno::Reference< beans::XPropertySet > xTargetStorProps( 1098 pImpl->mpTempObjectContainer->pImpl->mxStorage, 1099 uno::UNO_QUERY_THROW ); 1100 xTargetStorProps->setPropertyValue( s_sMediaType,uno::makeAny( aOrigStorMediaType ) ); 1101 } 1102 catch( uno::Exception& ) 1103 { 1104 OSL_ENSURE( sal_False, "Can not set the new media type to a storage!\n" ); 1105 } 1106 } 1107 1108 ::rtl::OUString aTempName, aMediaType; 1109 pImpl->mpTempObjectContainer->InsertEmbeddedObject( xObj, aTempName ); 1110 1111 uno::Reference < io::XInputStream > xStream = GetGraphicStream( xObj, &aMediaType ); 1112 if ( xStream.is() ) 1113 pImpl->mpTempObjectContainer->InsertGraphicStream( xStream, aTempName, aMediaType ); 1114 1115 // object is stored, so at least it can be set to loaded state 1116 xObj->changeState( embed::EmbedStates::LOADED ); 1117 } 1118 else 1119 // objects without persistence need to stay in running state if they shall not be closed 1120 xObj->changeState( embed::EmbedStates::RUNNING ); 1121 } 1122 catch ( uno::Exception& ) 1123 { 1124 return sal_False; 1125 } 1126 } 1127 1128 sal_Bool bFound = sal_False; 1129 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.begin(); 1130 while ( aIt != pImpl->maObjectContainer.end() ) 1131 { 1132 if ( (*aIt).second == xObj ) 1133 { 1134 pImpl->maObjectContainer.erase( aIt ); 1135 bFound = sal_True; 1136 uno::Reference < container::XChild > xChild( xObj, uno::UNO_QUERY ); 1137 if ( xChild.is() ) 1138 xChild->setParent( uno::Reference < uno::XInterface >() ); 1139 break; 1140 } 1141 1142 aIt++; 1143 } 1144 1145 OSL_ENSURE( bFound, "Object not found for removal!" ); 1146 // if ( xPersist.is() ) 1147 if ( xPersist.is() && bKeepToTempStorage ) // #i119941 1148 { 1149 // remove replacement image (if there is one) 1150 RemoveGraphicStream( aName ); 1151 1152 // now it's time to remove the storage from the container storage 1153 try 1154 { 1155 #if OSL_DEBUG_LEVEL > 1 1156 // if the object has a persistance and the object is not a link than it must have persistence entry in storage 1157 OSL_ENSURE( bIsNotEmbedded || pImpl->mxStorage->hasByName( aName ), "The object has no persistence entry in the storage!" ); 1158 #endif 1159 if ( xPersist.is() && pImpl->mxStorage->hasByName( aName ) ) 1160 pImpl->mxStorage->removeElement( aName ); 1161 } 1162 catch ( uno::Exception& ) 1163 { 1164 OSL_ENSURE( sal_False, "Failed to remove object from storage!" ); 1165 return sal_False; 1166 } 1167 } 1168 1169 return sal_True; 1170 } 1171 1172 sal_Bool EmbeddedObjectContainer::CloseEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj ) 1173 { 1174 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::CloseEmbeddedObject" ); 1175 1176 // disconnect the object from the container and close it if possible 1177 1178 sal_Bool bFound = sal_False; 1179 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.begin(); 1180 while ( aIt != pImpl->maObjectContainer.end() ) 1181 { 1182 if ( (*aIt).second == xObj ) 1183 { 1184 pImpl->maObjectContainer.erase( aIt ); 1185 bFound = sal_True; 1186 break; 1187 } 1188 1189 aIt++; 1190 } 1191 1192 if ( bFound ) 1193 { 1194 uno::Reference < ::util::XCloseable > xClose( xObj, uno::UNO_QUERY ); 1195 try 1196 { 1197 xClose->close( sal_True ); 1198 } 1199 catch ( uno::Exception& ) 1200 { 1201 // it is no problem if the object is already closed 1202 // TODO/LATER: what if the object can not be closed? 1203 } 1204 } 1205 1206 return bFound; 1207 } 1208 1209 uno::Reference < io::XInputStream > EmbeddedObjectContainer::GetGraphicStream( const ::rtl::OUString& aName, rtl::OUString* pMediaType ) 1210 { 1211 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::GetGraphicStream( Name )" ); 1212 1213 uno::Reference < io::XInputStream > xStream; 1214 1215 OSL_ENSURE( !aName.isEmpty(), "Retrieving graphic for unknown object!" ); 1216 if ( !aName.isEmpty() ) 1217 { 1218 try 1219 { 1220 uno::Reference < embed::XStorage > xReplacements = pImpl->GetReplacements(); 1221 uno::Reference < io::XStream > xGraphicStream = xReplacements->openStreamElement( aName, embed::ElementModes::READ ); 1222 xStream = xGraphicStream->getInputStream(); 1223 if ( pMediaType ) 1224 { 1225 uno::Reference < beans::XPropertySet > xSet( xStream, uno::UNO_QUERY ); 1226 if ( xSet.is() ) 1227 { 1228 uno::Any aAny = xSet->getPropertyValue( ::rtl::OUString::createFromAscii("MediaType") ); 1229 aAny >>= *pMediaType; 1230 } 1231 } 1232 } 1233 catch ( uno::Exception& ) 1234 { 1235 } 1236 } 1237 1238 return xStream; 1239 } 1240 1241 uno::Reference < io::XInputStream > EmbeddedObjectContainer::GetGraphicStream( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& xObj, rtl::OUString* pMediaType ) 1242 { 1243 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::GetGraphicStream( Object )" ); 1244 1245 // get the object name 1246 ::rtl::OUString aName; 1247 EmbeddedObjectContainerNameMap::iterator aIt = pImpl->maObjectContainer.begin(); 1248 while ( aIt != pImpl->maObjectContainer.end() ) 1249 { 1250 if ( (*aIt).second == xObj ) 1251 { 1252 aName = (*aIt).first; 1253 break; 1254 } 1255 1256 aIt++; 1257 } 1258 1259 // try to load it from the container storage 1260 return GetGraphicStream( aName, pMediaType ); 1261 } 1262 1263 sal_Bool EmbeddedObjectContainer::InsertGraphicStream( const com::sun::star::uno::Reference < com::sun::star::io::XInputStream >& rStream, const ::rtl::OUString& rObjectName, const rtl::OUString& rMediaType ) 1264 { 1265 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::InsertGraphicStream" ); 1266 1267 try 1268 { 1269 uno::Reference < embed::XStorage > xReplacements = pImpl->GetReplacements(); 1270 1271 // store it into the subfolder 1272 uno::Reference < io::XOutputStream > xOutStream; 1273 uno::Reference < io::XStream > xGraphicStream = xReplacements->openStreamElement( rObjectName, 1274 embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE ); 1275 xOutStream = xGraphicStream->getOutputStream(); 1276 ::comphelper::OStorageHelper::CopyInputToOutput( rStream, xOutStream ); 1277 xOutStream->flush(); 1278 1279 uno::Reference< beans::XPropertySet > xPropSet( xGraphicStream, uno::UNO_QUERY ); 1280 if ( !xPropSet.is() ) 1281 throw uno::RuntimeException(); 1282 1283 xPropSet->setPropertyValue( ::rtl::OUString::createFromAscii( "UseCommonStoragePasswordEncryption" ), 1284 uno::makeAny( (sal_Bool)sal_True ) ); 1285 uno::Any aAny; 1286 aAny <<= rMediaType; 1287 xPropSet->setPropertyValue( ::rtl::OUString::createFromAscii("MediaType"), aAny ); 1288 1289 xPropSet->setPropertyValue( ::rtl::OUString::createFromAscii( "Compressed" ), 1290 uno::makeAny( (sal_Bool)sal_True ) ); 1291 } 1292 catch( uno::Exception& ) 1293 { 1294 return sal_False; 1295 } 1296 1297 return sal_True; 1298 } 1299 1300 sal_Bool EmbeddedObjectContainer::InsertGraphicStreamDirectly( const com::sun::star::uno::Reference < com::sun::star::io::XInputStream >& rStream, const ::rtl::OUString& rObjectName, const rtl::OUString& rMediaType ) 1301 { 1302 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::InsertGraphicStreamDirectly" ); 1303 1304 try 1305 { 1306 uno::Reference < embed::XStorage > xReplacement = pImpl->GetReplacements(); 1307 uno::Reference < embed::XOptimizedStorage > xOptRepl( xReplacement, uno::UNO_QUERY_THROW ); 1308 1309 // store it into the subfolder 1310 uno::Sequence< beans::PropertyValue > aProps( 3 ); 1311 aProps[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ); 1312 aProps[0].Value <<= rMediaType; 1313 aProps[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseCommonStoragePasswordEncryption" ) ); 1314 aProps[1].Value <<= (sal_Bool)sal_True; 1315 aProps[2].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Compressed" ) ); 1316 aProps[2].Value <<= (sal_Bool)sal_True; 1317 1318 if ( xReplacement->hasByName( rObjectName ) ) 1319 xReplacement->removeElement( rObjectName ); 1320 1321 xOptRepl->insertStreamElementDirect( rObjectName, rStream, aProps ); 1322 } 1323 catch( uno::Exception& ) 1324 { 1325 return sal_False; 1326 } 1327 1328 return sal_True; 1329 } 1330 1331 1332 sal_Bool EmbeddedObjectContainer::RemoveGraphicStream( const ::rtl::OUString& rObjectName ) 1333 { 1334 RTL_LOGFILE_CONTEXT( aLog, "comphelper (mv76033) comphelper::EmbeddedObjectContainer::RemoveGraphicStream" ); 1335 1336 try 1337 { 1338 uno::Reference < embed::XStorage > xReplacements = pImpl->GetReplacements(); 1339 xReplacements->removeElement( rObjectName ); 1340 } 1341 catch( uno::Exception& ) 1342 { 1343 return sal_False; 1344 } 1345 1346 return sal_True; 1347 } 1348 namespace { 1349 void InsertStreamIntoPicturesStorage_Impl( const uno::Reference< embed::XStorage >& xDocStor, 1350 const uno::Reference< io::XInputStream >& xInStream, 1351 const ::rtl::OUString& aStreamName ) 1352 { 1353 OSL_ENSURE( !aStreamName.isEmpty() && xInStream.is() && xDocStor.is(), "Misuse of the method!\n" ); 1354 1355 try 1356 { 1357 uno::Reference< embed::XStorage > xPictures = xDocStor->openStorageElement( 1358 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Pictures" ) ), 1359 embed::ElementModes::READWRITE ); 1360 uno::Reference< io::XStream > xObjReplStr = xPictures->openStreamElement( 1361 aStreamName, 1362 embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE ); 1363 uno::Reference< io::XOutputStream > xOutStream( 1364 xObjReplStr->getInputStream(), uno::UNO_QUERY_THROW ); 1365 1366 ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xOutStream ); 1367 xOutStream->closeOutput(); 1368 1369 uno::Reference< embed::XTransactedObject > xTransact( xPictures, uno::UNO_QUERY ); 1370 if ( xTransact.is() ) 1371 xTransact->commit(); 1372 } 1373 catch( uno::Exception& ) 1374 { 1375 OSL_ENSURE( sal_False, "The pictures storage is not available!\n" ); 1376 } 1377 } 1378 1379 } 1380 // ----------------------------------------------------------------------------- 1381 sal_Bool EmbeddedObjectContainer::StoreAsChildren(sal_Bool _bOasisFormat,sal_Bool _bCreateEmbedded,const uno::Reference < embed::XStorage >& _xStorage) 1382 { 1383 sal_Bool bResult = sal_False; 1384 try 1385 { 1386 comphelper::EmbeddedObjectContainer aCnt( _xStorage ); 1387 const uno::Sequence < ::rtl::OUString > aNames = GetObjectNames(); 1388 const ::rtl::OUString* pIter = aNames.getConstArray(); 1389 const ::rtl::OUString* pEnd = pIter + aNames.getLength(); 1390 for(;pIter != pEnd;++pIter) 1391 { 1392 uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( *pIter ); 1393 OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!\n" ); 1394 if ( xObj.is() ) 1395 { 1396 sal_Bool bSwitchBackToLoaded = sal_False; 1397 uno::Reference< embed::XLinkageSupport > xLink( xObj, uno::UNO_QUERY ); 1398 1399 uno::Reference < io::XInputStream > xStream; 1400 ::rtl::OUString aMediaType; 1401 1402 sal_Int32 nCurState = xObj->getCurrentState(); 1403 if ( nCurState == embed::EmbedStates::LOADED || nCurState == embed::EmbedStates::RUNNING ) 1404 { 1405 // means that the object is not active 1406 // copy replacement image from old to new container 1407 xStream = GetGraphicStream( xObj, &aMediaType ); 1408 } 1409 1410 if ( !xStream.is() && getUserAllowsLinkUpdate() ) 1411 { 1412 // the image must be regenerated 1413 // TODO/LATER: another aspect could be used 1414 if ( xObj->getCurrentState() == embed::EmbedStates::LOADED ) 1415 bSwitchBackToLoaded = sal_True; 1416 1417 xStream = GetGraphicReplacementStream( 1418 embed::Aspects::MSOLE_CONTENT, 1419 xObj, 1420 &aMediaType ); 1421 } 1422 1423 if ( _bOasisFormat || (xLink.is() && xLink->isLink()) ) 1424 { 1425 if ( xStream.is() ) 1426 { 1427 if ( _bOasisFormat ) 1428 { 1429 // if it is an embedded object or the optimized inserting fails the normal inserting should be done 1430 if ( _bCreateEmbedded 1431 || !aCnt.InsertGraphicStreamDirectly( xStream, *pIter, aMediaType ) ) 1432 aCnt.InsertGraphicStream( xStream, *pIter, aMediaType ); 1433 } 1434 else 1435 { 1436 // it is a linked object exported into SO7 format 1437 InsertStreamIntoPicturesStorage_Impl( _xStorage, xStream, *pIter ); 1438 } 1439 } 1440 } 1441 1442 uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 1443 if ( xPersist.is() ) 1444 { 1445 uno::Sequence< beans::PropertyValue > aArgs( _bOasisFormat ? 2 : 3 ); 1446 aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StoreVisualReplacement" ) ); 1447 aArgs[0].Value <<= (sal_Bool)( !_bOasisFormat ); 1448 1449 // if it is an embedded object or the optimized inserting fails the normal inserting should be done 1450 aArgs[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CanTryOptimization" ) ); 1451 aArgs[1].Value <<= !_bCreateEmbedded; 1452 if ( !_bOasisFormat ) 1453 { 1454 // if object has no cached replacement it will use this one 1455 aArgs[2].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "VisualReplacement" ) ); 1456 aArgs[2].Value <<= xStream; 1457 } 1458 1459 xPersist->storeAsEntry( _xStorage, 1460 xPersist->getEntryName(), 1461 uno::Sequence< beans::PropertyValue >(), 1462 aArgs ); 1463 } 1464 1465 if ( bSwitchBackToLoaded ) 1466 // switch back to loaded state; that way we have a minimum cache confusion 1467 xObj->changeState( embed::EmbedStates::LOADED ); 1468 } 1469 } 1470 1471 bResult = aCnt.CommitImageSubStorage(); 1472 1473 } 1474 catch ( uno::Exception& ) 1475 { 1476 // TODO/LATER: error handling 1477 bResult = sal_False; 1478 } 1479 1480 // the old SO6 format does not store graphical replacements 1481 if ( !_bOasisFormat && bResult ) 1482 { 1483 try 1484 { 1485 // the substorage still can not be locked by the embedded object conteiner 1486 ::rtl::OUString aObjReplElement( RTL_CONSTASCII_USTRINGPARAM( "ObjectReplacements" ) ); 1487 if ( _xStorage->hasByName( aObjReplElement ) && _xStorage->isStorageElement( aObjReplElement ) ) 1488 _xStorage->removeElement( aObjReplElement ); 1489 } 1490 catch ( uno::Exception& ) 1491 { 1492 // TODO/LATER: error handling; 1493 bResult = sal_False; 1494 } 1495 } 1496 return bResult; 1497 } 1498 // ----------------------------------------------------------------------------- 1499 sal_Bool EmbeddedObjectContainer::StoreChildren(sal_Bool _bOasisFormat,sal_Bool _bObjectsOnly) 1500 { 1501 sal_Bool bResult = sal_True; 1502 const uno::Sequence < ::rtl::OUString > aNames = GetObjectNames(); 1503 const ::rtl::OUString* pIter = aNames.getConstArray(); 1504 const ::rtl::OUString* pEnd = pIter + aNames.getLength(); 1505 for(;pIter != pEnd;++pIter) 1506 { 1507 uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( *pIter ); 1508 OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!\n" ); 1509 if ( xObj.is() ) 1510 { 1511 sal_Int32 nCurState = xObj->getCurrentState(); 1512 if ( _bOasisFormat && nCurState != embed::EmbedStates::LOADED && nCurState != embed::EmbedStates::RUNNING ) 1513 { 1514 // means that the object is active 1515 // the image must be regenerated 1516 ::rtl::OUString aMediaType; 1517 1518 // TODO/LATER: another aspect could be used 1519 uno::Reference < io::XInputStream > xStream = 1520 GetGraphicReplacementStream( 1521 embed::Aspects::MSOLE_CONTENT, 1522 xObj, 1523 &aMediaType ); 1524 if ( xStream.is() ) 1525 { 1526 if ( !InsertGraphicStreamDirectly( xStream, *pIter, aMediaType ) ) 1527 InsertGraphicStream( xStream, *pIter, aMediaType ); 1528 } 1529 } 1530 1531 // TODO/LATER: currently the object by default does not cache replacement image 1532 // that means that if somebody loads SO7 document and store its objects using 1533 // this method the images might be lost. 1534 // Currently this method is only used on storing to alien formats, that means 1535 // that SO7 documents storing does not use it, and all other filters are 1536 // based on OASIS format. But if it changes the method must be fixed. The fix 1537 // must be done only on demand since it can affect performance. 1538 1539 uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 1540 if ( xPersist.is() ) 1541 { 1542 try 1543 { 1544 //TODO/LATER: only storing if changed! 1545 //xPersist->storeOwn(); //commented, i120168 1546 1547 // begin:all charts will be persited as xml format on disk when saving, which is time consuming. 1548 // '_bObjectsOnly' mean we are storing to alien formats. 1549 // 'isStorageElement' mean current object is NOT an MS OLE format. (may also include in future), i120168 1550 if (_bObjectsOnly && (nCurState == embed::EmbedStates::LOADED || nCurState == embed::EmbedStates::RUNNING) 1551 && (pImpl->mxStorage->isStorageElement( *pIter ) )) 1552 { 1553 uno::Reference< util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY ); 1554 if ( xModifiable.is() && xModifiable->isModified()) 1555 { 1556 xPersist->storeOwn(); 1557 } 1558 else 1559 { 1560 //do nothing.embeded model is not modified, no need to persist. 1561 } 1562 } 1563 else //the embeded object is in active status, always store back it. 1564 { 1565 xPersist->storeOwn(); 1566 } 1567 //end i120168 1568 } 1569 catch( uno::Exception& ) 1570 { 1571 // TODO/LATER: error handling 1572 bResult = sal_False; 1573 break; 1574 } 1575 } 1576 1577 if ( !_bOasisFormat && !_bObjectsOnly ) 1578 { 1579 // copy replacement images for linked objects 1580 try 1581 { 1582 uno::Reference< embed::XLinkageSupport > xLink( xObj, uno::UNO_QUERY ); 1583 if ( xLink.is() && xLink->isLink() ) 1584 { 1585 ::rtl::OUString aMediaType; 1586 uno::Reference < io::XInputStream > xInStream = GetGraphicStream( xObj, &aMediaType ); 1587 if ( xInStream.is() ) 1588 InsertStreamIntoPicturesStorage_Impl( pImpl->mxStorage, xInStream, *pIter ); 1589 } 1590 } 1591 catch( uno::Exception& ) 1592 { 1593 } 1594 } 1595 } 1596 } 1597 1598 if ( bResult && _bOasisFormat ) 1599 bResult = CommitImageSubStorage(); 1600 1601 if ( bResult && !_bObjectsOnly ) 1602 { 1603 try 1604 { 1605 ReleaseImageSubStorage(); 1606 ::rtl::OUString aObjReplElement( RTL_CONSTASCII_USTRINGPARAM( "ObjectReplacements" ) ); 1607 if ( !_bOasisFormat && pImpl->mxStorage->hasByName( aObjReplElement ) && pImpl->mxStorage->isStorageElement( aObjReplElement ) ) 1608 pImpl->mxStorage->removeElement( aObjReplElement ); 1609 } 1610 catch( uno::Exception& ) 1611 { 1612 // TODO/LATER: error handling 1613 bResult = sal_False; 1614 } 1615 } 1616 return bResult; 1617 } 1618 // ----------------------------------------------------------------------------- 1619 uno::Reference< io::XInputStream > EmbeddedObjectContainer::GetGraphicReplacementStream( 1620 sal_Int64 nViewAspect, 1621 const uno::Reference< embed::XEmbeddedObject >& xObj, 1622 ::rtl::OUString* pMediaType ) 1623 { 1624 uno::Reference< io::XInputStream > xInStream; 1625 if ( xObj.is() ) 1626 { 1627 try 1628 { 1629 // retrieving of the visual representation can switch object to running state 1630 embed::VisualRepresentation aRep = xObj->getPreferredVisualRepresentation( nViewAspect ); 1631 if ( pMediaType ) 1632 *pMediaType = aRep.Flavor.MimeType; 1633 1634 uno::Sequence < sal_Int8 > aSeq; 1635 aRep.Data >>= aSeq; 1636 xInStream = new ::comphelper::SequenceInputStream( aSeq ); 1637 } 1638 catch ( uno::Exception& ) 1639 { 1640 } 1641 } 1642 1643 return xInStream; 1644 } 1645 // ----------------------------------------------------------------------------- 1646 sal_Bool EmbeddedObjectContainer::SetPersistentEntries(const uno::Reference< embed::XStorage >& _xStorage,bool _bClearModifedFlag) 1647 { 1648 sal_Bool bError = sal_False; 1649 const uno::Sequence < ::rtl::OUString > aNames = GetObjectNames(); 1650 const ::rtl::OUString* pIter = aNames.getConstArray(); 1651 const ::rtl::OUString* pEnd = pIter + aNames.getLength(); 1652 for(;pIter != pEnd;++pIter) 1653 { 1654 uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( *pIter ); 1655 OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!\n" ); 1656 if ( xObj.is() ) 1657 { 1658 uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); 1659 if ( xPersist.is() ) 1660 { 1661 try 1662 { 1663 xPersist->setPersistentEntry( _xStorage, 1664 *pIter, 1665 embed::EntryInitModes::NO_INIT, 1666 uno::Sequence< beans::PropertyValue >(), 1667 uno::Sequence< beans::PropertyValue >() ); 1668 1669 } 1670 catch( uno::Exception& ) 1671 { 1672 // TODO/LATER: error handling 1673 bError = sal_True; 1674 break; 1675 } 1676 } 1677 if ( _bClearModifedFlag ) 1678 { 1679 // if this method is used as part of SaveCompleted the object must stay unmodified after execution 1680 try 1681 { 1682 uno::Reference< util::XModifiable > xModif( xObj->getComponent(), uno::UNO_QUERY_THROW ); 1683 if ( xModif->isModified() ) 1684 xModif->setModified( sal_False ); 1685 } 1686 catch( uno::Exception& ) 1687 { 1688 } 1689 } 1690 } 1691 } 1692 return bError; 1693 } 1694 1695 bool EmbeddedObjectContainer::getUserAllowsLinkUpdate() const 1696 { 1697 return pImpl->mbUserAllowsLinkUpdate; 1698 } 1699 1700 void EmbeddedObjectContainer::setUserAllowsLinkUpdate(bool bNew) 1701 { 1702 if(pImpl->mbUserAllowsLinkUpdate != bNew) 1703 { 1704 pImpl->mbUserAllowsLinkUpdate = bNew; 1705 } 1706 } 1707 1708 } 1709