dtrans/source/win32/dtobj/XTDataObject.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: XTDataObject.cxx,v $
  10  * $Revision: 1.25 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_dtrans.hxx"
  33
  34 //------------------------------------------------------------------------
  35 // includes
  36 //------------------------------------------------------------------------
  37 #include <osl/diagnose.h>
  38
  39 #ifndef _TXDATAOBJECT_HXX_
  40 #include "XTDataObject.hxx"
  41 #endif
  42 #include <com/sun/star/datatransfer/dataflavor.hpp>
  43 #include "..\misc\ImplHelper.hxx"
  44 #include "DTransHelper.hxx"
  45 #include "TxtCnvtHlp.hxx"
  46 #include <com/sun/star/datatransfer/clipboard/XClipboardEx.hpp>
  47 #include "FmtFilter.hxx"
  48
  49 #if defined _MSC_VER
  50 #pragma warning(push,1)
  51 #pragma warning(disable:4917)
  52 #endif
  53 #include <windows.h>
  54 #include <shlobj.h>
  55 #if defined _MSC_VER
  56 #pragma warning(pop)
  57 #endif
  58
  59 #ifdef __MINGW32__
  60 #define __uuidof(I) IID_##I
  61 #endif
  62
  63 //------------------------------------------------------------------------
  64 // namespace directives
  65 //------------------------------------------------------------------------
  66
  67 using namespace com::sun::star::datatransfer;
  68 using namespace com::sun::star::datatransfer::clipboard;
  69 using namespace com::sun::star::uno;
  70 using namespace com::sun::star::lang;
  71 using namespace rtl;
  72
  73 //------------------------------------------------------------------------
  74 // a helper class that will be thrown by the function validateFormatEtc
  75 //------------------------------------------------------------------------
  76
  77 class CInvalidFormatEtcException
  78 {
  79 public:
  80     HRESULT m_hr;
  81     CInvalidFormatEtcException( HRESULT hr ) : m_hr( hr ) {};
  82 };
  83
  84 //------------------------------------------------------------------------
  85 // ctor
  86 //------------------------------------------------------------------------
  87
  88 CXTDataObject::CXTDataObject( const Reference< XMultiServiceFactory >& aServiceManager,
  89                               const Reference< XTransferable >& aXTransferable ) :
  90     m_nRefCnt( 0 ),
  91     m_SrvMgr( aServiceManager ),
  92     m_XTransferable( aXTransferable ),
  93     m_DataFormatTranslator( aServiceManager ),
  94     m_bFormatEtcContainerInitialized( sal_False ),
  95     m_FormatRegistrar( m_SrvMgr, m_DataFormatTranslator )
  96 {
  97 }
  98
  99 //------------------------------------------------------------------------
 100 // IUnknown->QueryInterface
 101 //------------------------------------------------------------------------
 102
 103 STDMETHODIMP CXTDataObject::QueryInterface( REFIID iid, LPVOID* ppvObject )
 104 {
 105     if ( NULL == ppvObject )
 106         return E_INVALIDARG;
 107
 108     HRESULT hr = E_NOINTERFACE;
 109
 110     *ppvObject = NULL;
 111     if ( ( __uuidof( IUnknown ) == iid ) ||
 112          ( __uuidof( IDataObject ) == iid ) )
 113     {
 114         *ppvObject = static_cast< IUnknown* >( this );
 115         ( (LPUNKNOWN)*ppvObject )->AddRef( );
 116         hr = S_OK;
 117     }
 118
 119     return hr;
 120 }
 121
 122 //------------------------------------------------------------------------
 123 // IUnknown->AddRef
 124 //------------------------------------------------------------------------
 125
 126 STDMETHODIMP_(ULONG) CXTDataObject::AddRef( )
 127 {
 128     return static_cast< ULONG >( InterlockedIncrement( &m_nRefCnt ) );
 129 }
 130
 131 //------------------------------------------------------------------------
 132 // IUnknown->Release
 133 //------------------------------------------------------------------------
 134
 135 STDMETHODIMP_(ULONG) CXTDataObject::Release( )
 136 {
 137     ULONG nRefCnt =
 138         static_cast< ULONG >( InterlockedDecrement( &m_nRefCnt ) );
 139
 140     if ( 0 == nRefCnt )
 141         delete this;
 142
 143     return nRefCnt;
 144 }
 145
 146 //------------------------------------------------------------------------
 147 //
 148 //------------------------------------------------------------------------
 149
 150 STDMETHODIMP CXTDataObject::GetData( LPFORMATETC pFormatetc, LPSTGMEDIUM pmedium )
 151 {
 152     if ( !(pFormatetc && pmedium) )
 153         return E_INVALIDARG;
 154
 155     try
 156     {
 157         // prepare data transfer
 158         invalidateStgMedium( *pmedium );
 159         validateFormatEtc( pFormatetc );
 160
 161         // handle locale request, because locale is a artificial format for us
 162         if ( CF_LOCALE == pFormatetc->cfFormat )
 163             renderLocaleAndSetupStgMedium( *pFormatetc, *pmedium );
 164         else if ( CF_UNICODETEXT == pFormatetc->cfFormat )
 165             renderUnicodeAndSetupStgMedium( *pFormatetc, *pmedium );
 166         else
 167             renderAnyDataAndSetupStgMedium( *pFormatetc, *pmedium );
 168     }
 169     catch(UnsupportedFlavorException&)
 170     {
 171         HRESULT hr = DV_E_FORMATETC;
 172
 173         if ( m_FormatRegistrar.isSynthesizeableFormat( *pFormatetc ) )
 174             hr = renderSynthesizedFormatAndSetupStgMedium( *pFormatetc, *pmedium );
 175
 176         return hr;
 177     }
 178     catch( CInvalidFormatEtcException& ex )
 179     {
 180         return ex.m_hr;
 181     }
 182     catch( CStgTransferHelper::CStgTransferException& ex )
 183     {
 184         return translateStgExceptionCode( ex.m_hr );
 185     }
 186     catch(...)
 187     {
 188         return E_UNEXPECTED;
 189     }
 190
 191     return S_OK;
 192 }
 193
 194 //------------------------------------------------------------------------
 195 //
 196 //------------------------------------------------------------------------
 197
 198 // inline
 199 void SAL_CALL CXTDataObject::renderDataAndSetupStgMedium(
 200     const sal_Int8* lpStorage, const FORMATETC& fetc, sal_uInt32 nInitStgSize,
 201     sal_uInt32 nBytesToTransfer, STGMEDIUM& stgmedium )
 202 {
 203     OSL_PRECOND( !nInitStgSize || nInitStgSize && (nInitStgSize >= nBytesToTransfer),
 204                  "Memory size less than number of bytes to transfer" );
 205
 206     CStgTransferHelper stgTransfHelper( AUTO_INIT );
 207
 208     // setup storage size
 209     if ( nInitStgSize > 0 )
 210         stgTransfHelper.init( nInitStgSize, GHND );
 211
 212 #if OSL_DEBUG_LEVEL > 0
 213     sal_uInt32 nBytesWritten = 0;
 214     stgTransfHelper.write( lpStorage, nBytesToTransfer, &nBytesWritten );
 215     OSL_ASSERT( nBytesWritten == nBytesToTransfer );
 216 #else
 217     stgTransfHelper.write( lpStorage, nBytesToTransfer );
 218 #endif
 219
 220     setupStgMedium( fetc, stgTransfHelper, stgmedium );
 221 }
 222
 223 //------------------------------------------------------------------------
 224 //
 225 //------------------------------------------------------------------------
 226
 227 //inline
 228 void SAL_CALL CXTDataObject::renderLocaleAndSetupStgMedium(
 229     FORMATETC& fetc, STGMEDIUM& stgmedium )
 230 {
 231     if ( m_FormatRegistrar.hasSynthesizedLocale( ) )
 232     {
 233         LCID lcid = m_FormatRegistrar.getSynthesizedLocale( );
 234         renderDataAndSetupStgMedium(
 235             reinterpret_cast< sal_Int8* >( &lcid ),
 236             fetc,
 237             0,
 238             sizeof( LCID ),
 239             stgmedium );
 240     }
 241     else
 242         throw CInvalidFormatEtcException( DV_E_FORMATETC );
 243 }
 244
 245 //------------------------------------------------------------------------
 246 //
 247 //------------------------------------------------------------------------
 248
 249 //inline
 250 void SAL_CALL CXTDataObject::renderUnicodeAndSetupStgMedium(
 251     FORMATETC& fetc, STGMEDIUM& stgmedium )
 252 {
 253     DataFlavor aFlavor = formatEtcToDataFlavor( fetc );
 254
 255     Any aAny = m_XTransferable->getTransferData( aFlavor );
 256
 257     // unfortunately not all transferables fulfill the
 258     // spec. an do throw an UnsupportedFlavorException
 259     // so we must check the any
 260     if ( !aAny.hasValue( ) )
 261     {
 262         OSL_ENSURE( sal_False, "XTransferable should throw an exception if ask for an unsupported flavor" );
 263         throw UnsupportedFlavorException( );
 264     }
 265
 266     OUString aText;
 267     aAny >>= aText;
 268
 269     sal_uInt32 nBytesToTransfer = aText.getLength( ) * sizeof( sal_Unicode );
 270
 271     // to be sure there is an ending 0
 272     sal_uInt32 nRequiredMemSize = nBytesToTransfer + sizeof( sal_Unicode );
 273
 274     renderDataAndSetupStgMedium(
 275         reinterpret_cast< const sal_Int8* >( aText.getStr( ) ),
 276         fetc,
 277         nRequiredMemSize,
 278         nBytesToTransfer,
 279         stgmedium );
 280 }
 281
 282 //------------------------------------------------------------------------
 283 //
 284 //------------------------------------------------------------------------
 285
 286 //inline
 287 void SAL_CALL CXTDataObject::renderAnyDataAndSetupStgMedium(
 288     FORMATETC& fetc, STGMEDIUM& stgmedium )
 289 {
 290     DataFlavor aFlavor = formatEtcToDataFlavor( fetc );
 291
 292     Any aAny = m_XTransferable->getTransferData( aFlavor );
 293
 294     // unfortunately not all transferables fulfill the
 295     // spec. an do throw an UnsupportedFlavorException
 296     // so we must check the any
 297     if ( !aAny.hasValue( ) )
 298     {
 299         OSL_ENSURE( sal_False, "XTransferable should throw an exception if ask for an unsupported flavor" );
 300         throw UnsupportedFlavorException( );
 301     }
 302
 303     // unfortunately not all transferables fulfill the
 304     // spec. an do throw an UnsupportedFlavorException
 305     // so we must check the any
 306     if ( !aAny.hasValue( ) )
 307         throw UnsupportedFlavorException( );
 308
 309     Sequence< sal_Int8 > clipDataStream;
 310     aAny >>= clipDataStream;
 311
 312     sal_uInt32 nRequiredMemSize = 0;
 313     if ( m_DataFormatTranslator.isOemOrAnsiTextFormat( fetc.cfFormat ) )
 314         nRequiredMemSize = sizeof( sal_Int8 ) * clipDataStream.getLength( ) + 1;
 315
 316     // prepare data for transmision
 317     if ( CF_DIB == fetc.cfFormat )
 318         clipDataStream = OOBmpToWinDIB( clipDataStream );
 319
 320     if ( CF_METAFILEPICT == fetc.cfFormat )
 321     {
 322         stgmedium.tymed          = TYMED_MFPICT;
 323         stgmedium.hMetaFilePict  = OOMFPictToWinMFPict( clipDataStream );
 324         stgmedium.pUnkForRelease = NULL;
 325     }
 326     else if( CF_ENHMETAFILE     == fetc.cfFormat )
 327     {
 328         stgmedium.tymed          = TYMED_ENHMF;
 329         stgmedium.hMetaFilePict  = OOMFPictToWinENHMFPict( clipDataStream );
 330         stgmedium.pUnkForRelease = NULL;
 331     }
 332     else
 333         renderDataAndSetupStgMedium(
 334             clipDataStream.getArray( ),
 335             fetc,
 336             nRequiredMemSize,
 337             clipDataStream.getLength( ),
 338             stgmedium );
 339 }
 340
 341 //------------------------------------------------------------------------
 342 //
 343 //------------------------------------------------------------------------
 344
 345 HRESULT SAL_CALL CXTDataObject::renderSynthesizedFormatAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
 346 {
 347     HRESULT hr = S_OK;
 348
 349     try
 350     {
 351         if ( CF_UNICODETEXT == fetc.cfFormat )
 352             // the transferable seems to have only text
 353             renderSynthesizedUnicodeAndSetupStgMedium( fetc, stgmedium );
 354         else if ( m_DataFormatTranslator.isOemOrAnsiTextFormat( fetc.cfFormat ) )
 355             // the transferable seems to have only unicode text
 356             renderSynthesizedTextAndSetupStgMedium( fetc, stgmedium );
 357         else
 358             // the transferable seems to have only text/html
 359             renderSynthesizedHtmlAndSetupStgMedium( fetc, stgmedium );
 360     }
 361     catch(UnsupportedFlavorException&)
 362     {
 363         hr = DV_E_FORMATETC;
 364     }
 365     catch( CInvalidFormatEtcException& )
 366     {
 367         OSL_ENSURE( sal_False, "Unexpected exception" );
 368     }
 369     catch( CStgTransferHelper::CStgTransferException& ex )
 370     {
 371         return translateStgExceptionCode( ex.m_hr );
 372     }
 373     catch(...)
 374     {
 375         hr = E_UNEXPECTED;
 376     }
 377
 378     return hr;
 379 }
 380
 381 //------------------------------------------------------------------------
 382 // the transferable must have only text, so we will synthesize unicode text
 383 //------------------------------------------------------------------------
 384
 385 void SAL_CALL CXTDataObject::renderSynthesizedUnicodeAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
 386 {
 387     OSL_ASSERT( CF_UNICODETEXT == fetc.cfFormat );
 388
 389     Any aAny = m_XTransferable->getTransferData( m_FormatRegistrar.getRegisteredTextFlavor( ) );
 390
 391     // unfortunately not all transferables fulfill the
 392     // spec. an do throw an UnsupportedFlavorException
 393     // so we must check the any
 394     if ( !aAny.hasValue( ) )
 395     {
 396         OSL_ENSURE( sal_False, "XTransferable should throw an exception if ask for an unsupported flavor" );
 397         throw UnsupportedFlavorException( );
 398     }
 399
 400     Sequence< sal_Int8 > aText;
 401     aAny >>= aText;
 402
 403     CStgTransferHelper stgTransfHelper;
 404
 405     MultiByteToWideCharEx(
 406         m_FormatRegistrar.getRegisteredTextCodePage( ),
 407         reinterpret_cast< char* >( aText.getArray( ) ),
 408         aText.getLength( ),
 409         stgTransfHelper );
 410
 411     setupStgMedium( fetc, stgTransfHelper, stgmedium );
 412 }
 413
 414 //------------------------------------------------------------------------
 415 // the transferable must have only unicode text so we will sythesize text
 416 //------------------------------------------------------------------------
 417
 418 void SAL_CALL CXTDataObject::renderSynthesizedTextAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
 419 {
 420     OSL_ASSERT( m_DataFormatTranslator.isOemOrAnsiTextFormat( fetc.cfFormat ) );
 421
 422     DataFlavor aFlavor = formatEtcToDataFlavor(
 423         m_DataFormatTranslator.getFormatEtcForClipformat( CF_UNICODETEXT ) );
 424
 425     Any aAny = m_XTransferable->getTransferData( aFlavor );
 426
 427     // unfortunately not all transferables fulfill the
 428     // spec. an do throw an UnsupportedFlavorException
 429     // so we must check the any
 430     if ( !aAny.hasValue( ) )
 431     {
 432         OSL_ENSURE( sal_False, "XTransferable should throw an exception if ask for an unsupported flavor" );
 433         throw UnsupportedFlavorException( );
 434     }
 435
 436     OUString aUnicodeText;
 437     aAny >>= aUnicodeText;
 438
 439     CStgTransferHelper stgTransfHelper;
 440
 441     WideCharToMultiByteEx(
 442         GetACP( ),
 443         reinterpret_cast<LPCWSTR>( aUnicodeText.getStr( ) ),
 444         aUnicodeText.getLength( ),
 445         stgTransfHelper );
 446
 447     setupStgMedium( fetc, stgTransfHelper, stgmedium );
 448 }
 449
 450 //------------------------------------------------------------------------
 451 //
 452 //------------------------------------------------------------------------
 453
 454 void SAL_CALL CXTDataObject::renderSynthesizedHtmlAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
 455 {
 456     OSL_ASSERT( m_DataFormatTranslator.isHTMLFormat( fetc.cfFormat ) );
 457
 458     DataFlavor aFlavor;
 459
 460     // creating a DataFlavor on the fly
 461     aFlavor.MimeType = OUString::createFromAscii( "text/html" );
 462     aFlavor.DataType = getCppuType( (Sequence< sal_Int8 >*)0 );
 463
 464     Any aAny = m_XTransferable->getTransferData( aFlavor );
 465
 466     // unfortunately not all transferables fulfill the
 467     // spec. an do throw an UnsupportedFlavorException
 468     // so we must check the any
 469     if ( !aAny.hasValue( ) )
 470     {
 471         OSL_ENSURE( sal_False, "XTransferable should throw an exception if ask for an unsupported flavor" );
 472         throw UnsupportedFlavorException( );
 473     }
 474
 475     Sequence< sal_Int8 > aTextHtmlSequence;
 476     aAny >>= aTextHtmlSequence;
 477
 478     Sequence< sal_Int8 > aHTMLFormatSequence = TextHtmlToHTMLFormat( aTextHtmlSequence );
 479
 480     sal_uInt32 nBytesToTransfer = aHTMLFormatSequence.getLength( );
 481
 482     renderDataAndSetupStgMedium(
 483         reinterpret_cast< const sal_Int8* >( aHTMLFormatSequence.getArray( ) ),
 484         fetc,
 485         0,
 486         nBytesToTransfer,
 487         stgmedium );
 488 }
 489
 490 //------------------------------------------------------------------------
 491 // IDataObject->EnumFormatEtc
 492 //------------------------------------------------------------------------
 493
 494 STDMETHODIMP CXTDataObject::EnumFormatEtc(
 495     DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc )
 496 {
 497     if ( NULL == ppenumFormatetc )
 498         return E_INVALIDARG;
 499
 500     if ( DATADIR_SET == dwDirection )
 501         return E_NOTIMPL;
 502
 503     *ppenumFormatetc = NULL;
 504
 505     InitializeFormatEtcContainer( );
 506
 507     HRESULT hr;
 508     if ( DATADIR_GET == dwDirection )
 509     {
 510         *ppenumFormatetc = new CEnumFormatEtc( this, m_FormatEtcContainer );
 511         if ( NULL != *ppenumFormatetc )
 512             static_cast< LPUNKNOWN >( *ppenumFormatetc )->AddRef( );
 513
 514         hr = ( NULL != *ppenumFormatetc ) ? S_OK : E_OUTOFMEMORY;
 515     }
 516     else
 517         hr = E_INVALIDARG;
 518
 519     return hr;
 520 }
 521
 522 //------------------------------------------------------------------------
 523 // IDataObject->QueryGetData
 524 //------------------------------------------------------------------------
 525
 526 STDMETHODIMP CXTDataObject::QueryGetData( LPFORMATETC pFormatetc )
 527 {
 528     if ( (NULL == pFormatetc) || IsBadReadPtr( pFormatetc, sizeof( FORMATETC ) ) )
 529         return E_INVALIDARG;
 530
 531     InitializeFormatEtcContainer( );
 532
 533     return m_FormatEtcContainer.hasFormatEtc( *pFormatetc ) ? S_OK : S_FALSE;
 534 }
 535
 536 //------------------------------------------------------------------------
 537 // IDataObject->GetDataHere
 538 //------------------------------------------------------------------------
 539
 540 STDMETHODIMP CXTDataObject::GetDataHere( LPFORMATETC, LPSTGMEDIUM )
 541 {
 542     return E_NOTIMPL;
 543 }
 544
 545 //------------------------------------------------------------------------
 546 // IDataObject->GetCanonicalFormatEtc
 547 //------------------------------------------------------------------------
 548
 549 STDMETHODIMP CXTDataObject::GetCanonicalFormatEtc( LPFORMATETC, LPFORMATETC )
 550 {
 551     return E_NOTIMPL;
 552 }
 553
 554 //------------------------------------------------------------------------
 555 // IDataObject->SetData
 556 //------------------------------------------------------------------------
 557
 558 STDMETHODIMP CXTDataObject::SetData( LPFORMATETC, LPSTGMEDIUM, BOOL )
 559 {
 560     return E_NOTIMPL;
 561 }
 562
 563 //------------------------------------------------------------------------
 564 // IDataObject->DAdvise
 565 //------------------------------------------------------------------------
 566
 567 STDMETHODIMP CXTDataObject::DAdvise( LPFORMATETC, DWORD, LPADVISESINK, DWORD * )
 568 {
 569     return E_NOTIMPL;
 570 }
 571
 572 //------------------------------------------------------------------------
 573 // IDataObject->DUnadvise
 574 //------------------------------------------------------------------------
 575
 576 STDMETHODIMP CXTDataObject::DUnadvise( DWORD )
 577 {
 578     return E_NOTIMPL;
 579 }
 580
 581 //------------------------------------------------------------------------
 582 // IDataObject->EnumDAdvise
 583 //------------------------------------------------------------------------
 584
 585 STDMETHODIMP CXTDataObject::EnumDAdvise( LPENUMSTATDATA * )
 586 {
 587     return E_NOTIMPL;
 588 }
 589
 590 //------------------------------------------------------------------------
 591 // for our convenience
 592 //------------------------------------------------------------------------
 593
 594 CXTDataObject::operator IDataObject*( )
 595 {
 596     return static_cast< IDataObject* >( this );
 597 }
 598
 599 //------------------------------------------------------------------------
 600 //
 601 //------------------------------------------------------------------------
 602
 603 inline
 604 DataFlavor SAL_CALL CXTDataObject::formatEtcToDataFlavor( const FORMATETC& aFormatEtc ) const
 605 {
 606     DataFlavor aFlavor;
 607
 608     if ( m_FormatRegistrar.hasSynthesizedLocale( ) )
 609         aFlavor =
 610             m_DataFormatTranslator.getDataFlavorFromFormatEtc( aFormatEtc, m_FormatRegistrar.getSynthesizedLocale( ) );
 611     else
 612         aFlavor = m_DataFormatTranslator.getDataFlavorFromFormatEtc( aFormatEtc );
 613
 614     if ( !aFlavor.MimeType.getLength( ) )
 615         throw UnsupportedFlavorException( );
 616
 617     return aFlavor;
 618 }
 619
 620 //------------------------------------------------------------------------
 621 //
 622 //------------------------------------------------------------------------
 623
 624 inline
 625 void CXTDataObject::validateFormatEtc( LPFORMATETC lpFormatEtc ) const
 626 {
 627     OSL_ASSERT( lpFormatEtc );
 628
 629     if ( lpFormatEtc->lindex != -1 )
 630         throw CInvalidFormatEtcException( DV_E_LINDEX );
 631
 632     if ( !(lpFormatEtc->dwAspect & DVASPECT_CONTENT) &&
 633          !(lpFormatEtc->dwAspect & DVASPECT_SHORTNAME) )
 634         throw CInvalidFormatEtcException( DV_E_DVASPECT );
 635
 636     if ( !(lpFormatEtc->tymed & TYMED_HGLOBAL) &&
 637          !(lpFormatEtc->tymed & TYMED_ISTREAM) &&
 638          !(lpFormatEtc->tymed & TYMED_MFPICT) &&
 639          !(lpFormatEtc->tymed & TYMED_ENHMF) )
 640         throw CInvalidFormatEtcException( DV_E_TYMED );
 641
 642     if ( lpFormatEtc->cfFormat == CF_METAFILEPICT &&
 643          !(lpFormatEtc->tymed & TYMED_MFPICT) )
 644         throw CInvalidFormatEtcException( DV_E_TYMED );
 645
 646     if ( lpFormatEtc->cfFormat == CF_ENHMETAFILE &&
 647          !(lpFormatEtc->tymed & TYMED_ENHMF) )
 648         throw CInvalidFormatEtcException( DV_E_TYMED );
 649 }
 650
 651 //------------------------------------------------------------------------
 652 //
 653 //------------------------------------------------------------------------
 654
 655 //inline
 656 void SAL_CALL CXTDataObject::setupStgMedium( const FORMATETC& fetc,
 657                                              CStgTransferHelper& stgTransHlp,
 658                                              STGMEDIUM& stgmedium )
 659 {
 660     stgmedium.pUnkForRelease = NULL;
 661
 662     if ( fetc.cfFormat == CF_METAFILEPICT )
 663     {
 664         stgmedium.tymed         = TYMED_MFPICT;
 665         stgmedium.hMetaFilePict = static_cast< HMETAFILEPICT >( stgTransHlp.getHGlobal( ) );
 666     }
 667     else if ( fetc.cfFormat == CF_ENHMETAFILE )
 668     {
 669         stgmedium.tymed        = TYMED_ENHMF;
 670         stgmedium.hEnhMetaFile = static_cast< HENHMETAFILE >( stgTransHlp.getHGlobal( ) );
 671     }
 672     else if ( fetc.tymed & TYMED_HGLOBAL )
 673     {
 674         stgmedium.tymed   = TYMED_HGLOBAL;
 675         stgmedium.hGlobal = stgTransHlp.getHGlobal( );
 676     }
 677     else if ( fetc.tymed & TYMED_ISTREAM )
 678     {
 679         stgmedium.tymed = TYMED_ISTREAM;
 680         stgTransHlp.getIStream( &stgmedium.pstm );
 681     }
 682     else
 683         OSL_ASSERT( sal_False );
 684 }
 685
 686 //------------------------------------------------------------------------
 687 //
 688 //------------------------------------------------------------------------
 689
 690 inline
 691 void SAL_CALL CXTDataObject::invalidateStgMedium( STGMEDIUM& stgmedium ) const
 692 {
 693     stgmedium.tymed = TYMED_NULL;
 694 }
 695
 696 //------------------------------------------------------------------------
 697 //
 698 //------------------------------------------------------------------------
 699
 700 inline
 701 HRESULT SAL_CALL CXTDataObject::translateStgExceptionCode( HRESULT hr ) const
 702 {
 703     HRESULT hrTransl;
 704
 705     switch( hr )
 706     {
 707     case STG_E_MEDIUMFULL:
 708         hrTransl = hr;
 709         break;
 710
 711     default:
 712         hrTransl = E_UNEXPECTED;
 713         break;
 714     }
 715
 716     return hrTransl;
 717 }
 718
 719 //------------------------------------------------------------------------
 720 //
 721 //------------------------------------------------------------------------
 722
 723 inline void SAL_CALL CXTDataObject::InitializeFormatEtcContainer( )
 724 {
 725     if ( !m_bFormatEtcContainerInitialized )
 726     {
 727         m_FormatRegistrar.RegisterFormats( m_XTransferable, m_FormatEtcContainer );
 728         m_bFormatEtcContainerInitialized = sal_True;
 729     }
 730 }
 731
 732 //============================================================================
 733 // CEnumFormatEtc
 734 //============================================================================
 735
 736 //----------------------------------------------------------------------------
 737 // ctor
 738 //----------------------------------------------------------------------------
 739
 740 CEnumFormatEtc::CEnumFormatEtc( LPUNKNOWN lpUnkOuter, const CFormatEtcContainer& aFormatEtcContainer ) :
 741     m_nRefCnt( 0 ),
 742     m_lpUnkOuter( lpUnkOuter ),
 743     m_FormatEtcContainer( aFormatEtcContainer )
 744 {
 745     Reset( );
 746 }
 747
 748 //----------------------------------------------------------------------------
 749 // IUnknown->QueryInterface
 750 //----------------------------------------------------------------------------
 751
 752 STDMETHODIMP CEnumFormatEtc::QueryInterface( REFIID iid, LPVOID* ppvObject )
 753 {
 754     if ( NULL == ppvObject )
 755         return E_INVALIDARG;
 756
 757     HRESULT hr = E_NOINTERFACE;
 758
 759     *ppvObject = NULL;
 760
 761     if ( ( __uuidof( IUnknown ) == iid ) ||
 762          ( __uuidof( IEnumFORMATETC ) == iid ) )
 763     {
 764         *ppvObject = static_cast< IUnknown* >( this );
 765         static_cast< LPUNKNOWN >( *ppvObject )->AddRef( );
 766         hr = S_OK;
 767     }
 768
 769     return hr;
 770 }
 771
 772 //----------------------------------------------------------------------------
 773 // IUnknown->AddRef
 774 //----------------------------------------------------------------------------
 775
 776 STDMETHODIMP_(ULONG) CEnumFormatEtc::AddRef( )
 777 {
 778     // keep the dataobject alive
 779     m_lpUnkOuter->AddRef( );
 780     return InterlockedIncrement( &m_nRefCnt );
 781 }
 782
 783 //----------------------------------------------------------------------------
 784 // IUnknown->Release
 785 //----------------------------------------------------------------------------
 786
 787 STDMETHODIMP_(ULONG) CEnumFormatEtc::Release( )
 788 {
 789     // release the outer dataobject
 790     m_lpUnkOuter->Release( );
 791
 792     ULONG nRefCnt = InterlockedDecrement( &m_nRefCnt );
 793     if ( 0 == nRefCnt )
 794         delete this;
 795
 796     return nRefCnt;
 797 }
 798
 799 //----------------------------------------------------------------------------
 800 // IEnumFORMATETC->Next
 801 //----------------------------------------------------------------------------
 802
 803 STDMETHODIMP CEnumFormatEtc::Next( ULONG nRequested, LPFORMATETC lpDest, ULONG* lpFetched )
 804 {
 805     if ( ( nRequested < 1 ) ||
 806          (( nRequested > 1 ) && ( NULL == lpFetched )) ||
 807          IsBadWritePtr( lpDest, sizeof( FORMATETC ) * nRequested ) )
 808         return E_INVALIDARG;
 809
 810     sal_uInt32 nFetched = m_FormatEtcContainer.nextFormatEtc( lpDest, nRequested );
 811
 812     if ( NULL != lpFetched )
 813         *lpFetched = nFetched;
 814
 815     return (nFetched == nRequested) ? S_OK : S_FALSE;
 816 }
 817
 818 //----------------------------------------------------------------------------
 819 // IEnumFORMATETC->Skip
 820 //----------------------------------------------------------------------------
 821
 822 STDMETHODIMP CEnumFormatEtc::Skip( ULONG celt )
 823 {
 824     return m_FormatEtcContainer.skipFormatEtc( celt ) ? S_OK : S_FALSE;
 825 }
 826
 827 //----------------------------------------------------------------------------
 828 // IEnumFORMATETC->Reset
 829 //----------------------------------------------------------------------------
 830
 831 STDMETHODIMP CEnumFormatEtc::Reset( )
 832 {
 833     m_FormatEtcContainer.beginEnumFormatEtc( );
 834     return S_OK;
 835 }
 836
 837 //----------------------------------------------------------------------------
 838 // IEnumFORMATETC->Clone
 839 //----------------------------------------------------------------------------
 840
 841 STDMETHODIMP CEnumFormatEtc::Clone( IEnumFORMATETC** ppenum )
 842 {
 843     if ( NULL == ppenum )
 844         return E_INVALIDARG;
 845
 846     *ppenum = new CEnumFormatEtc( m_lpUnkOuter, m_FormatEtcContainer );
 847     if ( NULL != ppenum )
 848         static_cast< LPUNKNOWN >( *ppenum )->AddRef( );
 849
 850     return ( NULL != *ppenum ) ? S_OK : E_OUTOFMEMORY;
 851 }