vcl/win/dtrans/XTDataObject.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <osl/diagnose.h>
  21 #include <o3tl/char16_t2wchar_t.hxx>
  22 #include <o3tl/safeint.hxx>
  23
  24 #include "XTDataObject.hxx"
  25 #include <com/sun/star/datatransfer/DataFlavor.hpp>
  26 #include "ImplHelper.hxx"
  27 #include "DTransHelper.hxx"
  28 #include "TxtCnvtHlp.hxx"
  29 #include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>
  30 #include <com/sun/star/datatransfer/clipboard/XClipboardEx.hpp>
  31 #include <com/sun/star/awt/AsyncCallback.hpp>
  32 #include <com/sun/star/awt/XCallback.hpp>
  33 #include "FmtFilter.hxx"
  34 #include <cppuhelper/implbase.hxx>
  35
  36 #if !defined WIN32_LEAN_AND_MEAN
  37 # define WIN32_LEAN_AND_MEAN
  38 #endif
  39 #include <windows.h>
  40 #include <shlobj.h>
  41
  42 using namespace com::sun::star::datatransfer;
  43 using namespace com::sun::star::datatransfer::clipboard;
  44 using namespace com::sun::star::uno;
  45 using namespace com::sun::star::lang;
  46
  47 namespace {
  48
  49 void setupStgMedium( const FORMATETC& fetc,
  50                                              CStgTransferHelper& stgTransHlp,
  51                                              STGMEDIUM& stgmedium )
  52 {
  53     stgmedium.pUnkForRelease = nullptr;
  54
  55     if ( fetc.cfFormat == CF_METAFILEPICT )
  56     {
  57         stgmedium.tymed         = TYMED_MFPICT;
  58         stgmedium.hMetaFilePict = static_cast< HMETAFILEPICT >( stgTransHlp.getHGlobal( ) );
  59     }
  60     else if ( fetc.cfFormat == CF_ENHMETAFILE )
  61     {
  62         stgmedium.tymed        = TYMED_ENHMF;
  63         stgmedium.hEnhMetaFile = static_cast< HENHMETAFILE >( stgTransHlp.getHGlobal( ) );
  64     }
  65     else if ( fetc.tymed & TYMED_HGLOBAL )
  66     {
  67         stgmedium.tymed   = TYMED_HGLOBAL;
  68         stgmedium.hGlobal = stgTransHlp.getHGlobal( );
  69     }
  70     else if ( fetc.tymed & TYMED_ISTREAM )
  71     {
  72         stgmedium.tymed = TYMED_ISTREAM;
  73         stgTransHlp.getIStream( &stgmedium.pstm );
  74     }
  75     else
  76         OSL_ASSERT( false );
  77 }
  78
  79 /**
  80    We need to destroy XTransferable in the main thread to avoid dead lock
  81    when locking in the clipboard thread. So we transfer the ownership of the
  82    XTransferable reference to this object and release it when the callback
  83    is executed in main thread.
  84 */
  85 class AsyncDereference : public cppu::WeakImplHelper<css::awt::XCallback>
  86 {
  87     Reference<XTransferable> maTransferable;
  88
  89 public:
  90     AsyncDereference(css::uno::Reference<css::datatransfer::XTransferable> const & rTransferable)
  91         : maTransferable(rTransferable)
  92     {}
  93
  94     virtual void SAL_CALL notify(css::uno::Any const &) override
  95     {
  96         maTransferable.clear();
  97     }
  98 };
  99
 100 // a helper class that will be thrown by the function validateFormatEtc
 101
 102 class CInvalidFormatEtcException
 103 {
 104 public:
 105     HRESULT m_hr;
 106     explicit CInvalidFormatEtcException( HRESULT hr ) : m_hr( hr ) {};
 107 };
 108
 109 void validateFormatEtc( LPFORMATETC lpFormatEtc )
 110 {
 111     assert(lpFormatEtc);
 112
 113     if ( lpFormatEtc->lindex != -1 )
 114         throw CInvalidFormatEtcException( DV_E_LINDEX );
 115
 116     if ( !(lpFormatEtc->dwAspect & DVASPECT_CONTENT) &&
 117          !(lpFormatEtc->dwAspect & DVASPECT_SHORTNAME) )
 118         throw CInvalidFormatEtcException( DV_E_DVASPECT );
 119
 120     if ( !(lpFormatEtc->tymed & TYMED_HGLOBAL) &&
 121          !(lpFormatEtc->tymed & TYMED_ISTREAM) &&
 122          !(lpFormatEtc->tymed & TYMED_MFPICT) &&
 123          !(lpFormatEtc->tymed & TYMED_ENHMF) )
 124         throw CInvalidFormatEtcException( DV_E_TYMED );
 125
 126     if ( lpFormatEtc->cfFormat == CF_METAFILEPICT &&
 127          !(lpFormatEtc->tymed & TYMED_MFPICT) )
 128         throw CInvalidFormatEtcException( DV_E_TYMED );
 129
 130     if ( lpFormatEtc->cfFormat == CF_ENHMETAFILE &&
 131          !(lpFormatEtc->tymed & TYMED_ENHMF) )
 132         throw CInvalidFormatEtcException( DV_E_TYMED );
 133 }
 134
 135 void invalidateStgMedium( STGMEDIUM& stgmedium )
 136 {
 137     stgmedium.tymed = TYMED_NULL;
 138 }
 139
 140 HRESULT translateStgExceptionCode( HRESULT hr )
 141 {
 142     HRESULT hrTransl;
 143
 144     switch( hr )
 145     {
 146     case STG_E_MEDIUMFULL:
 147         hrTransl = hr;
 148         break;
 149
 150     default:
 151         hrTransl = E_UNEXPECTED;
 152         break;
 153     }
 154
 155     return hrTransl;
 156 }
 157
 158 // inline
 159 void renderDataAndSetupStgMedium(
 160     const sal_Int8* lpStorage, const FORMATETC& fetc, sal_uInt32 nInitStgSize,
 161     sal_uInt32 nBytesToTransfer, STGMEDIUM& stgmedium )
 162 {
 163     OSL_PRECOND( !nInitStgSize || (nInitStgSize >= nBytesToTransfer),
 164                  "Memory size less than number of bytes to transfer" );
 165
 166     CStgTransferHelper stgTransfHelper( AUTO_INIT );
 167
 168     // setup storage size
 169     if ( nInitStgSize > 0 )
 170         stgTransfHelper.init( nInitStgSize );
 171
 172 #if OSL_DEBUG_LEVEL > 0
 173     sal_uInt32 nBytesWritten = 0;
 174     stgTransfHelper.write( lpStorage, nBytesToTransfer, &nBytesWritten );
 175     OSL_ASSERT( nBytesWritten == nBytesToTransfer );
 176 #else
 177     stgTransfHelper.write( lpStorage, nBytesToTransfer );
 178 #endif
 179
 180     setupStgMedium( fetc, stgTransfHelper, stgmedium );
 181 }
 182
 183 }
 184
 185 CXTDataObject::CXTDataObject( const Reference< XComponentContext >& rxContext,
 186                               const Reference< XTransferable >& aXTransferable )
 187     : m_nRefCnt( 0 )
 188     , m_XTransferable( aXTransferable )
 189     , m_XComponentContext( rxContext )
 190     , m_bFormatEtcContainerInitialized( false )
 191     , m_DataFormatTranslator( rxContext )
 192     , m_FormatRegistrar( rxContext, m_DataFormatTranslator )
 193 {
 194 }
 195
 196 CXTDataObject::~CXTDataObject()
 197 {
 198     css::awt::AsyncCallback::create(m_XComponentContext)->addCallback(
 199         new AsyncDereference(m_XTransferable),
 200         css::uno::Any());
 201 }
 202
 203 // IUnknown->QueryInterface
 204
 205 STDMETHODIMP CXTDataObject::QueryInterface( REFIID iid, void** ppvObject )
 206 {
 207     if ( nullptr == ppvObject )
 208         return E_INVALIDARG;
 209
 210     HRESULT hr = E_NOINTERFACE;
 211
 212     *ppvObject = nullptr;
 213     if ( ( __uuidof( IUnknown ) == iid ) ||
 214          ( __uuidof( IDataObject ) == iid ) )
 215     {
 216         *ppvObject = static_cast< IUnknown* >( this );
 217         static_cast<LPUNKNOWN>(*ppvObject)->AddRef( );
 218         hr = S_OK;
 219     }
 220
 221     return hr;
 222 }
 223
 224 // IUnknown->AddRef
 225
 226 STDMETHODIMP_(ULONG) CXTDataObject::AddRef( )
 227 {
 228     return static_cast< ULONG >( InterlockedIncrement( &m_nRefCnt ) );
 229 }
 230
 231 // IUnknown->Release
 232
 233 STDMETHODIMP_(ULONG) CXTDataObject::Release( )
 234 {
 235     ULONG nRefCnt =
 236         static_cast< ULONG >( InterlockedDecrement( &m_nRefCnt ) );
 237
 238     if ( 0 == nRefCnt )
 239         delete this;
 240
 241     return nRefCnt;
 242 }
 243
 244 STDMETHODIMP CXTDataObject::GetData( FORMATETC * pFormatetc, STGMEDIUM * pmedium )
 245 {
 246     if ( !(pFormatetc && pmedium) )
 247         return E_INVALIDARG;
 248
 249     try
 250     {
 251         // prepare data transfer
 252         invalidateStgMedium( *pmedium );
 253         validateFormatEtc( pFormatetc );
 254
 255         // handle locale request, because locale is an artificial format for us
 256         if ( CF_LOCALE == pFormatetc->cfFormat )
 257             renderLocaleAndSetupStgMedium( *pFormatetc, *pmedium );
 258         else if ( CF_UNICODETEXT == pFormatetc->cfFormat )
 259             renderUnicodeAndSetupStgMedium( *pFormatetc, *pmedium );
 260         else
 261             renderAnyDataAndSetupStgMedium( *pFormatetc, *pmedium );
 262     }
 263     catch(UnsupportedFlavorException&)
 264     {
 265         HRESULT hr = DV_E_FORMATETC;
 266
 267         CFormatEtc aFormatetc(*pFormatetc);
 268         if (CFormatRegistrar::isSynthesizeableFormat(aFormatetc))
 269             hr = renderSynthesizedFormatAndSetupStgMedium( *pFormatetc, *pmedium );
 270
 271         return hr;
 272     }
 273     catch( CInvalidFormatEtcException& ex )
 274     {
 275         return ex.m_hr;
 276     }
 277     catch( CStgTransferHelper::CStgTransferException& ex )
 278     {
 279         return translateStgExceptionCode( ex.m_hr );
 280     }
 281     catch(...)
 282     {
 283         return E_UNEXPECTED;
 284     }
 285
 286     return S_OK;
 287 }
 288
 289 //inline
 290 void CXTDataObject::renderLocaleAndSetupStgMedium(
 291     FORMATETC const & fetc, STGMEDIUM& stgmedium )
 292 {
 293     if ( !m_FormatRegistrar.hasSynthesizedLocale( ) )
 294         throw CInvalidFormatEtcException( DV_E_FORMATETC );
 295     LCID lcid = CFormatRegistrar::getSynthesizedLocale( );
 296     renderDataAndSetupStgMedium(
 297         reinterpret_cast< sal_Int8* >( &lcid ),
 298         fetc,
 299         0,
 300         sizeof( LCID ),
 301         stgmedium );
 302 }
 303
 304 void CXTDataObject::renderUnicodeAndSetupStgMedium(
 305     FORMATETC const & fetc, STGMEDIUM& stgmedium )
 306 {
 307     DataFlavor aFlavor = formatEtcToDataFlavor( fetc );
 308
 309     Any aAny = m_XTransferable->getTransferData( aFlavor );
 310
 311     // unfortunately not all transferables fulfill the
 312     // spec. and do throw an UnsupportedFlavorException
 313     // so we must check the any
 314     if ( !aAny.hasValue( ) )
 315     {
 316         OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
 317         throw UnsupportedFlavorException( );
 318     }
 319
 320     OUString aText;
 321     aAny >>= aText;
 322
 323     sal_uInt32 nBytesToTransfer = aText.getLength( ) * sizeof( sal_Unicode );
 324
 325     // to be sure there is an ending 0
 326     sal_uInt32 nRequiredMemSize = nBytesToTransfer + sizeof( sal_Unicode );
 327
 328     renderDataAndSetupStgMedium(
 329         reinterpret_cast< const sal_Int8* >( aText.getStr( ) ),
 330         fetc,
 331         nRequiredMemSize,
 332         nBytesToTransfer,
 333         stgmedium );
 334 }
 335
 336 void CXTDataObject::renderAnyDataAndSetupStgMedium(
 337     FORMATETC& fetc, STGMEDIUM& stgmedium )
 338 {
 339     DataFlavor aFlavor = formatEtcToDataFlavor( fetc );
 340
 341     Any aAny = m_XTransferable->getTransferData( aFlavor );
 342
 343     // unfortunately not all transferables fulfill the
 344     // spec. and do throw an UnsupportedFlavorException
 345     // so we must check the any
 346     if ( !aAny.hasValue( ) )
 347     {
 348         OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
 349         throw UnsupportedFlavorException( );
 350     }
 351
 352     Sequence< sal_Int8 > clipDataStream;
 353     aAny >>= clipDataStream;
 354
 355     sal_uInt32 nRequiredMemSize = 0;
 356     if ( CDataFormatTranslator::isOemOrAnsiTextFormat( fetc.cfFormat ) )
 357         nRequiredMemSize = sizeof( sal_Int8 ) * clipDataStream.getLength( ) + 1;
 358
 359     // prepare data for transmission
 360     // #i124085# DIBV5 should not happen for now, but keep as hint here
 361     if ( CF_DIBV5 == fetc.cfFormat || CF_DIB == fetc.cfFormat )
 362     {
 363 #ifdef DBG_UTIL
 364         if(CF_DIBV5 == fetc.cfFormat)
 365         {
 366             OSL_ENSURE(o3tl::make_unsigned(clipDataStream.getLength()) > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPV5HEADER)), "Wrong size on CF_DIBV5 data (!)");
 367         }
 368         else // CF_DIB == fetc.cfFormat
 369         {
 370             OSL_ENSURE(o3tl::make_unsigned(clipDataStream.getLength()) > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)), "Wrong size on CF_DIB data (!)");
 371         }
 372 #endif
 373
 374         // remove BITMAPFILEHEADER
 375         clipDataStream = OOBmpToWinDIB( clipDataStream );
 376     }
 377
 378     if ( CF_METAFILEPICT == fetc.cfFormat )
 379     {
 380         stgmedium.tymed          = TYMED_MFPICT;
 381         stgmedium.hMetaFilePict  = OOMFPictToWinMFPict( clipDataStream );
 382         stgmedium.pUnkForRelease = nullptr;
 383     }
 384     else if( CF_ENHMETAFILE == fetc.cfFormat )
 385     {
 386         stgmedium.tymed          = TYMED_ENHMF;
 387         stgmedium.hMetaFilePict  = OOMFPictToWinENHMFPict( clipDataStream );
 388         stgmedium.pUnkForRelease = nullptr;
 389     }
 390     else
 391         renderDataAndSetupStgMedium(
 392             clipDataStream.getArray( ),
 393             fetc,
 394             nRequiredMemSize,
 395             clipDataStream.getLength( ),
 396             stgmedium );
 397 }
 398
 399 HRESULT CXTDataObject::renderSynthesizedFormatAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
 400 {
 401     HRESULT hr = S_OK;
 402
 403     try
 404     {
 405         if ( CF_UNICODETEXT == fetc.cfFormat )
 406             // the transferable seems to have only text
 407             renderSynthesizedUnicodeAndSetupStgMedium( fetc, stgmedium );
 408         else if ( CDataFormatTranslator::isOemOrAnsiTextFormat( fetc.cfFormat ) )
 409             // the transferable seems to have only unicode text
 410             renderSynthesizedTextAndSetupStgMedium( fetc, stgmedium );
 411         else
 412             // the transferable seems to have only text/html
 413             renderSynthesizedHtmlAndSetupStgMedium( fetc, stgmedium );
 414     }
 415     catch(UnsupportedFlavorException&)
 416     {
 417         hr = DV_E_FORMATETC;
 418     }
 419     catch( CInvalidFormatEtcException& )
 420     {
 421         OSL_FAIL( "Unexpected exception" );
 422     }
 423     catch( CStgTransferHelper::CStgTransferException& ex )
 424     {
 425         return translateStgExceptionCode( ex.m_hr );
 426     }
 427     catch(...)
 428     {
 429         hr = E_UNEXPECTED;
 430     }
 431
 432     return hr;
 433 }
 434
 435 // the transferable must have only text, so we will synthesize unicode text
 436
 437 void CXTDataObject::renderSynthesizedUnicodeAndSetupStgMedium( FORMATETC const & fetc, STGMEDIUM& stgmedium )
 438 {
 439     OSL_ASSERT( CF_UNICODETEXT == fetc.cfFormat );
 440
 441     Any aAny = m_XTransferable->getTransferData( m_FormatRegistrar.getRegisteredTextFlavor( ) );
 442
 443     // unfortunately not all transferables fulfill the
 444     // spec. and do throw an UnsupportedFlavorException
 445     // so we must check the any
 446     if ( !aAny.hasValue( ) )
 447     {
 448         OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
 449         throw UnsupportedFlavorException( );
 450     }
 451
 452     Sequence< sal_Int8 > aText;
 453     aAny >>= aText;
 454
 455     CStgTransferHelper stgTransfHelper;
 456
 457     MultiByteToWideCharEx(
 458         CFormatRegistrar::getRegisteredTextCodePage( ),
 459         reinterpret_cast< char* >( aText.getArray( ) ),
 460         aText.getLength( ),
 461         stgTransfHelper );
 462
 463     setupStgMedium( fetc, stgTransfHelper, stgmedium );
 464 }
 465
 466 // the transferable must have only unicode text so we will synthesize text
 467
 468 void CXTDataObject::renderSynthesizedTextAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
 469 {
 470     OSL_ASSERT( CDataFormatTranslator::isOemOrAnsiTextFormat( fetc.cfFormat ) );
 471
 472     DataFlavor aFlavor = formatEtcToDataFlavor(
 473         CDataFormatTranslator::getFormatEtcForClipformat( CF_UNICODETEXT ) );
 474
 475     Any aAny = m_XTransferable->getTransferData( aFlavor );
 476
 477     // unfortunately not all transferables fulfill the
 478     // spec. and do throw an UnsupportedFlavorException
 479     // so we must check the any
 480     if ( !aAny.hasValue( ) )
 481     {
 482         OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
 483         throw UnsupportedFlavorException( );
 484     }
 485
 486     OUString aUnicodeText;
 487     aAny >>= aUnicodeText;
 488
 489     CStgTransferHelper stgTransfHelper;
 490
 491     WideCharToMultiByteEx(
 492         GetACP( ),
 493         o3tl::toW( aUnicodeText.getStr( ) ),
 494         aUnicodeText.getLength( ),
 495         stgTransfHelper );
 496
 497     setupStgMedium( fetc, stgTransfHelper, stgmedium );
 498 }
 499
 500 void CXTDataObject::renderSynthesizedHtmlAndSetupStgMedium( FORMATETC& fetc, STGMEDIUM& stgmedium )
 501 {
 502     OSL_ASSERT( CDataFormatTranslator::isHTMLFormat( fetc.cfFormat ) );
 503
 504     DataFlavor aFlavor;
 505
 506     // creating a DataFlavor on the fly
 507     aFlavor.MimeType = "text/html";
 508     aFlavor.DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
 509
 510     Any aAny = m_XTransferable->getTransferData( aFlavor );
 511
 512     // unfortunately not all transferables fulfill the
 513     // spec. and do throw an UnsupportedFlavorException
 514     // so we must check the any
 515     if ( !aAny.hasValue( ) )
 516     {
 517         OSL_FAIL( "XTransferable should throw an exception if ask for an unsupported flavor" );
 518         throw UnsupportedFlavorException( );
 519     }
 520
 521     Sequence< sal_Int8 > aTextHtmlSequence;
 522     aAny >>= aTextHtmlSequence;
 523
 524     Sequence< sal_Int8 > aHTMLFormatSequence = TextHtmlToHTMLFormat( aTextHtmlSequence );
 525
 526     sal_uInt32 nBytesToTransfer = aHTMLFormatSequence.getLength( );
 527
 528     renderDataAndSetupStgMedium(
 529         reinterpret_cast< const sal_Int8* >( aHTMLFormatSequence.getArray( ) ),
 530         fetc,
 531         0,
 532         nBytesToTransfer,
 533         stgmedium );
 534 }
 535
 536 // IDataObject->EnumFormatEtc
 537
 538 STDMETHODIMP CXTDataObject::EnumFormatEtc(
 539     DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc )
 540 {
 541     if ( nullptr == ppenumFormatetc )
 542         return E_INVALIDARG;
 543
 544     if ( DATADIR_SET == dwDirection )
 545         return E_NOTIMPL;
 546
 547     *ppenumFormatetc = nullptr;
 548
 549     InitializeFormatEtcContainer( );
 550
 551     HRESULT hr;
 552     if ( DATADIR_GET == dwDirection )
 553     {
 554         *ppenumFormatetc = new CEnumFormatEtc( this, m_FormatEtcContainer );
 555         static_cast< LPUNKNOWN >( *ppenumFormatetc )->AddRef( );
 556
 557         hr = S_OK;
 558     }
 559     else
 560         hr = E_INVALIDARG;
 561
 562     return hr;
 563 }
 564
 565 // IDataObject->QueryGetData
 566
 567 STDMETHODIMP CXTDataObject::QueryGetData( FORMATETC * pFormatetc )
 568 {
 569     if ( (nullptr == pFormatetc) || IsBadReadPtr( pFormatetc, sizeof( FORMATETC ) ) )
 570         return E_INVALIDARG;
 571
 572     InitializeFormatEtcContainer( );
 573
 574     CFormatEtc aFormatetc(*pFormatetc);
 575     return m_FormatEtcContainer.hasFormatEtc(aFormatetc) ? S_OK : S_FALSE;
 576 }
 577
 578 // IDataObject->GetDataHere
 579
 580 STDMETHODIMP CXTDataObject::GetDataHere( FORMATETC *, STGMEDIUM * )
 581 {
 582     return E_NOTIMPL;
 583 }
 584
 585 // IDataObject->GetCanonicalFormatEtc
 586
 587 STDMETHODIMP CXTDataObject::GetCanonicalFormatEtc( FORMATETC *, FORMATETC * )
 588 {
 589     return E_NOTIMPL;
 590 }
 591
 592 // IDataObject->SetData
 593
 594 STDMETHODIMP CXTDataObject::SetData( FORMATETC *, STGMEDIUM *, BOOL )
 595 {
 596     return E_NOTIMPL;
 597 }
 598
 599 // IDataObject->DAdvise
 600
 601 STDMETHODIMP CXTDataObject::DAdvise( FORMATETC *, DWORD, IAdviseSink *, DWORD * )
 602 {
 603     return E_NOTIMPL;
 604 }
 605
 606 // IDataObject->DUnadvise
 607
 608 STDMETHODIMP CXTDataObject::DUnadvise( DWORD )
 609 {
 610     return E_NOTIMPL;
 611 }
 612
 613 // IDataObject->EnumDAdvise
 614
 615 STDMETHODIMP CXTDataObject::EnumDAdvise( IEnumSTATDATA ** )
 616 {
 617     return E_NOTIMPL;
 618 }
 619
 620 // for our convenience
 621
 622 CXTDataObject::operator IDataObject*( )
 623 {
 624     return static_cast< IDataObject* >( this );
 625 }
 626
 627 inline
 628 DataFlavor CXTDataObject::formatEtcToDataFlavor( const FORMATETC& aFormatEtc ) const
 629 {
 630     DataFlavor aFlavor;
 631
 632     if ( m_FormatRegistrar.hasSynthesizedLocale( ) )
 633         aFlavor = m_DataFormatTranslator.getDataFlavorFromFormatEtc(
 634             aFormatEtc.cfFormat, CFormatRegistrar::getSynthesizedLocale());
 635     else
 636         aFlavor = m_DataFormatTranslator.getDataFlavorFromFormatEtc(aFormatEtc.cfFormat);
 637
 638     if ( !aFlavor.MimeType.getLength( ) )
 639         throw UnsupportedFlavorException( );
 640
 641     return aFlavor;
 642 }
 643
 644 inline void CXTDataObject::InitializeFormatEtcContainer( )
 645 {
 646     if ( !m_bFormatEtcContainerInitialized )
 647     {
 648         m_FormatRegistrar.RegisterFormats( m_XTransferable, m_FormatEtcContainer );
 649         m_bFormatEtcContainerInitialized = true;
 650     }
 651 }
 652
 653 CEnumFormatEtc::CEnumFormatEtc( LPUNKNOWN lpUnkOuter, const CFormatEtcContainer& aFormatEtcContainer ) :
 654     m_nRefCnt( 0 ),
 655     m_lpUnkOuter( lpUnkOuter ),
 656     m_FormatEtcContainer( aFormatEtcContainer )
 657 {
 658     Reset( );
 659 }
 660
 661 // IUnknown->QueryInterface
 662
 663 STDMETHODIMP CEnumFormatEtc::QueryInterface( REFIID iid, void** ppvObject )
 664 {
 665     if ( nullptr == ppvObject )
 666         return E_INVALIDARG;
 667
 668     HRESULT hr = E_NOINTERFACE;
 669
 670     *ppvObject = nullptr;
 671
 672     if ( ( __uuidof( IUnknown ) == iid ) ||
 673          ( __uuidof( IEnumFORMATETC ) == iid ) )
 674     {
 675         *ppvObject = static_cast< IUnknown* >( this );
 676         static_cast< LPUNKNOWN >( *ppvObject )->AddRef( );
 677         hr = S_OK;
 678     }
 679
 680     return hr;
 681 }
 682
 683 // IUnknown->AddRef
 684
 685 STDMETHODIMP_(ULONG) CEnumFormatEtc::AddRef( )
 686 {
 687     // keep the dataobject alive
 688     m_lpUnkOuter->AddRef( );
 689     return InterlockedIncrement( &m_nRefCnt );
 690 }
 691
 692 // IUnknown->Release
 693
 694 STDMETHODIMP_(ULONG) CEnumFormatEtc::Release( )
 695 {
 696     // release the outer dataobject
 697     m_lpUnkOuter->Release( );
 698
 699     ULONG nRefCnt = InterlockedDecrement( &m_nRefCnt );
 700     if ( 0 == nRefCnt )
 701         delete this;
 702
 703     return nRefCnt;
 704 }
 705
 706 // IEnumFORMATETC->Next
 707
 708 STDMETHODIMP CEnumFormatEtc::Next( ULONG nRequested, FORMATETC * lpDest, ULONG* lpFetched )
 709 {
 710     if ( ( nRequested < 1 ) ||
 711          (( nRequested > 1 ) && ( nullptr == lpFetched )) ||
 712          IsBadWritePtr( lpDest, sizeof( FORMATETC ) * nRequested ) )
 713         return E_INVALIDARG;
 714
 715     sal_uInt32 nFetched = m_FormatEtcContainer.nextFormatEtc( lpDest, nRequested );
 716
 717     if ( nullptr != lpFetched )
 718         *lpFetched = nFetched;
 719
 720     return (nFetched == nRequested) ? S_OK : S_FALSE;
 721 }
 722
 723 // IEnumFORMATETC->Skip
 724
 725 STDMETHODIMP CEnumFormatEtc::Skip( ULONG celt )
 726 {
 727     return m_FormatEtcContainer.skipFormatEtc( celt ) ? S_OK : S_FALSE;
 728 }
 729
 730 // IEnumFORMATETC->Reset
 731
 732 STDMETHODIMP CEnumFormatEtc::Reset( )
 733 {
 734     m_FormatEtcContainer.beginEnumFormatEtc( );
 735     return S_OK;
 736 }
 737
 738 // IEnumFORMATETC->Clone
 739
 740 STDMETHODIMP CEnumFormatEtc::Clone( IEnumFORMATETC** ppenum )
 741 {
 742     if ( nullptr == ppenum )
 743         return E_INVALIDARG;
 744
 745     *ppenum = new CEnumFormatEtc( m_lpUnkOuter, m_FormatEtcContainer );
 746     static_cast< LPUNKNOWN >( *ppenum )->AddRef( );
 747
 748     return S_OK;
 749 }
 750
 751 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */