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_embeddedobj.hxx" 26 #include <com/sun/star/lang/IllegalArgumentException.hpp> 27 #include <com/sun/star/lang/DisposedException.hpp> 28 #include <com/sun/star/embed/WrongStateException.hpp> 29 #include <com/sun/star/embed/UnreachableStateException.hpp> 30 #include <com/sun/star/ucb/XSimpleFileAccess.hpp> 31 #include <com/sun/star/beans/XPropertySet.hpp> 32 #include <com/sun/star/io/XTruncate.hpp> 33 #include <com/sun/star/awt/XRequestCallback.hpp> 34 35 #include <platform.h> 36 #include <cppuhelper/interfacecontainer.h> 37 #include <comphelper/mimeconfighelper.hxx> 38 #include <comphelper/storagehelper.hxx> 39 #include <osl/file.hxx> 40 #include <rtl/ref.hxx> 41 42 #include <olecomponent.hxx> 43 #include <olewrapclient.hxx> 44 #include <advisesink.hxx> 45 #include <oleembobj.hxx> 46 #include <mtnotification.hxx> 47 48 using namespace ::com::sun::star; 49 using namespace ::comphelper; 50 #define MAX_ENUM_ELE 20 51 #define FORMATS_NUM 3 52 53 // ============ class ComSmart ===================== 54 namespace { 55 56 template< class T > class ComSmart 57 { 58 T* m_pInterface; 59 60 void OwnRelease() 61 { 62 if ( m_pInterface ) 63 { 64 T* pInterface = m_pInterface; 65 m_pInterface = NULL; 66 pInterface->Release(); 67 } 68 } 69 70 public: 71 ComSmart() 72 : m_pInterface( NULL ) 73 {} 74 75 ComSmart( const ComSmart<T>& rObj ) 76 : m_pInterface( rObj.m_pInterface ) 77 { 78 if ( m_pInterface != NULL ) 79 m_pInterface->AddRef(); 80 } 81 82 ComSmart( T* pInterface ) 83 : m_pInterface( pInterface ) 84 { 85 if ( m_pInterface != NULL ) 86 m_pInterface->AddRef(); 87 } 88 89 ~ComSmart() 90 { 91 OwnRelease(); 92 } 93 94 ComSmart& operator=( const ComSmart<T>& rObj ) 95 { 96 OwnRelease(); 97 98 m_pInterface = rObj.m_pInterface; 99 100 if ( m_pInterface != NULL ) 101 m_pInterface->AddRef(); 102 103 return *this; 104 } 105 106 ComSmart<T>& operator=( T* pInterface ) 107 { 108 OwnRelease(); 109 110 m_pInterface = pInterface; 111 112 if ( m_pInterface != NULL ) 113 m_pInterface->AddRef(); 114 115 return *this; 116 } 117 118 operator T*() const 119 { 120 return m_pInterface; 121 } 122 123 T& operator*() const 124 { 125 return *m_pInterface; 126 } 127 128 T** operator&() 129 { 130 OwnRelease(); 131 132 m_pInterface = NULL; 133 134 return &m_pInterface; 135 } 136 137 T* operator->() const 138 { 139 return m_pInterface; 140 } 141 142 BOOL operator==( const ComSmart<T>& rObj ) const 143 { 144 return ( m_pInterface == rObj.m_pInterface ); 145 } 146 147 BOOL operator!=( const ComSmart<T>& rObj ) const 148 { 149 return ( m_pInterface != rObj.m_pInterface ); 150 } 151 152 BOOL operator==( const T* pInterface ) const 153 { 154 return ( m_pInterface == pInterface ); 155 } 156 157 BOOL operator!=( const T* pInterface ) const 158 { 159 return ( m_pInterface != pInterface ); 160 } 161 }; 162 163 } 164 165 // ============ class ComSmart ===================== 166 167 sal_Bool ConvertBufferToFormat( void* pBuf, 168 sal_uInt32 nBufSize, 169 const ::rtl::OUString& aFormatShortName, 170 uno::Any& aResult ); 171 172 ::rtl::OUString GetNewTempFileURL_Impl( const uno::Reference< lang::XMultiServiceFactory >& xFactory ) throw( io::IOException ); 173 174 typedef ::std::vector< FORMATETC* > FormatEtcList; 175 176 FORMATETC pFormatTemplates[FORMATS_NUM] = { 177 { CF_ENHMETAFILE, NULL, 0, -1, TYMED_ENHMF }, 178 { CF_METAFILEPICT, NULL, 0, -1, TYMED_MFPICT }, 179 { CF_BITMAP, NULL, 0, -1, TYMED_GDI } }; 180 181 182 struct OleComponentNative_Impl { 183 ComSmart< IUnknown > m_pObj; 184 ComSmart< IOleObject > m_pOleObject; 185 ComSmart< IViewObject2 > m_pViewObject2; 186 ComSmart< IStorage > m_pIStorage; 187 FormatEtcList m_aFormatsList; 188 uno::Sequence< datatransfer::DataFlavor > m_aSupportedGraphFormats; 189 190 OleComponentNative_Impl() 191 { 192 // TODO: Extend format list 193 m_aSupportedGraphFormats.realloc( 5 ); 194 195 m_aSupportedGraphFormats[0] = datatransfer::DataFlavor( 196 ::rtl::OUString::createFromAscii( "application/x-openoffice-emf;windows_formatname=\"Image EMF\"" ), 197 ::rtl::OUString::createFromAscii( "Windows Enhanced Metafile" ), 198 getCppuType( (const uno::Sequence< sal_Int8 >*) 0 ) ); 199 200 m_aSupportedGraphFormats[1] = datatransfer::DataFlavor( 201 ::rtl::OUString::createFromAscii( "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"" ), 202 ::rtl::OUString::createFromAscii( "Windows Metafile" ), 203 getCppuType( (const uno::Sequence< sal_Int8 >*) 0 ) ); 204 205 m_aSupportedGraphFormats[2] = datatransfer::DataFlavor( 206 ::rtl::OUString::createFromAscii( "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"" ), 207 ::rtl::OUString::createFromAscii( "Bitmap" ), 208 getCppuType( (const uno::Sequence< sal_Int8 >*) 0 ) ); 209 210 m_aSupportedGraphFormats[3] = datatransfer::DataFlavor( 211 ::rtl::OUString::createFromAscii( "image/png" ), 212 ::rtl::OUString::createFromAscii( "PNG" ), 213 getCppuType( (const uno::Sequence< sal_Int8 >*) 0 ) ); 214 215 m_aSupportedGraphFormats[0] = datatransfer::DataFlavor( 216 ::rtl::OUString::createFromAscii( "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"" ), 217 ::rtl::OUString::createFromAscii( "GDIMetafile" ), 218 getCppuType( (const uno::Sequence< sal_Int8 >*) 0 ) ); 219 } 220 221 void AddSupportedFormat( const FORMATETC& aFormatEtc ); 222 223 FORMATETC* GetSupportedFormatForAspect( sal_uInt32 nRequestedAspect ); 224 225 sal_Bool ConvertDataForFlavor( const STGMEDIUM& aMedium, 226 const datatransfer::DataFlavor& aFlavor, 227 uno::Any& aResult ); 228 229 sal_Bool GraphicalFlavor( const datatransfer::DataFlavor& aFlavor ); 230 231 uno::Sequence< datatransfer::DataFlavor > GetFlavorsForAspects( sal_uInt32 nSupportedAspects ); 232 }; 233 234 //---------------------------------------------- 235 DWORD GetAspectFromFlavor( const datatransfer::DataFlavor& aFlavor ) 236 { 237 if ( aFlavor.MimeType.indexOf( ::rtl::OUString::createFromAscii( ";Aspect=THUMBNAIL" ) ) != -1 ) 238 return DVASPECT_THUMBNAIL; 239 else if ( aFlavor.MimeType.indexOf( ::rtl::OUString::createFromAscii( ";Aspect=ICON" ) ) != -1 ) 240 return DVASPECT_ICON; 241 else if ( aFlavor.MimeType.indexOf( ::rtl::OUString::createFromAscii( ";Aspect=DOCPRINT" ) ) != -1 ) 242 return DVASPECT_DOCPRINT; 243 else 244 return DVASPECT_CONTENT; 245 } 246 247 //---------------------------------------------- 248 ::rtl::OUString GetFlavorSuffixFromAspect( DWORD nAsp ) 249 { 250 ::rtl::OUString aResult; 251 252 if ( nAsp == DVASPECT_THUMBNAIL ) 253 aResult = ::rtl::OUString::createFromAscii( ";Aspect=THUMBNAIL" ); 254 else if ( nAsp == DVASPECT_ICON ) 255 aResult = ::rtl::OUString::createFromAscii( ";Aspect=ICON" ); 256 else if ( nAsp == DVASPECT_DOCPRINT ) 257 aResult = ::rtl::OUString::createFromAscii( ";Aspect=DOCPRINT" ); 258 259 // no suffix for DVASPECT_CONTENT 260 261 return aResult; 262 } 263 264 //---------------------------------------------- 265 HRESULT OpenIStorageFromURL_Impl( const ::rtl::OUString& aURL, IStorage** ppIStorage ) 266 { 267 OSL_ENSURE( ppIStorage, "The pointer must not be empty!" ); 268 269 ::rtl::OUString aFilePath; 270 if ( !ppIStorage || ::osl::FileBase::getSystemPathFromFileURL( aURL, aFilePath ) != ::osl::FileBase::E_None ) 271 throw uno::RuntimeException(); // TODO: something dangerous happened 272 273 return StgOpenStorage( reinterpret_cast<LPCWSTR>(aFilePath.getStr()), 274 NULL, 275 STGM_READWRITE | STGM_TRANSACTED, // | STGM_DELETEONRELEASE, 276 NULL, 277 0, 278 ppIStorage ); 279 } 280 281 //---------------------------------------------- 282 sal_Bool OleComponentNative_Impl::ConvertDataForFlavor( const STGMEDIUM& aMedium, 283 const datatransfer::DataFlavor& aFlavor, 284 uno::Any& aResult ) 285 { 286 sal_Bool bAnyIsReady = sal_False; 287 288 // try to convert data from Medium format to specified Flavor format 289 if ( aFlavor.DataType == getCppuType( ( const uno::Sequence< sal_Int8 >* ) 0 ) ) 290 { 291 // first the GDI-metafile must be generated 292 293 unsigned char* pBuf = NULL; 294 sal_uInt32 nBufSize = 0; 295 ::rtl::OUString aFormat; 296 297 if ( aMedium.tymed == TYMED_MFPICT ) // Win Metafile 298 { 299 aFormat = ::rtl::OUString::createFromAscii("image/x-wmf"); 300 METAFILEPICT* pMF = ( METAFILEPICT* )GlobalLock( aMedium.hMetaFilePict ); 301 if ( pMF ) 302 { 303 nBufSize = GetMetaFileBitsEx( pMF->hMF, 0, NULL ) + 22; 304 pBuf = new unsigned char[nBufSize]; 305 306 307 // TODO/LATER: the unit size must be calculated correctly 308 *( (long* )pBuf ) = 0x9ac6cdd7L; 309 *( (short* )( pBuf+6 )) = ( SHORT ) 0; 310 *( (short* )( pBuf+8 )) = ( SHORT ) 0; 311 *( (short* )( pBuf+10 )) = ( SHORT ) pMF->xExt; 312 *( (short* )( pBuf+12 )) = ( SHORT ) pMF->yExt; 313 *( (short* )( pBuf+14 )) = ( USHORT ) 2540; 314 315 316 if ( nBufSize && nBufSize == GetMetaFileBitsEx( pMF->hMF, nBufSize - 22, pBuf + 22 ) ) 317 { 318 if ( aFlavor.MimeType.matchAsciiL( "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"", 57 ) ) 319 { 320 aResult <<= uno::Sequence< sal_Int8 >( ( sal_Int8* )pBuf, nBufSize ); 321 bAnyIsReady = sal_True; 322 } 323 } 324 325 GlobalUnlock( aMedium.hMetaFilePict ); 326 } 327 } 328 else if ( aMedium.tymed == TYMED_ENHMF ) // Enh Metafile 329 { 330 aFormat = ::rtl::OUString::createFromAscii("image/x-emf"); 331 nBufSize = GetEnhMetaFileBits( aMedium.hEnhMetaFile, 0, NULL ); 332 pBuf = new unsigned char[nBufSize]; 333 if ( nBufSize && nBufSize == GetEnhMetaFileBits( aMedium.hEnhMetaFile, nBufSize, pBuf ) ) 334 { 335 if ( aFlavor.MimeType.matchAsciiL( "application/x-openoffice-emf;windows_formatname=\"Image EMF\"", 57 ) ) 336 { 337 aResult <<= uno::Sequence< sal_Int8 >( ( sal_Int8* )pBuf, nBufSize ); 338 bAnyIsReady = sal_True; 339 } 340 } 341 } 342 else if ( aMedium.tymed == TYMED_GDI ) // Bitmap 343 { 344 aFormat = ::rtl::OUString::createFromAscii("image/x-MS-bmp"); 345 nBufSize = GetBitmapBits( aMedium.hBitmap, 0, NULL ); 346 pBuf = new unsigned char[nBufSize]; 347 if ( nBufSize && nBufSize == sal::static_int_cast< ULONG >( GetBitmapBits( aMedium.hBitmap, nBufSize, pBuf ) ) ) 348 { 349 if ( aFlavor.MimeType.matchAsciiL( "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"", 54 ) ) 350 { 351 aResult <<= uno::Sequence< sal_Int8 >( ( sal_Int8* )pBuf, nBufSize ); 352 bAnyIsReady = sal_True; 353 } 354 } 355 } 356 357 if ( pBuf && !bAnyIsReady ) 358 { 359 for ( sal_Int32 nInd = 0; nInd < m_aSupportedGraphFormats.getLength(); nInd++ ) 360 if ( aFlavor.MimeType.match( m_aSupportedGraphFormats[nInd].MimeType ) 361 && aFlavor.DataType == m_aSupportedGraphFormats[nInd].DataType 362 && aFlavor.DataType == getCppuType( (const uno::Sequence< sal_Int8 >*) 0 ) ) 363 { 364 bAnyIsReady = ConvertBufferToFormat( ( void* )pBuf, nBufSize, aFormat, aResult ); 365 break; 366 } 367 } 368 369 delete[] pBuf; 370 } 371 372 return bAnyIsReady; 373 } 374 375 //---------------------------------------------- 376 sal_Bool OleComponentNative_Impl::GraphicalFlavor( const datatransfer::DataFlavor& aFlavor ) 377 { 378 // Actually all the required graphical formats must be supported 379 for ( sal_Int32 nInd = 0; nInd < m_aSupportedGraphFormats.getLength(); nInd++ ) 380 if ( aFlavor.MimeType.match( m_aSupportedGraphFormats[nInd].MimeType ) 381 && aFlavor.DataType == m_aSupportedGraphFormats[nInd].DataType ) 382 return sal_True; 383 384 return sal_False; 385 } 386 387 //---------------------------------------------- 388 sal_Bool GetClassIDFromSequence_Impl( uno::Sequence< sal_Int8 > aSeq, CLSID& aResult ) 389 { 390 if ( aSeq.getLength() == 16 ) 391 { 392 aResult.Data1 = ( ( ( ( ( ( sal_uInt8 )aSeq[0] << 8 ) + ( sal_uInt8 )aSeq[1] ) << 8 ) + ( sal_uInt8 )aSeq[2] ) << 8 ) + ( sal_uInt8 )aSeq[3]; 393 aResult.Data2 = ( ( sal_uInt8 )aSeq[4] << 8 ) + ( sal_uInt8 )aSeq[5]; 394 aResult.Data3 = ( ( sal_uInt8 )aSeq[6] << 8 ) + ( sal_uInt8 )aSeq[7]; 395 for( int nInd = 0; nInd < 8; nInd++ ) 396 aResult.Data4[nInd] = ( sal_uInt8 )aSeq[nInd+8]; 397 398 return sal_True; 399 } 400 401 return sal_False; 402 } 403 404 //---------------------------------------------- 405 ::rtl::OUString WinAccToVcl_Impl( const sal_Unicode* pStr ) 406 { 407 ::rtl::OUString aResult; 408 409 if( pStr ) 410 { 411 while ( *pStr ) 412 { 413 if ( *pStr == '&' ) 414 { 415 aResult += ::rtl::OUString::createFromAscii( "~" ); 416 while( *( ++pStr ) == '&' ); 417 } 418 else 419 { 420 aResult += ::rtl::OUString( pStr, 1 ); 421 pStr++; 422 } 423 } 424 } 425 426 return aResult; 427 } 428 429 //---------------------------------------------- 430 OleComponent::OleComponent( const uno::Reference< lang::XMultiServiceFactory >& xFactory, OleEmbeddedObject* pUnoOleObject ) 431 : m_pInterfaceContainer( NULL ) 432 , m_bDisposed( sal_False ) 433 , m_bModified( sal_False ) 434 , m_pNativeImpl( new OleComponentNative_Impl() ) 435 , m_xFactory( xFactory ) 436 , m_pOleWrapClientSite( NULL ) 437 , m_pImplAdviseSink( NULL ) 438 , m_pUnoOleObject( pUnoOleObject ) 439 , m_nOLEMiscFlags( 0 ) 440 , m_nAdvConn( 0 ) 441 , m_bOleInitialized( sal_False ) 442 , m_bWorkaroundActive( sal_False ) 443 { 444 OSL_ENSURE( m_pUnoOleObject, "No owner object is provided!" ); 445 446 HRESULT hr = OleInitialize( NULL ); 447 OSL_ENSURE( hr == S_OK || hr == S_FALSE, "The ole can not be successfuly initialized\n" ); 448 if ( hr == S_OK || hr == S_FALSE ) 449 m_bOleInitialized = sal_True; 450 451 m_pOleWrapClientSite = new OleWrapperClientSite( ( OleComponent* )this ); 452 m_pOleWrapClientSite->AddRef(); 453 454 m_pImplAdviseSink = new OleWrapperAdviseSink( ( OleComponent* )this ); 455 m_pImplAdviseSink->AddRef(); 456 457 } 458 459 //---------------------------------------------- 460 OleComponent::~OleComponent() 461 { 462 OSL_ENSURE( !m_pOleWrapClientSite && !m_pImplAdviseSink && !m_pInterfaceContainer && !m_bOleInitialized, 463 "The object was not closed successfully! DISASTER is possible!" ); 464 465 if ( m_pOleWrapClientSite || m_pImplAdviseSink || m_pInterfaceContainer || m_bOleInitialized ) 466 { 467 ::osl::MutexGuard aGuard( m_aMutex ); 468 m_refCount++; 469 try { 470 Dispose(); 471 } catch( uno::Exception& ) {} 472 } 473 474 for ( FormatEtcList::iterator aIter = m_pNativeImpl->m_aFormatsList.begin(); 475 aIter != m_pNativeImpl->m_aFormatsList.end(); 476 aIter++ ) 477 { 478 delete (*aIter); 479 (*aIter) = NULL; 480 } 481 m_pNativeImpl->m_aFormatsList.clear(); 482 483 delete m_pNativeImpl; 484 } 485 486 //---------------------------------------------- 487 void OleComponentNative_Impl::AddSupportedFormat( const FORMATETC& aFormatEtc ) 488 { 489 FORMATETC* pFormatToInsert = new FORMATETC( aFormatEtc ); 490 m_aFormatsList.push_back( pFormatToInsert ); 491 } 492 493 //---------------------------------------------- 494 FORMATETC* OleComponentNative_Impl::GetSupportedFormatForAspect( sal_uInt32 nRequestedAspect ) 495 { 496 for ( FormatEtcList::iterator aIter = m_aFormatsList.begin(); 497 aIter != m_aFormatsList.end(); 498 aIter++ ) 499 if ( (*aIter) && (*aIter)->dwAspect == nRequestedAspect ) 500 return (*aIter); 501 502 return NULL; 503 } 504 505 //---------------------------------------------- 506 void OleComponent::Dispose() 507 { 508 // the mutex must be locked before this method is called 509 if ( m_bDisposed ) 510 return; 511 512 CloseObject(); 513 514 if ( m_pOleWrapClientSite ) 515 { 516 m_pOleWrapClientSite->disconnectOleComponent(); 517 m_pOleWrapClientSite->Release(); 518 m_pOleWrapClientSite = NULL; 519 } 520 521 if ( m_pImplAdviseSink ) 522 { 523 m_pImplAdviseSink->disconnectOleComponent(); 524 m_pImplAdviseSink->Release(); 525 m_pImplAdviseSink = NULL; 526 } 527 528 if ( m_pInterfaceContainer ) 529 { 530 lang::EventObject aEvent( static_cast< ::cppu::OWeakObject* >( this ) ); 531 m_pInterfaceContainer->disposeAndClear( aEvent ); 532 533 delete m_pInterfaceContainer; 534 m_pInterfaceContainer = NULL; 535 } 536 537 if ( m_bOleInitialized ) 538 { 539 // since the disposing can happen not only from main thread but also from a clipboard 540 // the deinitialization might lead to a disaster, SO7 does not deinitialize OLE at all 541 // so currently the same approach is selected as workaround 542 // OleUninitialize(); 543 m_bOleInitialized = sal_False; 544 } 545 546 m_bDisposed = sal_True; 547 } 548 549 //---------------------------------------------- 550 void OleComponent::disconnectEmbeddedObject() 551 { 552 // must not be called from destructor of UNO OLE object!!! 553 osl::MutexGuard aGuard( m_aMutex ); 554 m_pUnoOleObject = NULL; 555 } 556 557 //---------------------------------------------- 558 void OleComponent::CreateNewIStorage_Impl() 559 { 560 // TODO: in future a global memory could be used instead of file. 561 562 // write the stream to the temporary file 563 ::rtl::OUString aTempURL; 564 565 OSL_ENSURE( m_pUnoOleObject, "Unexpected object absence!" ); 566 if ( m_pUnoOleObject ) 567 aTempURL = m_pUnoOleObject->CreateTempURLEmpty_Impl(); 568 else 569 aTempURL = GetNewTempFileURL_Impl( m_xFactory ); 570 571 if ( !aTempURL.getLength() ) 572 throw uno::RuntimeException(); // TODO 573 574 // open an IStorage based on the temporary file 575 ::rtl::OUString aTempFilePath; 576 if ( ::osl::FileBase::getSystemPathFromFileURL( aTempURL, aTempFilePath ) != ::osl::FileBase::E_None ) 577 throw uno::RuntimeException(); // TODO: something dangerous happened 578 579 HRESULT hr = StgCreateDocfile( reinterpret_cast<LPCWSTR>(aTempFilePath.getStr()), STGM_CREATE | STGM_READWRITE | STGM_TRANSACTED | STGM_DELETEONRELEASE, 0, &m_pNativeImpl->m_pIStorage ); 580 if ( FAILED( hr ) || !m_pNativeImpl->m_pIStorage ) 581 throw io::IOException(); // TODO: transport error code? 582 } 583 584 //---------------------------------------------- 585 uno::Sequence< datatransfer::DataFlavor > OleComponentNative_Impl::GetFlavorsForAspects( sal_uInt32 nSupportedAspects ) 586 { 587 uno::Sequence< datatransfer::DataFlavor > aResult; 588 for ( sal_uInt32 nAsp = 1; nAsp <= 8; nAsp *= 2 ) 589 if ( ( nSupportedAspects & nAsp ) == nAsp ) 590 { 591 ::rtl::OUString aAspectSuffix = GetFlavorSuffixFromAspect( nAsp ); 592 593 sal_Int32 nLength = aResult.getLength(); 594 aResult.realloc( nLength + m_aSupportedGraphFormats.getLength() ); 595 596 for ( sal_Int32 nInd = 0; nInd < m_aSupportedGraphFormats.getLength(); nInd++ ) 597 { 598 aResult[nLength + nInd].MimeType = m_aSupportedGraphFormats[nInd].MimeType + aAspectSuffix; 599 aResult[nLength + nInd].HumanPresentableName = m_aSupportedGraphFormats[nInd].HumanPresentableName; 600 aResult[nLength + nInd].DataType = m_aSupportedGraphFormats[nInd].DataType; 601 } 602 } 603 604 return aResult; 605 } 606 607 //---------------------------------------------- 608 void OleComponent::RetrieveObjectDataFlavors_Impl() 609 { 610 if ( !m_pNativeImpl->m_pOleObject ) 611 throw embed::WrongStateException(); // TODO: the object is in wrong state 612 613 if ( !m_aDataFlavors.getLength() ) 614 { 615 ComSmart< IDataObject > pDataObject; 616 HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, (void**)&pDataObject ); 617 if ( SUCCEEDED( hr ) && pDataObject ) 618 { 619 ComSmart< IEnumFORMATETC > pFormatEnum; 620 hr = pDataObject->EnumFormatEtc( DATADIR_GET, &pFormatEnum ); 621 if ( SUCCEEDED( hr ) && pFormatEnum ) 622 { 623 FORMATETC pElem[ MAX_ENUM_ELE ]; 624 ULONG nNum = 0; 625 626 // if it is possible to retrieve at least one supported graphical format for an aspect 627 // this format can be converted to other supported formats 628 sal_uInt32 nSupportedAspects = 0; 629 do 630 { 631 HRESULT hr = pFormatEnum->Next( MAX_ENUM_ELE, pElem, &nNum ); 632 if( hr == S_OK || hr == S_FALSE ) 633 { 634 for( sal_uInt32 nInd = 0; nInd < FORMATS_NUM; nInd++ ) 635 { 636 if ( pElem[nInd].cfFormat == pFormatTemplates[nInd].cfFormat 637 && pElem[nInd].tymed == pFormatTemplates[nInd].tymed ) 638 nSupportedAspects |= pElem[nInd].dwAspect; 639 } 640 } 641 else 642 break; 643 } 644 while( nNum == MAX_ENUM_ELE ); 645 646 m_aDataFlavors = m_pNativeImpl->GetFlavorsForAspects( nSupportedAspects ); 647 } 648 } 649 650 if ( !m_aDataFlavors.getLength() ) 651 { 652 // TODO: 653 // for any reason the object could not provide this information 654 // try to get access to the cached representation 655 } 656 } 657 } 658 659 //---------------------------------------------- 660 sal_Bool OleComponent::InitializeObject_Impl() 661 // There will be no static objects! 662 { 663 if ( !m_pNativeImpl->m_pObj ) 664 return sal_False; 665 666 // the linked object will be detected here 667 ComSmart< IOleLink > pOleLink; 668 HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IOleLink, (void**)&pOleLink ); 669 OSL_ENSURE( m_pUnoOleObject, "Unexpected object absence!" ); 670 if ( m_pUnoOleObject ) 671 m_pUnoOleObject->SetObjectIsLink_Impl( sal_Bool( pOleLink != NULL ) ); 672 673 674 hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IViewObject2, (void**)&m_pNativeImpl->m_pViewObject2 ); 675 if ( FAILED( hr ) || !m_pNativeImpl->m_pViewObject2 ) 676 return sal_False; 677 678 // not really needed for now, since object is updated on saving 679 // m_pNativeImpl->m_pViewObject2->SetAdvise( DVASPECT_CONTENT, 0, m_pImplAdviseSink ); 680 681 // remove all the caches 682 IOleCache* pIOleCache = NULL; 683 if ( SUCCEEDED( m_pNativeImpl->m_pObj->QueryInterface( IID_IOleCache, (void**)&pIOleCache ) ) && pIOleCache ) 684 { 685 IEnumSTATDATA* pEnumSD = NULL; 686 HRESULT hr = pIOleCache->EnumCache( &pEnumSD ); 687 688 if ( SUCCEEDED( hr ) && pEnumSD ) 689 { 690 pEnumSD->Reset(); 691 STATDATA aSD; 692 DWORD nNum; 693 while( SUCCEEDED( pEnumSD->Next( 1, &aSD, &nNum ) ) && nNum == 1 ) 694 hr = pIOleCache->Uncache( aSD.dwConnection ); 695 } 696 697 // No IDataObject implementation, caching must be used instead 698 DWORD nConn; 699 FORMATETC aFormat = { 0, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT }; 700 hr = pIOleCache->Cache( &aFormat, ADVFCACHE_ONSAVE, &nConn ); 701 702 pIOleCache->Release(); 703 pIOleCache = NULL; 704 } 705 706 hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IOleObject, (void**)&m_pNativeImpl->m_pOleObject ); 707 if ( FAILED( hr ) || !m_pNativeImpl->m_pOleObject ) 708 return sal_False; // Static objects are not supported, they should be inserted as graphics 709 710 m_pNativeImpl->m_pOleObject->GetMiscStatus( DVASPECT_CONTENT, ( DWORD* )&m_nOLEMiscFlags ); 711 // TODO: use other misc flags also 712 // the object should have drawable aspect even in case it supports only iconic representation 713 // if ( m_nOLEMiscFlags & OLEMISC_ONLYICONIC ) 714 715 m_pNativeImpl->m_pOleObject->SetClientSite( m_pOleWrapClientSite ); 716 717 // the only need in this registration is workaround for close notification 718 m_pNativeImpl->m_pOleObject->Advise( m_pImplAdviseSink, ( DWORD* )&m_nAdvConn ); 719 m_pNativeImpl->m_pViewObject2->SetAdvise( DVASPECT_CONTENT, 0, m_pImplAdviseSink ); 720 721 OleSetContainedObject( m_pNativeImpl->m_pOleObject, TRUE ); 722 723 return sal_True; 724 } 725 726 //---------------------------------------------- 727 void OleComponent::LoadEmbeddedObject( const ::rtl::OUString& aTempURL ) 728 { 729 if ( !aTempURL.getLength() ) 730 throw lang::IllegalArgumentException(); // TODO 731 732 if ( m_pNativeImpl->m_pIStorage ) 733 throw io::IOException(); // TODO the object is already initialized or wrong initialization is done 734 735 // open an IStorage based on the temporary file 736 HRESULT hr = OpenIStorageFromURL_Impl( aTempURL, &m_pNativeImpl->m_pIStorage ); 737 738 if ( FAILED( hr ) || !m_pNativeImpl->m_pIStorage ) 739 throw io::IOException(); // TODO: transport error code? 740 741 hr = OleLoad( m_pNativeImpl->m_pIStorage, IID_IUnknown, NULL, (void**)&m_pNativeImpl->m_pObj ); 742 if ( FAILED( hr ) || !m_pNativeImpl->m_pObj ) 743 { 744 // STATSTG aStat; 745 // m_pNativeImpl->m_pIStorage->Stat( &aStat, STATFLAG_NONAME ); 746 throw uno::RuntimeException(); 747 } 748 749 if ( !InitializeObject_Impl() ) 750 throw uno::RuntimeException(); // TODO 751 } 752 753 //---------------------------------------------- 754 void OleComponent::CreateObjectFromClipboard() 755 { 756 if ( m_pNativeImpl->m_pIStorage ) 757 throw io::IOException(); // TODO:the object is already initialized 758 759 CreateNewIStorage_Impl(); 760 if ( !m_pNativeImpl->m_pIStorage ) 761 throw uno::RuntimeException(); // TODO 762 763 IDataObject * pDO = NULL; 764 HRESULT hr = OleGetClipboard( &pDO ); 765 if( SUCCEEDED( hr ) && pDO ) 766 { 767 hr = OleQueryCreateFromData( pDO ); 768 if( S_OK == GetScode( hr ) ) 769 { 770 hr = OleCreateFromData( pDO, 771 IID_IUnknown, 772 OLERENDER_DRAW, // OLERENDER_FORMAT 773 NULL, // &aFormat, 774 NULL, 775 m_pNativeImpl->m_pIStorage, 776 (void**)&m_pNativeImpl->m_pObj ); 777 } 778 else 779 { 780 // Static objects are not supported 781 pDO->Release(); 782 } 783 } 784 785 if ( FAILED( hr ) || !m_pNativeImpl->m_pObj ) 786 throw uno::RuntimeException(); 787 788 if ( !InitializeObject_Impl() ) 789 throw uno::RuntimeException(); // TODO 790 } 791 792 //---------------------------------------------- 793 void OleComponent::CreateNewEmbeddedObject( const uno::Sequence< sal_Int8 >& aSeqCLSID ) 794 { 795 CLSID aClsID; 796 797 if ( !GetClassIDFromSequence_Impl( aSeqCLSID, aClsID ) ) 798 throw lang::IllegalArgumentException(); // TODO 799 800 if ( m_pNativeImpl->m_pIStorage ) 801 throw io::IOException(); // TODO:the object is already initialized 802 803 CreateNewIStorage_Impl(); 804 if ( !m_pNativeImpl->m_pIStorage ) 805 throw uno::RuntimeException(); // TODO 806 807 // FORMATETC aFormat = { CF_METAFILEPICT, NULL, nAspect, -1, TYMED_MFPICT }; // for OLE..._DRAW should be NULL 808 809 HRESULT hr = OleCreate( aClsID, 810 IID_IUnknown, 811 OLERENDER_DRAW, // OLERENDER_FORMAT 812 NULL, // &aFormat, 813 NULL, 814 m_pNativeImpl->m_pIStorage, 815 (void**)&m_pNativeImpl->m_pObj ); 816 817 if ( FAILED( hr ) || !m_pNativeImpl->m_pObj ) 818 throw uno::RuntimeException(); // TODO 819 820 if ( !InitializeObject_Impl() ) 821 throw uno::RuntimeException(); // TODO 822 823 // TODO: getExtent??? 824 } 825 826 //---------------------------------------------- 827 void OleComponent::CreateObjectFromData( const uno::Reference< datatransfer::XTransferable >& ) 828 // Static objects are not supported, they should be inserted as graphics 829 { 830 // TODO: May be this call is useless since there are no static objects 831 // and nonstatic objects will be created based on OLEstorage ( stream ). 832 // ??? 833 834 // OleQueryCreateFromData... 835 } 836 837 //---------------------------------------------- 838 void OleComponent::CreateObjectFromFile( const ::rtl::OUString& aFileURL ) 839 { 840 if ( m_pNativeImpl->m_pIStorage ) 841 throw io::IOException(); // TODO:the object is already initialized 842 843 CreateNewIStorage_Impl(); 844 if ( !m_pNativeImpl->m_pIStorage ) 845 throw uno::RuntimeException(); // TODO: 846 847 ::rtl::OUString aFilePath; 848 if ( ::osl::FileBase::getSystemPathFromFileURL( aFileURL, aFilePath ) != ::osl::FileBase::E_None ) 849 throw uno::RuntimeException(); // TODO: something dangerous happened 850 851 HRESULT hr = OleCreateFromFile( CLSID_NULL, 852 reinterpret_cast<LPCWSTR>(aFilePath.getStr()), 853 IID_IUnknown, 854 OLERENDER_DRAW, // OLERENDER_FORMAT 855 NULL, 856 NULL, 857 m_pNativeImpl->m_pIStorage, 858 (void**)&m_pNativeImpl->m_pObj ); 859 860 if ( FAILED( hr ) || !m_pNativeImpl->m_pObj ) 861 throw uno::RuntimeException(); // TODO 862 863 if ( !InitializeObject_Impl() ) 864 throw uno::RuntimeException(); // TODO 865 } 866 867 //---------------------------------------------- 868 void OleComponent::CreateLinkFromFile( const ::rtl::OUString& aFileURL ) 869 { 870 if ( m_pNativeImpl->m_pIStorage ) 871 throw io::IOException(); // TODO:the object is already initialized 872 873 CreateNewIStorage_Impl(); 874 if ( !m_pNativeImpl->m_pIStorage ) 875 throw uno::RuntimeException(); // TODO: 876 877 ::rtl::OUString aFilePath; 878 if ( ::osl::FileBase::getSystemPathFromFileURL( aFileURL, aFilePath ) != ::osl::FileBase::E_None ) 879 throw uno::RuntimeException(); // TODO: something dangerous happened 880 881 HRESULT hr = OleCreateLinkToFile( reinterpret_cast<LPCWSTR>(aFilePath.getStr()), 882 IID_IUnknown, 883 OLERENDER_DRAW, // OLERENDER_FORMAT 884 NULL, 885 NULL, 886 m_pNativeImpl->m_pIStorage, 887 (void**)&m_pNativeImpl->m_pObj ); 888 889 if ( FAILED( hr ) || !m_pNativeImpl->m_pObj ) 890 throw uno::RuntimeException(); // TODO 891 892 if ( !InitializeObject_Impl() ) 893 throw uno::RuntimeException(); // TODO 894 } 895 896 //---------------------------------------------- 897 void OleComponent::InitEmbeddedCopyOfLink( OleComponent* pOleLinkComponent ) 898 { 899 if ( !pOleLinkComponent || !pOleLinkComponent->m_pNativeImpl->m_pObj ) 900 throw lang::IllegalArgumentException(); // TODO 901 902 if ( m_pNativeImpl->m_pIStorage ) 903 throw io::IOException(); // TODO:the object is already initialized 904 905 ComSmart< IDataObject > pDataObject; 906 HRESULT hr = pOleLinkComponent->m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, (void**)&pDataObject ); 907 if ( SUCCEEDED( hr ) && pDataObject && SUCCEEDED( OleQueryCreateFromData( pDataObject ) ) ) 908 { 909 // the object must be already disconnected from the temporary URL 910 CreateNewIStorage_Impl(); 911 if ( !m_pNativeImpl->m_pIStorage ) 912 throw uno::RuntimeException(); // TODO: 913 914 hr = OleCreateFromData( pDataObject, 915 IID_IUnknown, 916 OLERENDER_DRAW, 917 NULL, 918 NULL, 919 m_pNativeImpl->m_pIStorage, 920 (void**)&m_pNativeImpl->m_pObj ); 921 } 922 923 if ( !m_pNativeImpl->m_pObj ) 924 { 925 ComSmart< IOleLink > pOleLink; 926 hr = pOleLinkComponent->m_pNativeImpl->m_pObj->QueryInterface( IID_IOleLink, (void**)&pOleLink ); 927 if ( FAILED( hr ) || !pOleLink ) 928 throw io::IOException(); // TODO: the object doesn't support IOleLink 929 930 ComSmart< IMoniker > pMoniker; 931 hr = pOleLink->GetSourceMoniker( &pMoniker ); 932 if ( FAILED( hr ) || !pMoniker ) 933 throw io::IOException(); // TODO: can not retrieve moniker 934 935 // In case of file moniker life is easy : ) 936 DWORD aMonType = 0; 937 hr = pMoniker->IsSystemMoniker( &aMonType ); 938 if ( SUCCEEDED( hr ) && aMonType == MKSYS_FILEMONIKER ) 939 { 940 ComSmart< IMalloc > pMalloc; 941 CoGetMalloc( 1, &pMalloc ); // if fails there will be a memory leak 942 OSL_ENSURE( pMalloc, "CoGetMalloc() failed!" ); 943 944 LPOLESTR pOleStr = NULL; 945 hr = pOleLink->GetSourceDisplayName( &pOleStr ); 946 if ( SUCCEEDED( hr ) && pOleStr ) 947 { 948 ::rtl::OUString aFilePath( ( sal_Unicode* )pOleStr ); 949 if ( pMalloc ) 950 pMalloc->Free( ( void* )pOleStr ); 951 952 hr = OleCreateFromFile( CLSID_NULL, 953 reinterpret_cast<LPCWSTR>(aFilePath.getStr()), 954 IID_IUnknown, 955 OLERENDER_DRAW, // OLERENDER_FORMAT 956 NULL, 957 NULL, 958 m_pNativeImpl->m_pIStorage, 959 (void**)&m_pNativeImpl->m_pObj ); 960 } 961 } 962 963 // in case of other moniker types the only way is to get storage 964 if ( !m_pNativeImpl->m_pObj ) 965 { 966 ComSmart< IBindCtx > pBindCtx; 967 hr = CreateBindCtx( 0, ( LPBC FAR* )&pBindCtx ); 968 if ( SUCCEEDED( hr ) && pBindCtx ) 969 { 970 ComSmart< IStorage > pObjectStorage; 971 hr = pMoniker->BindToStorage( pBindCtx, NULL, IID_IStorage, (void**)&pObjectStorage ); 972 if ( SUCCEEDED( hr ) && pObjectStorage ) 973 { 974 hr = pObjectStorage->CopyTo( 0, NULL, NULL, m_pNativeImpl->m_pIStorage ); 975 if ( SUCCEEDED( hr ) ) 976 hr = OleLoad( m_pNativeImpl->m_pIStorage, IID_IUnknown, NULL, (void**)&m_pNativeImpl->m_pObj ); 977 } 978 } 979 } 980 } 981 982 // If object could not be created the only way is to use graphical representation 983 if ( FAILED( hr ) || !m_pNativeImpl->m_pObj ) 984 throw uno::RuntimeException(); // TODO 985 986 if ( !InitializeObject_Impl() ) 987 throw uno::RuntimeException(); // TODO 988 } 989 990 //---------------------------------------------- 991 void OleComponent::RunObject() 992 { 993 OSL_ENSURE( m_pNativeImpl->m_pOleObject, "The pointer can not be set to NULL here!\n" ); 994 if ( !m_pNativeImpl->m_pOleObject ) 995 throw embed::WrongStateException(); // TODO: the object is in wrong state 996 997 if ( !OleIsRunning( m_pNativeImpl->m_pOleObject ) ) 998 { 999 HRESULT hr = S_OK; 1000 try 1001 { 1002 hr = OleRun( m_pNativeImpl->m_pObj ); 1003 } 1004 catch( ... ) 1005 { 1006 int i = 0; 1007 i++; 1008 } 1009 1010 if ( FAILED( hr ) ) 1011 { 1012 if ( hr == REGDB_E_CLASSNOTREG ) 1013 throw embed::UnreachableStateException(); // the object server is not installed 1014 else 1015 throw io::IOException(); 1016 } 1017 } 1018 } 1019 1020 //---------------------------------------------- 1021 awt::Size OleComponent::CalculateWithFactor( const awt::Size& aSize, 1022 const awt::Size& aMultiplier, 1023 const awt::Size& aDivisor ) 1024 { 1025 awt::Size aResult; 1026 1027 sal_Int64 nWidth = (sal_Int64)aSize.Width * (sal_Int64)aMultiplier.Width / (sal_Int64)aDivisor.Width; 1028 sal_Int64 nHeight = (sal_Int64)aSize.Height * (sal_Int64)aMultiplier.Height / (sal_Int64)aDivisor.Height; 1029 OSL_ENSURE( nWidth < SAL_MAX_INT32 && nWidth > SAL_MIN_INT32 1030 && nHeight < SAL_MAX_INT32 && nHeight > SAL_MIN_INT32, 1031 "Unacceptable result size!" ); 1032 1033 aResult.Width = (sal_Int32)nWidth; 1034 aResult.Height = (sal_Int32)nHeight; 1035 1036 return aResult; 1037 } 1038 1039 //---------------------------------------------- 1040 void OleComponent::CloseObject() 1041 { 1042 if ( m_pNativeImpl->m_pOleObject && OleIsRunning( m_pNativeImpl->m_pOleObject ) ) 1043 m_pNativeImpl->m_pOleObject->Close( OLECLOSE_NOSAVE ); // must be saved before 1044 } 1045 1046 //---------------------------------------------- 1047 uno::Sequence< embed::VerbDescriptor > OleComponent::GetVerbList() 1048 { 1049 if ( !m_pNativeImpl->m_pOleObject ) 1050 throw embed::WrongStateException(); // TODO: the object is in wrong state 1051 1052 if( !m_aVerbList.getLength() ) 1053 { 1054 ComSmart< IEnumOLEVERB > pEnum; 1055 if( SUCCEEDED( m_pNativeImpl->m_pOleObject->EnumVerbs( &pEnum ) ) ) 1056 { 1057 OLEVERB szEle[ MAX_ENUM_ELE ]; 1058 ULONG nNum = 0; 1059 sal_Int32 nSeqSize = 0; 1060 1061 do 1062 { 1063 HRESULT hr = pEnum->Next( MAX_ENUM_ELE, szEle, &nNum ); 1064 if( hr == S_OK || hr == S_FALSE ) 1065 { 1066 m_aVerbList.realloc( nSeqSize += nNum ); 1067 for( sal_uInt32 nInd = 0; nInd < nNum; nInd++ ) 1068 { 1069 m_aVerbList[nSeqSize-nNum+nInd].VerbID = szEle[ nInd ].lVerb; 1070 m_aVerbList[nSeqSize-nNum+nInd].VerbName = WinAccToVcl_Impl( reinterpret_cast<const sal_Unicode*>(szEle[ nInd ].lpszVerbName) ); 1071 m_aVerbList[nSeqSize-nNum+nInd].VerbFlags = szEle[ nInd ].fuFlags; 1072 m_aVerbList[nSeqSize-nNum+nInd].VerbAttributes = szEle[ nInd ].grfAttribs; 1073 } 1074 } 1075 else 1076 break; 1077 } 1078 while( nNum == MAX_ENUM_ELE ); 1079 } 1080 } 1081 1082 return m_aVerbList; 1083 } 1084 1085 //---------------------------------------------- 1086 void OleComponent::ExecuteVerb( sal_Int32 nVerbID ) 1087 { 1088 if ( !m_pNativeImpl->m_pOleObject ) 1089 throw embed::WrongStateException(); // TODO 1090 1091 HRESULT hr = OleRun( m_pNativeImpl->m_pOleObject ); 1092 if ( FAILED( hr ) ) 1093 throw io::IOException(); // TODO: a specific exception that transport error code can be thrown here 1094 1095 // TODO: probably extents should be set here and stored in aRect 1096 // TODO: probably the parent window also should be set 1097 hr = m_pNativeImpl->m_pOleObject->DoVerb( nVerbID, NULL, m_pOleWrapClientSite, 0, NULL, NULL ); 1098 1099 if ( FAILED( hr ) ) 1100 throw io::IOException(); // TODO 1101 1102 // TODO/LATER: the real names should be used here 1103 m_pNativeImpl->m_pOleObject->SetHostNames( L"app name", L"untitled" ); 1104 } 1105 1106 //---------------------------------------------- 1107 void OleComponent::SetHostName( const ::rtl::OUString&, 1108 const ::rtl::OUString& ) 1109 { 1110 if ( !m_pNativeImpl->m_pOleObject ) 1111 throw embed::WrongStateException(); // TODO: the object is in wrong state 1112 1113 // TODO: use aContName and aEmbDocName in m_pNativeImpl->m_pOleObject->SetHostNames() 1114 } 1115 1116 //---------------------------------------------- 1117 void OleComponent::SetExtent( const awt::Size& aVisAreaSize, sal_Int64 nAspect ) 1118 { 1119 if ( !m_pNativeImpl->m_pOleObject ) 1120 throw embed::WrongStateException(); // TODO: the object is in wrong state 1121 1122 DWORD nMSAspect = ( DWORD )nAspect; // first 32 bits are for MS aspects 1123 1124 SIZEL aSize = { aVisAreaSize.Width, aVisAreaSize.Height }; 1125 HRESULT hr = m_pNativeImpl->m_pOleObject->SetExtent( nMSAspect, &aSize ); 1126 1127 if ( FAILED( hr ) ) 1128 { 1129 // TODO/LATER: is it correct? In future user code probably should be ready for the exception. 1130 // if the object is running but not activated, RPC_E_SERVER_DIED error code is returned by OLE package 1131 // in this case just do nothing 1132 // Also Visio returns E_FAIL on resize if it is in running state 1133 // if ( hr != RPC_E_SERVER_DIED ) 1134 throw io::IOException(); // TODO 1135 } 1136 } 1137 1138 //---------------------------------------------- 1139 awt::Size OleComponent::GetExtent( sal_Int64 nAspect ) 1140 { 1141 if ( !m_pNativeImpl->m_pOleObject ) 1142 throw embed::WrongStateException(); // TODO: the object is in wrong state 1143 1144 DWORD nMSAspect = ( DWORD )nAspect; // first 32 bits are for MS aspects 1145 awt::Size aSize; 1146 sal_Bool bGotSize = sal_False; 1147 1148 if ( nMSAspect == DVASPECT_CONTENT ) 1149 { 1150 // Try to get the size from the replacement image first 1151 ComSmart< IDataObject > pDataObject; 1152 HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, (void**)&pDataObject ); 1153 if ( SUCCEEDED( hr ) || pDataObject ) 1154 { 1155 STGMEDIUM aMedium; 1156 FORMATETC aFormat = pFormatTemplates[1]; // use windows metafile format 1157 aFormat.dwAspect = nMSAspect; 1158 1159 hr = pDataObject->GetData( &aFormat, &aMedium ); 1160 if ( SUCCEEDED( hr ) && aMedium.tymed == TYMED_MFPICT ) // Win Metafile 1161 { 1162 METAFILEPICT* pMF = ( METAFILEPICT* )GlobalLock( aMedium.hMetaFilePict ); 1163 if ( pMF ) 1164 { 1165 // the object uses 0.01 mm as unit, so the metafile size should be converted to object unit 1166 sal_Int64 nMult = 1; 1167 sal_Int64 nDiv = 1; 1168 switch( pMF->mm ) 1169 { 1170 case MM_HIENGLISH: 1171 nMult = 254; 1172 nDiv = 100; 1173 break; 1174 1175 case MM_LOENGLISH: 1176 nMult = 254; 1177 nDiv = 10; 1178 break; 1179 1180 case MM_LOMETRIC: 1181 nMult = 10; 1182 break; 1183 1184 case MM_TWIPS: 1185 nMult = 254; 1186 nDiv = 144; 1187 break; 1188 1189 case MM_ISOTROPIC: 1190 case MM_ANISOTROPIC: 1191 case MM_HIMETRIC: 1192 // do nothing 1193 break; 1194 } 1195 1196 sal_Int64 nX = ( (sal_Int64)abs( pMF->xExt ) ) * nMult / nDiv; 1197 sal_Int64 nY = ( (sal_Int64)abs( pMF->yExt ) ) * nMult / nDiv; 1198 if ( nX < SAL_MAX_INT32 && nY < SAL_MAX_INT32 ) 1199 { 1200 aSize.Width = ( sal_Int32 )nX; 1201 aSize.Height = ( sal_Int32 )nY; 1202 bGotSize = sal_True; 1203 } 1204 else 1205 OSL_ENSURE( sal_False, "Unexpected size is provided!" ); 1206 } 1207 } 1208 // i113605, to release storge medium 1209 if ( SUCCEEDED( hr ) ) 1210 ::ReleaseStgMedium(&aMedium); 1211 } 1212 } 1213 1214 if ( !bGotSize ) 1215 throw lang::IllegalArgumentException(); 1216 1217 return aSize; 1218 } 1219 1220 //---------------------------------------------- 1221 awt::Size OleComponent::GetCachedExtent( sal_Int64 nAspect ) 1222 { 1223 if ( !m_pNativeImpl->m_pOleObject ) 1224 throw embed::WrongStateException(); // TODO: the object is in wrong state 1225 1226 DWORD nMSAspect = ( DWORD )nAspect; // first 32 bits are for MS aspects 1227 SIZEL aSize; 1228 1229 HRESULT hr = m_pNativeImpl->m_pViewObject2->GetExtent( nMSAspect, -1, NULL, &aSize ); 1230 1231 if ( FAILED( hr ) ) 1232 { 1233 // TODO/LATER: is it correct? 1234 // if there is no appropriate cache for the aspect, OLE_E_BLANK error code is returned 1235 // if ( hr == OLE_E_BLANK ) 1236 // throw lang::IllegalArgumentException(); 1237 //else 1238 // throw io::IOException(); // TODO 1239 1240 throw lang::IllegalArgumentException(); 1241 } 1242 1243 return awt::Size( aSize.cx, aSize.cy ); 1244 } 1245 1246 //---------------------------------------------- 1247 awt::Size OleComponent::GetReccomendedExtent( sal_Int64 nAspect ) 1248 { 1249 if ( !m_pNativeImpl->m_pOleObject ) 1250 throw embed::WrongStateException(); // TODO: the object is in wrong state 1251 1252 DWORD nMSAspect = ( DWORD )nAspect; // first 32 bits are for MS aspects 1253 SIZEL aSize; 1254 HRESULT hr = m_pNativeImpl->m_pOleObject->GetExtent( nMSAspect, &aSize ); 1255 if ( FAILED( hr ) ) 1256 throw lang::IllegalArgumentException(); 1257 1258 return awt::Size( aSize.cx, aSize.cy ); 1259 } 1260 1261 //---------------------------------------------- 1262 sal_Int64 OleComponent::GetMiscStatus( sal_Int64 nAspect ) 1263 { 1264 if ( !m_pNativeImpl->m_pOleObject ) 1265 throw embed::WrongStateException(); // TODO: the object is in wrong state 1266 1267 sal_uInt32 nResult; 1268 m_pNativeImpl->m_pOleObject->GetMiscStatus( ( DWORD )nAspect, ( DWORD* )&nResult ); 1269 return ( sal_Int64 )nResult; // first 32 bits are for MS flags 1270 } 1271 1272 //---------------------------------------------- 1273 uno::Sequence< sal_Int8 > OleComponent::GetCLSID() 1274 { 1275 if ( !m_pNativeImpl->m_pOleObject ) 1276 throw embed::WrongStateException(); // TODO: the object is in wrong state 1277 1278 GUID aCLSID; 1279 HRESULT hr = m_pNativeImpl->m_pOleObject->GetUserClassID( &aCLSID ); 1280 if ( FAILED( hr ) ) 1281 throw io::IOException(); // TODO: 1282 1283 return MimeConfigurationHelper::GetSequenceClassID( aCLSID.Data1, aCLSID.Data2, aCLSID.Data3, 1284 aCLSID.Data4[0], aCLSID.Data4[1], 1285 aCLSID.Data4[2], aCLSID.Data4[3], 1286 aCLSID.Data4[4], aCLSID.Data4[5], 1287 aCLSID.Data4[6], aCLSID.Data4[7] ); 1288 } 1289 1290 //---------------------------------------------- 1291 sal_Bool OleComponent::IsDirty() 1292 { 1293 if ( !m_pNativeImpl->m_pOleObject ) 1294 throw embed::WrongStateException(); // TODO: the object is in wrong state 1295 1296 if ( IsWorkaroundActive() ) 1297 return sal_True; 1298 1299 ComSmart< IPersistStorage > pPersistStorage; 1300 HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IPersistStorage, (void**)&pPersistStorage ); 1301 if ( FAILED( hr ) || !pPersistStorage ) 1302 throw io::IOException(); // TODO 1303 1304 hr = pPersistStorage->IsDirty(); 1305 return ( hr != S_FALSE ); 1306 } 1307 1308 //---------------------------------------------- 1309 void OleComponent::StoreOwnTmpIfNecessary() 1310 { 1311 if ( !m_pNativeImpl->m_pOleObject ) 1312 throw embed::WrongStateException(); // TODO: the object is in wrong state 1313 1314 ComSmart< IPersistStorage > pPersistStorage; 1315 HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IPersistStorage, (void**)&pPersistStorage ); 1316 if ( FAILED( hr ) || !pPersistStorage ) 1317 throw io::IOException(); // TODO 1318 1319 if ( m_bWorkaroundActive || pPersistStorage->IsDirty() != S_FALSE ) 1320 { 1321 hr = OleSave( pPersistStorage, m_pNativeImpl->m_pIStorage, TRUE ); 1322 if ( FAILED( hr ) ) 1323 { 1324 // Till now was required only for AcrobatReader7.0.8 1325 GUID aCLSID; 1326 hr = m_pNativeImpl->m_pOleObject->GetUserClassID( &aCLSID ); 1327 if ( FAILED( hr ) ) 1328 throw io::IOException(); // TODO 1329 1330 hr = WriteClassStg( m_pNativeImpl->m_pIStorage, aCLSID ); 1331 if ( FAILED( hr ) ) 1332 throw io::IOException(); // TODO 1333 1334 // the result of the following call is not checked because some objects, for example AcrobatReader7.0.8 1335 // return error even in case the saving was done correctly 1336 hr = pPersistStorage->Save( m_pNativeImpl->m_pIStorage, TRUE ); 1337 1338 // another workaround for AcrobatReader7.0.8 object, this object might think that it is not changed 1339 // when it has been created from file, although it must be saved 1340 m_bWorkaroundActive = sal_True; 1341 } 1342 1343 hr = m_pNativeImpl->m_pIStorage->Commit( STGC_DEFAULT ); 1344 if ( FAILED( hr ) ) 1345 throw io::IOException(); // TODO 1346 1347 hr = pPersistStorage->SaveCompleted( NULL ); 1348 if ( FAILED( hr ) && hr != E_UNEXPECTED ) 1349 throw io::IOException(); // TODO 1350 1351 // STATSTG aStat; 1352 // m_pNativeImpl->m_pIStorage->Stat( &aStat, STATFLAG_NONAME ); 1353 } 1354 } 1355 1356 //---------------------------------------------- 1357 sal_Bool OleComponent::SaveObject_Impl() 1358 { 1359 sal_Bool bResult = sal_False; 1360 OleEmbeddedObject* pLockObject = NULL; 1361 1362 { 1363 osl::MutexGuard aGuard( m_aMutex ); 1364 if ( m_pUnoOleObject ) 1365 { 1366 pLockObject = m_pUnoOleObject; 1367 pLockObject->acquire(); 1368 } 1369 } 1370 1371 if ( pLockObject ) 1372 { 1373 bResult = pLockObject->SaveObject_Impl(); 1374 pLockObject->release(); 1375 } 1376 1377 return bResult; 1378 } 1379 1380 //---------------------------------------------- 1381 sal_Bool OleComponent::OnShowWindow_Impl( bool bShow ) 1382 { 1383 sal_Bool bResult = sal_False; 1384 OleEmbeddedObject* pLockObject = NULL; 1385 1386 { 1387 osl::MutexGuard aGuard( m_aMutex ); 1388 1389 if ( m_pUnoOleObject ) 1390 { 1391 pLockObject = m_pUnoOleObject; 1392 pLockObject->acquire(); 1393 } 1394 } 1395 1396 if ( pLockObject ) 1397 { 1398 bResult = pLockObject->OnShowWindow_Impl( bShow ); 1399 pLockObject->release(); 1400 } 1401 1402 return bResult; 1403 } 1404 1405 //---------------------------------------------- 1406 void OleComponent::OnViewChange_Impl( sal_uInt32 dwAspect ) 1407 { 1408 // TODO: check if it is enough or may be saving notifications are required for Visio2000 1409 ::rtl::Reference< OleEmbeddedObject > xLockObject; 1410 1411 { 1412 osl::MutexGuard aGuard( m_aMutex ); 1413 if ( m_pUnoOleObject ) 1414 xLockObject = m_pUnoOleObject; 1415 } 1416 1417 if ( xLockObject.is() ) 1418 { 1419 uno::Reference < awt::XRequestCallback > xRequestCallback( 1420 m_xFactory->createInstance( 1421 ::rtl::OUString::createFromAscii("com.sun.star.awt.AsyncCallback") ), 1422 uno::UNO_QUERY ); 1423 xRequestCallback->addCallback( new MainThreadNotificationRequest( xLockObject, OLECOMP_ONVIEWCHANGE, dwAspect ), uno::Any() ); 1424 } 1425 } 1426 1427 //---------------------------------------------- 1428 void OleComponent::OnClose_Impl() 1429 { 1430 ::rtl::Reference< OleEmbeddedObject > xLockObject; 1431 1432 { 1433 osl::MutexGuard aGuard( m_aMutex ); 1434 if ( m_pUnoOleObject ) 1435 xLockObject = m_pUnoOleObject; 1436 } 1437 1438 if ( xLockObject.is() ) 1439 { 1440 uno::Reference < awt::XRequestCallback > xRequestCallback( 1441 m_xFactory->createInstance( 1442 ::rtl::OUString::createFromAscii("com.sun.star.awt.AsyncCallback") ), 1443 uno::UNO_QUERY ); 1444 xRequestCallback->addCallback( new MainThreadNotificationRequest( xLockObject, OLECOMP_ONCLOSE ), uno::Any() ); 1445 } 1446 } 1447 1448 // XCloseable 1449 //---------------------------------------------- 1450 void SAL_CALL OleComponent::close( sal_Bool bDeliverOwnership ) 1451 throw ( util::CloseVetoException, 1452 uno::RuntimeException ) 1453 { 1454 ::osl::MutexGuard aGuard( m_aMutex ); 1455 if ( m_bDisposed ) 1456 throw lang::DisposedException(); // TODO 1457 1458 uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >( this ) ); 1459 lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) ); 1460 1461 if ( m_pInterfaceContainer ) 1462 { 1463 ::cppu::OInterfaceContainerHelper* pContainer = 1464 m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< util::XCloseListener >* ) NULL ) ); 1465 if ( pContainer != NULL ) 1466 { 1467 ::cppu::OInterfaceIteratorHelper pIterator( *pContainer ); 1468 while ( pIterator.hasMoreElements() ) 1469 { 1470 try 1471 { 1472 ( (util::XCloseListener* )pIterator.next() )->queryClosing( aSource, bDeliverOwnership ); 1473 } 1474 catch( uno::RuntimeException& ) 1475 { 1476 pIterator.remove(); 1477 } 1478 } 1479 } 1480 1481 pContainer = m_pInterfaceContainer->getContainer( 1482 ::getCppuType( ( const uno::Reference< util::XCloseListener >* ) NULL ) ); 1483 if ( pContainer != NULL ) 1484 { 1485 ::cppu::OInterfaceIteratorHelper pCloseIterator( *pContainer ); 1486 while ( pCloseIterator.hasMoreElements() ) 1487 { 1488 try 1489 { 1490 ( (util::XCloseListener* )pCloseIterator.next() )->notifyClosing( aSource ); 1491 } 1492 catch( uno::RuntimeException& ) 1493 { 1494 pCloseIterator.remove(); 1495 } 1496 } 1497 } 1498 } 1499 1500 Dispose(); 1501 } 1502 1503 //---------------------------------------------- 1504 void SAL_CALL OleComponent::addCloseListener( const uno::Reference< util::XCloseListener >& xListener ) 1505 throw ( uno::RuntimeException ) 1506 { 1507 ::osl::MutexGuard aGuard( m_aMutex ); 1508 if ( m_bDisposed ) 1509 throw lang::DisposedException(); // TODO 1510 1511 if ( !m_pInterfaceContainer ) 1512 m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex ); 1513 1514 m_pInterfaceContainer->addInterface( ::getCppuType( ( const uno::Reference< util::XCloseListener >* )0 ), xListener ); 1515 } 1516 1517 //---------------------------------------------- 1518 void SAL_CALL OleComponent::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener ) 1519 throw ( uno::RuntimeException ) 1520 { 1521 ::osl::MutexGuard aGuard( m_aMutex ); 1522 if ( m_bDisposed ) 1523 throw lang::DisposedException(); // TODO 1524 1525 if ( m_pInterfaceContainer ) 1526 m_pInterfaceContainer->removeInterface( ::getCppuType( ( const uno::Reference< util::XCloseListener >* )0 ), 1527 xListener ); 1528 } 1529 1530 // XTransferable 1531 //---------------------------------------------- 1532 uno::Any SAL_CALL OleComponent::getTransferData( const datatransfer::DataFlavor& aFlavor ) 1533 throw ( datatransfer::UnsupportedFlavorException, 1534 io::IOException, 1535 uno::RuntimeException ) 1536 { 1537 ::osl::MutexGuard aGuard( m_aMutex ); 1538 if ( m_bDisposed ) 1539 throw lang::DisposedException(); // TODO 1540 1541 if ( !m_pNativeImpl->m_pOleObject ) 1542 throw embed::WrongStateException(); // TODO: the object is in wrong state 1543 1544 uno::Any aResult; 1545 sal_Bool bSupportedFlavor = sal_False; 1546 1547 if ( m_pNativeImpl->GraphicalFlavor( aFlavor ) ) 1548 { 1549 DWORD nRequestedAspect = GetAspectFromFlavor( aFlavor ); 1550 // if own icon is set and icon aspect is requested the own icon can be returned directly 1551 1552 ComSmart< IDataObject > pDataObject; 1553 HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, (void**)&pDataObject ); 1554 if ( FAILED( hr ) || !pDataObject ) 1555 throw io::IOException(); // TODO: transport error code 1556 1557 // The following optimization does not make much sence currently just because 1558 // only one aspect is supported, and only three formats for the aspect are supported 1559 // and moreover it is not guarantied that the once returned format will be supported further 1560 // example - i52106 1561 // TODO/LATER: bring the optimization back when other aspects are supported 1562 1563 // FORMATETC* pFormatEtc = m_pNativeImpl->GetSupportedFormatForAspect( nRequestedAspect ); 1564 // if ( pFormatEtc ) 1565 // { 1566 // STGMEDIUM aMedium; 1567 // hr = pDataObject->GetData( pFormatEtc, &aMedium ); 1568 // if ( SUCCEEDED( hr ) ) 1569 // bSupportedFlavor = m_pNativeImpl->ConvertDataForFlavor( aMedium, aFlavor, aResult ); 1570 // } 1571 // else 1572 { 1573 // the supported format of the application is still not found, find one 1574 for ( sal_Int32 nInd = 0; nInd < FORMATS_NUM; nInd++ ) 1575 { 1576 STGMEDIUM aMedium; 1577 FORMATETC aFormat = pFormatTemplates[nInd]; 1578 aFormat.dwAspect = nRequestedAspect; 1579 1580 hr = pDataObject->GetData( &aFormat, &aMedium ); 1581 if ( SUCCEEDED( hr ) ) 1582 { 1583 bSupportedFlavor = m_pNativeImpl->ConvertDataForFlavor( aMedium, aFlavor, aResult ); 1584 ::ReleaseStgMedium(&aMedium); // i113605, to release storge medium 1585 if ( bSupportedFlavor ) 1586 { 1587 // TODO/LATER: bring the optimization back when other aspects are supported 1588 // m_pNativeImpl->AddSupportedFormat( aFormat ); 1589 break; 1590 } 1591 } 1592 } 1593 } 1594 1595 // If the replacement could not be retrieved, the cached representaion should be used 1596 // currently it is not necessary to retrieve it here, so it is implemented in the object itself 1597 } 1598 // TODO: Investigate if there is already the format name 1599 // and whether this format is really required 1600 else if ( aFlavor.DataType == getCppuType( ( const uno::Reference< io::XInputStream >* ) 0 ) 1601 && aFlavor.MimeType.equalsAscii( "application/x-openoffice-contentstream" ) ) 1602 { 1603 // allow to retrieve stream-representation of the object persistence 1604 bSupportedFlavor = sal_True; 1605 uno::Reference < io::XStream > xTempFileStream( 1606 m_xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ) ), 1607 uno::UNO_QUERY ); 1608 1609 if ( !xTempFileStream.is() ) 1610 throw uno::RuntimeException(); // TODO 1611 1612 uno::Reference< io::XOutputStream > xTempOutStream = xTempFileStream->getOutputStream(); 1613 uno::Reference< io::XInputStream > xTempInStream = xTempFileStream->getInputStream(); 1614 if ( xTempOutStream.is() && xTempInStream.is() ) 1615 { 1616 OSL_ENSURE( m_pUnoOleObject, "Unexpected object absence!" ); 1617 if ( !m_pUnoOleObject ) 1618 throw uno::RuntimeException(); 1619 1620 m_pUnoOleObject->StoreObjectToStream( xTempOutStream ); 1621 1622 xTempOutStream->closeOutput(); 1623 xTempOutStream = uno::Reference< io::XOutputStream >(); 1624 } 1625 else 1626 throw io::IOException(); // TODO: 1627 1628 aResult <<= xTempInStream; 1629 } 1630 1631 if ( !bSupportedFlavor ) 1632 throw datatransfer::UnsupportedFlavorException(); 1633 1634 return aResult; 1635 } 1636 1637 //---------------------------------------------- 1638 uno::Sequence< datatransfer::DataFlavor > SAL_CALL OleComponent::getTransferDataFlavors() 1639 throw ( uno::RuntimeException ) 1640 { 1641 ::osl::MutexGuard aGuard( m_aMutex ); 1642 if ( m_bDisposed ) 1643 throw lang::DisposedException(); // TODO 1644 1645 if ( !m_pNativeImpl->m_pOleObject ) 1646 throw embed::WrongStateException(); // TODO: the object is in wrong state 1647 1648 RetrieveObjectDataFlavors_Impl(); 1649 1650 return m_aDataFlavors; 1651 } 1652 1653 //---------------------------------------------- 1654 sal_Bool SAL_CALL OleComponent::isDataFlavorSupported( const datatransfer::DataFlavor& aFlavor ) 1655 throw ( uno::RuntimeException ) 1656 { 1657 ::osl::MutexGuard aGuard( m_aMutex ); 1658 if ( m_bDisposed ) 1659 throw lang::DisposedException(); // TODO 1660 1661 if ( !m_pNativeImpl->m_pOleObject ) 1662 throw embed::WrongStateException(); // TODO: the object is in wrong state 1663 1664 if ( !m_aDataFlavors.getLength() ) 1665 { 1666 RetrieveObjectDataFlavors_Impl(); 1667 } 1668 1669 for ( sal_Int32 nInd = 0; nInd < m_aDataFlavors.getLength(); nInd++ ) 1670 if ( m_aDataFlavors[nInd].MimeType.equals( aFlavor.MimeType ) && m_aDataFlavors[nInd].DataType == aFlavor.DataType ) 1671 return sal_True; 1672 1673 return sal_False; 1674 } 1675 1676 void SAL_CALL OleComponent::dispose() throw (::com::sun::star::uno::RuntimeException) 1677 { 1678 try 1679 { 1680 close( sal_True ); 1681 } 1682 catch ( uno::Exception& ) 1683 { 1684 } 1685 } 1686 1687 void SAL_CALL OleComponent::addEventListener( const uno::Reference< lang::XEventListener >& xListener ) 1688 throw ( uno::RuntimeException ) 1689 { 1690 ::osl::MutexGuard aGuard( m_aMutex ); 1691 if ( m_bDisposed ) 1692 throw lang::DisposedException(); // TODO 1693 1694 if ( !m_pInterfaceContainer ) 1695 m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex ); 1696 1697 m_pInterfaceContainer->addInterface( ::getCppuType( ( const uno::Reference< lang::XEventListener >* )0 ), xListener ); 1698 } 1699 1700 //---------------------------------------------- 1701 void SAL_CALL OleComponent::removeEventListener( const uno::Reference< lang::XEventListener >& xListener ) 1702 throw ( uno::RuntimeException ) 1703 { 1704 ::osl::MutexGuard aGuard( m_aMutex ); 1705 if ( m_bDisposed ) 1706 throw lang::DisposedException(); // TODO 1707 1708 if ( m_pInterfaceContainer ) 1709 m_pInterfaceContainer->removeInterface( ::getCppuType( ( const uno::Reference< lang::XEventListener >* )0 ), 1710 xListener ); 1711 } 1712 1713 sal_Int64 SAL_CALL OleComponent::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& aIdentifier ) throw(::com::sun::star::uno::RuntimeException) 1714 { 1715 try 1716 { 1717 uno::Sequence < sal_Int8 > aCLSID = GetCLSID(); 1718 if ( MimeConfigurationHelper::ClassIDsEqual( aIdentifier, aCLSID ) ) 1719 return (sal_Int64) (IUnknown*) m_pNativeImpl->m_pObj; 1720 1721 // compatibility hack for old versions: CLSID was used in wrong order (SvGlobalName order) 1722 sal_Int32 nLength = aIdentifier.getLength(); 1723 if ( nLength == 16 ) 1724 { 1725 for ( sal_Int32 n=8; n<16; n++ ) 1726 if ( aIdentifier[n] != aCLSID[n] ) 1727 return 0; 1728 if ( aIdentifier[7] == aCLSID[6] && 1729 aIdentifier[6] == aCLSID[7] && 1730 aIdentifier[5] == aCLSID[4] && 1731 aIdentifier[4] == aCLSID[5] && 1732 aIdentifier[3] == aCLSID[0] && 1733 aIdentifier[2] == aCLSID[1] && 1734 aIdentifier[1] == aCLSID[2] && 1735 aIdentifier[0] == aCLSID[3] ) 1736 return (sal_Int64) (IUnknown*) m_pNativeImpl->m_pObj; 1737 } 1738 } 1739 catch ( uno::Exception& ) 1740 { 1741 } 1742 1743 return 0; 1744 } 1745 1746 sal_Bool SAL_CALL OleComponent::isModified() throw (::com::sun::star::uno::RuntimeException) 1747 { 1748 return m_bModified; 1749 } 1750 1751 void SAL_CALL OleComponent::setModified( sal_Bool bModified ) 1752 throw (::com::sun::star::beans::PropertyVetoException, ::com::sun::star::uno::RuntimeException) 1753 { 1754 m_bModified = bModified; 1755 1756 if ( bModified && m_pInterfaceContainer ) 1757 { 1758 ::cppu::OInterfaceContainerHelper* pContainer = 1759 m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< util::XModifyListener >* ) NULL ) ); 1760 if ( pContainer != NULL ) 1761 { 1762 ::cppu::OInterfaceIteratorHelper pIterator( *pContainer ); 1763 while ( pIterator.hasMoreElements() ) 1764 { 1765 try 1766 { 1767 lang::EventObject aEvent( (util::XModifiable*) this ); 1768 ((util::XModifyListener*)pIterator.next())->modified( aEvent ); 1769 } 1770 catch( uno::RuntimeException& ) 1771 { 1772 pIterator.remove(); 1773 } 1774 } 1775 } 1776 } 1777 } 1778 1779 void SAL_CALL OleComponent::addModifyListener( const com::sun::star::uno::Reference < com::sun::star::util::XModifyListener >& xListener ) throw(::com::sun::star::uno::RuntimeException) 1780 { 1781 ::osl::MutexGuard aGuard( m_aMutex ); 1782 if ( m_bDisposed ) 1783 throw lang::DisposedException(); // TODO 1784 1785 if ( !m_pInterfaceContainer ) 1786 m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex ); 1787 1788 m_pInterfaceContainer->addInterface( ::getCppuType( ( const uno::Reference< util::XModifyListener >* )0 ), xListener ); 1789 } 1790 1791 void SAL_CALL OleComponent::removeModifyListener( const com::sun::star::uno::Reference < com::sun::star::util::XModifyListener >& xListener) throw(::com::sun::star::uno::RuntimeException) 1792 { 1793 ::osl::MutexGuard aGuard( m_aMutex ); 1794 if ( m_bDisposed ) 1795 throw lang::DisposedException(); // TODO 1796 1797 if ( m_pInterfaceContainer ) 1798 m_pInterfaceContainer->removeInterface( ::getCppuType( ( const uno::Reference< util::XModifyListener >* )0 ), 1799 xListener ); 1800 } 1801 1802