dtrans/source/win32/workbench/XTDo.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: XTDo.cxx,v $
  10  * $Revision: 1.6 $
  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 #include "..\DTransHelper.hxx"
  40
  41 #ifndef _TWRAPPERDATAOBJECT_HXX_
  42 #include "XTDo.hxx"
  43 #endif
  44
  45 #if defined _MSC_VER
  46 #pragma warning(push,1)
  47 #endif
  48 #include <windows.h>
  49 #include <ole2.h>
  50 #if defined _MSC_VER
  51 #pragma warning(pop)
  52 #endif
  53 #include <memory>
  54 #include <tchar.h>
  55
  56 //------------------------------------------------------------------------
  57 // namespace directives
  58 //------------------------------------------------------------------------
  59
  60 using namespace ::std;
  61
  62 //============================================================================
  63 // OTWrapperDataObject
  64 //============================================================================
  65
  66 //------------------------------------------------------------------------
  67 // ctor
  68 //------------------------------------------------------------------------
  69 /*
  70     in the constructor we enumerate all formats offered by the transferable
  71     and convert the formats into formatetc structures
  72     if the transferable supports text in different charsets we use either
  73     the charset equal to the charset of the current thread or an arbitrary
  74     charset supported by the transferable and the system
  75     if the transferable supports only unicodetext we offer in addition to
  76     this text in the charset of the current thread
  77     in order to allow the consumer of the clipboard to query for the charset
  78     of the text in the clipboard we offer a CF_LOCALE
  79 */
  80 CXTDataObject::CXTDataObject( ) :
  81     m_nRefCnt( 0 )
  82 {
  83
  84 }
  85
  86 //------------------------------------------------------------------------
  87 // IUnknown->QueryInterface
  88 //------------------------------------------------------------------------
  89
  90 STDMETHODIMP CXTDataObject::QueryInterface( REFIID iid, LPVOID* ppvObject )
  91 {
  92     OSL_ASSERT( NULL != ppvObject );
  93
  94     if ( NULL == ppvObject )
  95         return E_INVALIDARG;
  96
  97     HRESULT hr = E_NOINTERFACE;
  98
  99     *ppvObject = NULL;
 100
 101     if ( ( __uuidof( IUnknown ) == iid ) || ( __uuidof( IDataObject ) == iid ) )
 102     {
 103         *ppvObject = static_cast< IUnknown* >( this );
 104         ( (LPUNKNOWN)*ppvObject )->AddRef( );
 105         hr = S_OK;
 106     }
 107
 108     return hr;
 109 }
 110
 111 //------------------------------------------------------------------------
 112 // IUnknown->AddRef
 113 //------------------------------------------------------------------------
 114
 115 STDMETHODIMP_(ULONG) CXTDataObject::AddRef( )
 116 {
 117     return static_cast< ULONG >( InterlockedIncrement( &m_nRefCnt ) );
 118 }
 119
 120 //------------------------------------------------------------------------
 121 // IUnknown->Release
 122 //------------------------------------------------------------------------
 123
 124 STDMETHODIMP_(ULONG) CXTDataObject::Release( )
 125 {
 126     // we need a helper variable because it's
 127     // not allowed to access a member variable
 128     // after an object is destroyed
 129     ULONG nRefCnt = static_cast< ULONG >( InterlockedDecrement( &m_nRefCnt ) );
 130
 131     if ( 0 == nRefCnt )
 132     {
 133         delete this;
 134     }
 135
 136     return nRefCnt;
 137 }
 138
 139 /*------------------------------------------------------------------------
 140
 141  IDataObject->GetData
 142  we deliver data only into global memory
 143
 144  algo:
 145  1. convert the given formatect struct into a valid dataflavor
 146  2. if the transferable directly supports the requested format
 147  2.1. if text data requested add a trailing '\0' in order to prevent
 148         problems (windows needs '\0' terminated strings
 149  2.2. we expect unicode data as Sequence< sal_Unicode > and all other
 150         text and raw data as Sequence< sal_Int8 >
 151
 152 ------------------------------------------------------------------------*/
 153
 154 STDMETHODIMP CXTDataObject::GetData( LPFORMATETC pFormatetc, LPSTGMEDIUM pmedium )
 155 {
 156     if ( ( NULL == pFormatetc ) || ( NULL == pmedium ) )
 157         return E_INVALIDARG;
 158
 159     HRESULT hr = E_FAIL;
 160     char    pBuff[] = "Test OleClipboard";
 161
 162     if ( CF_TEXT == pFormatetc->cfFormat )
 163     {
 164         CHGlobalHelper hGlobHlp( TRUE );
 165
 166         hGlobHlp.Write( pBuff, sizeof( pBuff ), NULL );
 167
 168         pmedium->tymed          = TYMED_HGLOBAL;
 169         pmedium->hGlobal        = hGlobHlp.GetHGlobal( );
 170         pmedium->pUnkForRelease = NULL;
 171
 172         hr = S_OK;
 173     }
 174
 175     return hr;
 176 }
 177
 178 //------------------------------------------------------------------------
 179 // IDataObject->EnumFormatEtc
 180 //------------------------------------------------------------------------
 181
 182 STDMETHODIMP CXTDataObject::EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc )
 183 {
 184     if ( ( NULL == ppenumFormatetc ) || ( DATADIR_SET == dwDirection ) )
 185         return E_INVALIDARG;
 186
 187     *ppenumFormatetc = NULL;
 188
 189     HRESULT hr = E_FAIL;
 190
 191     if ( DATADIR_GET == dwDirection )
 192     {
 193         *ppenumFormatetc = new CEnumFormatEtc( this );
 194         static_cast< LPUNKNOWN >( *ppenumFormatetc )->AddRef( );
 195         hr = S_OK;
 196     }
 197
 198     return hr;
 199 }
 200
 201 //------------------------------------------------------------------------
 202 // IDataObject->QueryGetData
 203 //------------------------------------------------------------------------
 204
 205 STDMETHODIMP CXTDataObject::QueryGetData( LPFORMATETC pFormatetc )
 206 {
 207     return E_NOTIMPL;
 208 }
 209
 210 //------------------------------------------------------------------------
 211 // IDataObject->GetDataHere
 212 //------------------------------------------------------------------------
 213
 214 STDMETHODIMP CXTDataObject::GetDataHere( LPFORMATETC, LPSTGMEDIUM )
 215 {
 216     return E_NOTIMPL;
 217 }
 218
 219 //------------------------------------------------------------------------
 220 // IDataObject->GetCanonicalFormatEtc
 221 //------------------------------------------------------------------------
 222
 223 STDMETHODIMP CXTDataObject::GetCanonicalFormatEtc( LPFORMATETC, LPFORMATETC )
 224 {
 225     return E_NOTIMPL;
 226 }
 227
 228 //------------------------------------------------------------------------
 229 // IDataObject->SetData
 230 //------------------------------------------------------------------------
 231
 232 STDMETHODIMP CXTDataObject::SetData( LPFORMATETC, LPSTGMEDIUM, BOOL )
 233 {
 234     return E_NOTIMPL;
 235 }
 236
 237 //------------------------------------------------------------------------
 238 // IDataObject->DAdvise
 239 //------------------------------------------------------------------------
 240
 241 STDMETHODIMP CXTDataObject::DAdvise( LPFORMATETC, DWORD, LPADVISESINK, DWORD * )
 242 {
 243     return E_NOTIMPL;
 244 }
 245
 246 //------------------------------------------------------------------------
 247 // IDataObject->DUnadvise
 248 //------------------------------------------------------------------------
 249
 250 STDMETHODIMP CXTDataObject::DUnadvise( DWORD )
 251 {
 252     return E_NOTIMPL;
 253 }
 254
 255 //------------------------------------------------------------------------
 256 // IDataObject->EnumDAdvise
 257 //------------------------------------------------------------------------
 258
 259 STDMETHODIMP CXTDataObject::EnumDAdvise( LPENUMSTATDATA * )
 260 {
 261     return E_NOTIMPL;
 262 }
 263
 264 //------------------------------------------------------------------------
 265 // for our convenience
 266 //------------------------------------------------------------------------
 267
 268 CXTDataObject::operator IDataObject*( )
 269 {
 270     return static_cast< IDataObject* >( this );
 271 }
 272
 273
 274 //============================================================================
 275 // CEnumFormatEtc
 276 //============================================================================
 277
 278 //----------------------------------------------------------------------------
 279 // ctor
 280 //----------------------------------------------------------------------------
 281
 282 CEnumFormatEtc::CEnumFormatEtc( LPUNKNOWN pUnkDataObj ) :
 283     m_nRefCnt( 0 ),
 284     m_pUnkDataObj( pUnkDataObj ),
 285     m_nCurrPos( 0 )
 286 {
 287 }
 288
 289 //----------------------------------------------------------------------------
 290 // IUnknown->QueryInterface
 291 //----------------------------------------------------------------------------
 292
 293 STDMETHODIMP CEnumFormatEtc::QueryInterface( REFIID iid, LPVOID* ppvObject )
 294 {
 295     if ( NULL == ppvObject )
 296         return E_INVALIDARG;
 297
 298     HRESULT hr = E_NOINTERFACE;
 299
 300     *ppvObject = NULL;
 301
 302     if ( ( __uuidof( IUnknown ) == iid ) || ( __uuidof( IEnumFORMATETC ) == iid ) )
 303     {
 304         *ppvObject = static_cast< IUnknown* >( this );
 305         static_cast< LPUNKNOWN >( *ppvObject )->AddRef( );
 306         hr = S_OK;
 307     }
 308
 309     return hr;
 310 }
 311
 312 //----------------------------------------------------------------------------
 313 // IUnknown->AddRef
 314 //----------------------------------------------------------------------------
 315
 316 STDMETHODIMP_(ULONG) CEnumFormatEtc::AddRef( )
 317 {
 318     // keep the dataobject alive
 319     m_pUnkDataObj->AddRef( );
 320     return InterlockedIncrement( &m_nRefCnt );
 321 }
 322
 323 //----------------------------------------------------------------------------
 324 // IUnknown->Release
 325 //----------------------------------------------------------------------------
 326
 327 STDMETHODIMP_(ULONG) CEnumFormatEtc::Release( )
 328 {
 329     // release the outer dataobject
 330     m_pUnkDataObj->Release( );
 331
 332     // we need a helper variable because it's
 333     // not allowed to access a member variable
 334     // after an object is destroyed
 335     ULONG nRefCnt = InterlockedDecrement( &m_nRefCnt );
 336     if ( 0 == nRefCnt )
 337         delete this;
 338
 339     return nRefCnt;
 340 }
 341
 342 //----------------------------------------------------------------------------
 343 // IEnumFORMATETC->Next
 344 //----------------------------------------------------------------------------
 345
 346 STDMETHODIMP CEnumFormatEtc::Next( ULONG celt, LPFORMATETC rgelt, ULONG* pceltFetched )
 347 {
 348     if ( ( 0 != celt ) && ( NULL == rgelt ) )
 349         return E_INVALIDARG;
 350
 351     ULONG   ulFetched = 0;
 352     ULONG   ulToFetch = celt;
 353     HRESULT hr        = S_FALSE;
 354
 355     while( m_nCurrPos < 1 )
 356     {
 357         rgelt->cfFormat = CF_TEXT;
 358         rgelt->ptd      = NULL;
 359         rgelt->dwAspect = DVASPECT_CONTENT;
 360         rgelt->lindex   = -1;
 361         rgelt->tymed    = TYMED_HGLOBAL;
 362
 363         ++m_nCurrPos;
 364         ++rgelt;
 365         --ulToFetch;
 366         ++ulFetched;
 367     }
 368
 369     if ( ulFetched == celt )
 370         hr = S_OK;
 371
 372     if ( NULL != pceltFetched )
 373     {
 374         *pceltFetched = ulFetched;
 375     }
 376
 377     return hr;
 378 }
 379
 380 //----------------------------------------------------------------------------
 381 // IEnumFORMATETC->Skip
 382 //----------------------------------------------------------------------------
 383
 384 STDMETHODIMP CEnumFormatEtc::Skip( ULONG celt )
 385 {
 386     HRESULT hr = S_FALSE;
 387
 388     /*
 389     if ( ( m_nCurrPos + celt ) < m_nClipFormats )
 390     {
 391         m_nCurrPos += celt;
 392         hr = S_OK;
 393     }
 394     */
 395
 396     return hr;
 397 }
 398
 399 //----------------------------------------------------------------------------
 400 // IEnumFORMATETC->Reset
 401 //----------------------------------------------------------------------------
 402
 403 STDMETHODIMP CEnumFormatEtc::Reset( )
 404 {
 405     m_nCurrPos = 0;
 406     return S_OK;
 407 }
 408
 409 //----------------------------------------------------------------------------
 410 // IEnumFORMATETC->Clone
 411 //----------------------------------------------------------------------------
 412
 413 STDMETHODIMP CEnumFormatEtc::Clone( IEnumFORMATETC** ppenum )
 414 {
 415     OSL_ASSERT( NULL != ppenum );
 416
 417     if ( NULL == ppenum )
 418         return E_INVALIDARG;
 419
 420     HRESULT hr = E_FAIL;
 421
 422     *ppenum = NULL;
 423
 424     CEnumFormatEtc* pCEnumFEtc = new CEnumFormatEtc( m_pUnkDataObj );
 425     if ( NULL != pCEnumFEtc )
 426     {
 427         pCEnumFEtc->m_nCurrPos = m_nCurrPos;
 428         *ppenum = static_cast< IEnumFORMATETC* >( pCEnumFEtc );
 429         static_cast< LPUNKNOWN >( *ppenum )->AddRef( );
 430         hr = NOERROR;
 431     }
 432
 433     return hr;
 434 }