dtrans/source/win32/clipb/MtaOleClipb.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 /*
  21     MtaOleClipb.cxx - documentation
  22
  23     This class setup a single threaded apartment (sta) thread to deal with
  24     the ole clipboard, which runs only in an sta thread.
  25     The consequence is that callback from the ole clipboard are in the
  26     context of this sta thread. In the soffice applications this may lead
  27     to problems because they all use the one and only mutex called
  28     SolarMutex.
  29     In order to transfer clipboard requests to our sta thread we use a
  30     hidden window an forward these requests via window messages.
  31 */
  32
  33 #ifdef _MSC_VER
  34 #pragma warning( disable : 4786 ) // identifier was truncated to 'number'
  35                                    // characters in the debug information
  36 #endif
  37
  38 //#define UNICODE
  39 #include <osl/diagnose.h>
  40
  41 #include "MtaOleClipb.hxx"
  42 #include <osl/conditn.hxx>
  43 #include <osl/thread.h>
  44
  45 #include <wchar.h>
  46 #include <process.h>
  47
  48 #include <systools/win32/comtools.hxx>
  49 #ifdef __MINGW32__
  50 #if defined __uuidof
  51 #undef __uuidof
  52 #endif
  53 #define __uuidof(I) IID_##I
  54 #endif
  55
  56 //  namespace directives
  57
  58 using osl::Condition;
  59 using osl::Mutex;
  60 using osl::MutexGuard;
  61 using osl::ClearableMutexGuard;
  62
  63 namespace /* private */
  64 {
  65     char CLIPSRV_DLL_NAME[] = "sysdtrans.dll";
  66     char g_szWndClsName[]   = "MtaOleReqWnd###";
  67
  68     // messages constants
  69
  70     const sal_uInt32 MSG_SETCLIPBOARD               = WM_USER + 0x0001;
  71     const sal_uInt32 MSG_GETCLIPBOARD               = WM_USER + 0x0002;
  72     const sal_uInt32 MSG_REGCLIPVIEWER              = WM_USER + 0x0003;
  73     const sal_uInt32 MSG_FLUSHCLIPBOARD             = WM_USER + 0x0004;
  74     const sal_uInt32 MSG_SHUTDOWN                   = WM_USER + 0x0005;
  75
  76     const sal_uInt32 MAX_WAITTIME                   = 10000;  // msec
  77     const sal_uInt32 MAX_WAIT_SHUTDOWN              = 10000; // msec
  78     const sal_uInt32 MAX_CLIPEVENT_PROCESSING_TIME  = 5000;  // msec
  79
  80     const sal_Bool MANUAL_RESET                     = sal_True;
  81     const sal_Bool AUTO_RESET                       = sal_False;
  82     const sal_Bool INIT_NONSIGNALED                 = sal_False;
  83
  84     /*  Cannot use osl conditions because they are blocking
  85         without waking up on messages sent by another thread
  86         this leads to deadlocks because we are blocking the
  87         communication between inter-thread marshalled COM
  88         pointers.
  89         COM Proxy-Stub communication uses SendMessages for
  90         synchronization purposes.
  91     */
  92     class Win32Condition
  93     {
  94         public:
  95             // ctor
  96             Win32Condition()
  97             {
  98                 m_hEvent = CreateEvent(
  99                     0,      /* no security */
 100                     true,   /* manual reset */
 101                     false,  /* initial state not signaled */
 102                     0);     /* automatic name */
 103             }
 104
 105             // dtor
 106             ~Win32Condition()
 107             {
 108                 CloseHandle(m_hEvent);
 109             }
 110
 111             // wait infinite for event be signaled
 112             // leave messages sent through
 113             void wait()
 114             {
 115                 while(1)
 116                 {
 117                     DWORD dwResult =
 118                         MsgWaitForMultipleObjects(1, &m_hEvent, FALSE, INFINITE, QS_SENDMESSAGE);
 119
 120                        switch (dwResult)
 121                     {
 122                         case WAIT_OBJECT_0:
 123                             return;
 124
 125                         case WAIT_OBJECT_0 + 1:
 126                         {
 127                             /* PeekMessage processes all messages in the SendMessage
 128                                queue that's what we want, messages from the PostMessage
 129                                queue stay untouched */
 130                             MSG msg;
 131                                PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
 132
 133                             break;
 134                         }
 135                     }
 136                 }
 137             }
 138
 139             // reset the event
 140             void set()
 141             {
 142                 SetEvent(m_hEvent);
 143             }
 144
 145         private:
 146             HANDLE m_hEvent;
 147
 148         // prevent copy/assignment
 149         private:
 150             Win32Condition(const Win32Condition&);
 151             Win32Condition& operator=(const Win32Condition&);
 152     };
 153
 154     // we use one condition for every request
 155
 156     struct MsgCtx
 157     {
 158         Win32Condition  aCondition;
 159         HRESULT         hr;
 160     };
 161
 162 } /* namespace private */
 163
 164 //  static member initialization
 165
 166 CMtaOleClipboard* CMtaOleClipboard::s_theMtaOleClipboardInst = NULL;
 167
 168 // marshal an IDataObject
 169
 170 //inline
 171 HRESULT MarshalIDataObjectInStream( IDataObject* pIDataObject, LPSTREAM* ppStream )
 172 {
 173     OSL_ASSERT( NULL != pIDataObject );
 174     OSL_ASSERT( NULL != ppStream );
 175
 176     *ppStream = NULL;
 177     return CoMarshalInterThreadInterfaceInStream(
 178         __uuidof(IDataObject),  //The IID of interface to be marshaled
 179         pIDataObject,           //The interface pointer
 180         ppStream                //IStream pointer
 181         );
 182 }
 183
 184 // unmarshal an IDataObject
 185
 186 //inline
 187 HRESULT UnmarshalIDataObjectAndReleaseStream( LPSTREAM lpStream, IDataObject** ppIDataObject )
 188 {
 189     OSL_ASSERT( NULL != lpStream );
 190     OSL_ASSERT( NULL != ppIDataObject );
 191
 192     *ppIDataObject = NULL;
 193     return CoGetInterfaceAndReleaseStream(
 194         lpStream,
 195         __uuidof(IDataObject),
 196         reinterpret_cast<LPVOID*>(ppIDataObject));
 197 }
 198
 199 // helper class to ensure that the calling thread has com initialized
 200
 201 class CAutoComInit
 202 {
 203 public:
 204     CAutoComInit( )
 205     {
 206         /*
 207             to be safe we call CoInitialize
 208             although it is not necessary if
 209             the calling thread was created
 210             using osl_CreateThread because
 211             this function calls CoInitialize
 212             for every thread it creates
 213         */
 214         m_hResult = CoInitialize( NULL );
 215
 216         if ( S_OK == m_hResult )
 217             OSL_FAIL( \
 218             "com was not yet initialzed, the thread was not created using osl_createThread" );
 219         else if ( FAILED( m_hResult ) && !( RPC_E_CHANGED_MODE == m_hResult ) )
 220             OSL_FAIL( \
 221             "com could not be initialized, maybe the thread was not created using osl_createThread" );
 222     }
 223
 224     ~CAutoComInit( )
 225     {
 226         /*
 227             we only call CoUninitialize when
 228             CoInitailize returned S_FALSE, what
 229             means that com was already initialize
 230             for that thread so we keep the balance
 231             if CoInitialize returned S_OK what means
 232             com was not yet initialized we better
 233             let com initialized or we may run into
 234             the realm of undefined behaviour
 235         */
 236         if ( m_hResult == S_FALSE )
 237             CoUninitialize( );
 238     }
 239
 240 private:
 241     HRESULT m_hResult;
 242 };
 243
 244 // ctor
 245
 246 CMtaOleClipboard::CMtaOleClipboard( ) :
 247     m_hOleThread( NULL ),
 248     m_uOleThreadId( 0 ),
 249     m_hEvtThrdReady( NULL ),
 250     m_hwndMtaOleReqWnd( NULL ),
 251     m_MtaOleReqWndClassAtom( 0 ),
 252     m_hwndNextClipViewer( NULL ),
 253     m_pfncClipViewerCallback( NULL ),
 254     m_bRunClipboardNotifierThread( true ),
 255     m_hClipboardChangedEvent( m_hClipboardChangedNotifierEvents[0] ),
 256     m_hTerminateClipboardChangedNotifierEvent( m_hClipboardChangedNotifierEvents[1] ),
 257     m_ClipboardChangedEventCount( 0 )
 258 {
 259     // signals that the thread was successfully setup
 260     m_hEvtThrdReady  = CreateEventA( 0, MANUAL_RESET, INIT_NONSIGNALED, NULL );
 261
 262     OSL_ASSERT( NULL != m_hEvtThrdReady );
 263
 264     s_theMtaOleClipboardInst = this;
 265
 266     m_hOleThread = (HANDLE)_beginthreadex(
 267         NULL, 0, CMtaOleClipboard::oleThreadProc, this, 0, &m_uOleThreadId );
 268     OSL_ASSERT( NULL != m_hOleThread );
 269
 270     // setup the clipboard changed notifier thread
 271
 272     m_hClipboardChangedNotifierEvents[0] = CreateEventA( 0, MANUAL_RESET, INIT_NONSIGNALED, NULL );
 273     OSL_ASSERT( NULL != m_hClipboardChangedNotifierEvents[0] );
 274
 275     m_hClipboardChangedNotifierEvents[1] = CreateEventA( 0, MANUAL_RESET, INIT_NONSIGNALED, NULL );
 276     OSL_ASSERT( NULL != m_hClipboardChangedNotifierEvents[1] );
 277
 278     unsigned uThreadId;
 279     m_hClipboardChangedNotifierThread = (HANDLE)_beginthreadex(
 280         NULL, 0, CMtaOleClipboard::clipboardChangedNotifierThreadProc, this, 0, &uThreadId );
 281
 282     OSL_ASSERT( NULL != m_hClipboardChangedNotifierThread );
 283 }
 284
 285 // dtor
 286
 287 CMtaOleClipboard::~CMtaOleClipboard( )
 288 {
 289     // block calling threads out
 290     if ( NULL != m_hEvtThrdReady )
 291         ResetEvent( m_hEvtThrdReady );
 292
 293     // terminate the clipboard changed notifier thread
 294     m_bRunClipboardNotifierThread = false;
 295     SetEvent( m_hTerminateClipboardChangedNotifierEvent );
 296
 297     sal_uInt32 dwResult = WaitForSingleObject(
 298         m_hClipboardChangedNotifierThread, MAX_WAIT_SHUTDOWN );
 299
 300     (void) dwResult;
 301     OSL_ENSURE( dwResult == WAIT_OBJECT_0, "clipboard notifier thread could not terminate" );
 302
 303     if ( NULL != m_hClipboardChangedNotifierThread )
 304         CloseHandle( m_hClipboardChangedNotifierThread );
 305
 306     if ( NULL != m_hClipboardChangedNotifierEvents[0] )
 307         CloseHandle( m_hClipboardChangedNotifierEvents[0] );
 308
 309     if ( NULL != m_hClipboardChangedNotifierEvents[1] )
 310         CloseHandle( m_hClipboardChangedNotifierEvents[1] );
 311
 312     // end the thread
 313     // because DestroyWindow can only be called
 314     // from within the thread that created the window
 315     sendMessage( MSG_SHUTDOWN,
 316                  static_cast< WPARAM >( 0 ),
 317                  static_cast< LPARAM >( 0 ) );
 318
 319     // wait for thread shutdown
 320     dwResult = WaitForSingleObject( m_hOleThread, MAX_WAIT_SHUTDOWN );
 321     OSL_ENSURE( dwResult == WAIT_OBJECT_0, "OleThread could not terminate" );
 322
 323     if ( NULL != m_hOleThread )
 324         CloseHandle( m_hOleThread );
 325
 326     if ( NULL != m_hEvtThrdReady )
 327         CloseHandle( m_hEvtThrdReady );
 328
 329     if ( m_MtaOleReqWndClassAtom )
 330         UnregisterClassA( g_szWndClsName, NULL );
 331
 332     OSL_ENSURE( ( NULL == m_pfncClipViewerCallback ) &&
 333                 !IsWindow( m_hwndNextClipViewer ), \
 334                 "Clipboard viewer not properly unregistered" );
 335 }
 336
 337 HRESULT CMtaOleClipboard::flushClipboard( )
 338 {
 339     if ( !WaitForThreadReady( ) )
 340     {
 341         OSL_FAIL( "clipboard sta thread not ready" );
 342         return E_FAIL;
 343     }
 344
 345     OSL_ENSURE( GetCurrentThreadId( ) != m_uOleThreadId, \
 346         "flushClipboard from within clipboard sta thread called" );
 347
 348     MsgCtx  aMsgCtx;
 349
 350     postMessage( MSG_FLUSHCLIPBOARD,
 351                  static_cast< WPARAM >( 0 ),
 352                  reinterpret_cast< LPARAM >( &aMsgCtx ) );
 353
 354     aMsgCtx.aCondition.wait( /* infinite */ );
 355
 356     return aMsgCtx.hr;
 357 }
 358
 359 HRESULT CMtaOleClipboard::getClipboard( IDataObject** ppIDataObject )
 360 {
 361     OSL_PRECOND( NULL != ppIDataObject, "invalid parameter" );
 362     OSL_PRECOND( GetCurrentThreadId( ) != m_uOleThreadId, "getClipboard from within clipboard sta thread called" );
 363
 364     if ( !WaitForThreadReady( ) )
 365     {
 366         OSL_FAIL( "clipboard sta thread not ready" );
 367         return E_FAIL;
 368     }
 369
 370     CAutoComInit comAutoInit;
 371
 372     LPSTREAM lpStream;
 373
 374     *ppIDataObject = NULL;
 375
 376     MsgCtx    aMsgCtx;
 377
 378     postMessage( MSG_GETCLIPBOARD,
 379                  reinterpret_cast< WPARAM >( &lpStream ),
 380                  reinterpret_cast< LPARAM >( &aMsgCtx ) );
 381
 382     aMsgCtx.aCondition.wait( /* infinite */ );
 383
 384     HRESULT hr = aMsgCtx.hr;
 385
 386     if ( SUCCEEDED( hr ) )
 387     {
 388         hr = UnmarshalIDataObjectAndReleaseStream( lpStream, ppIDataObject );
 389         OSL_ENSURE( SUCCEEDED( hr ), "unmarshalling clipboard data object failed" );
 390     }
 391
 392     return hr;
 393 }
 394
 395 // this is an asynchronous method that's why we don't wait until the
 396 // request is completed
 397
 398 HRESULT CMtaOleClipboard::setClipboard( IDataObject* pIDataObject )
 399 {
 400     if ( !WaitForThreadReady( ) )
 401     {
 402         OSL_FAIL( "clipboard sta thread not ready" );
 403         return E_FAIL;
 404     }
 405
 406     CAutoComInit comAutoInit;
 407
 408     OSL_ENSURE( GetCurrentThreadId( ) != m_uOleThreadId, "setClipboard from within the clipboard sta thread called" );
 409
 410     // because we marshall this request
 411     // into the sta thread we better
 412     // acquire the interface here so
 413     // that the object will not be
 414     // destroyed before the ole clipboard
 415     // can acquire it
 416     // remember: pIDataObject may be NULL
 417     // which is an request to clear the
 418     // current clipboard content
 419     if ( pIDataObject )
 420         pIDataObject->AddRef( );
 421
 422     postMessage(
 423         MSG_SETCLIPBOARD,
 424         reinterpret_cast< WPARAM >( pIDataObject ),
 425         0 );
 426
 427     // because this is an asynchronous function
 428     // the return value is useless
 429     return S_OK;
 430 }
 431
 432 // register a clipboard viewer
 433
 434 bool CMtaOleClipboard::registerClipViewer( LPFNC_CLIPVIEWER_CALLBACK_t pfncClipViewerCallback )
 435 {
 436     if ( !WaitForThreadReady( ) )
 437     {
 438         OSL_FAIL( "clipboard sta thread not ready" );
 439         return false;
 440     }
 441
 442     bool bRet = false;
 443
 444     OSL_ENSURE( GetCurrentThreadId( ) != m_uOleThreadId, "registerClipViewer from within the OleThread called" );
 445
 446     MsgCtx  aMsgCtx;
 447
 448     postMessage( MSG_REGCLIPVIEWER,
 449                  reinterpret_cast<WPARAM>( pfncClipViewerCallback ),
 450                  reinterpret_cast<LPARAM>( &aMsgCtx ) );
 451
 452     aMsgCtx.aCondition.wait( /* infinite */ );
 453
 454     return bRet;
 455 }
 456
 457 // register a clipboard viewer
 458
 459 bool CMtaOleClipboard::onRegisterClipViewer( LPFNC_CLIPVIEWER_CALLBACK_t pfncClipViewerCallback )
 460 {
 461     bool bRet = true;
 462
 463     // we need exclusive access because the clipboard changed notifier
 464     // thread also accesses this variable
 465     MutexGuard aGuard( m_pfncClipViewerCallbackMutex );
 466
 467     // register if not yet done
 468     if ( ( NULL != pfncClipViewerCallback ) && ( NULL == m_pfncClipViewerCallback ) )
 469     {
 470         // SetClipboardViewer sends a WM_DRAWCLIPBOARD message we ignore
 471         // this message if we register ourself as clip viewer
 472         m_bInRegisterClipViewer = true;
 473         m_hwndNextClipViewer = SetClipboardViewer( m_hwndMtaOleReqWnd );
 474         m_bInRegisterClipViewer = false;
 475
 476         // if there is no other cb-viewer the
 477         // return value is NULL!!!
 478         bRet = IsWindow( m_hwndNextClipViewer ) ? true : false;
 479
 480         // save the new callback function
 481         m_pfncClipViewerCallback = pfncClipViewerCallback;
 482     }
 483     else if ( ( NULL == pfncClipViewerCallback ) && ( NULL != m_pfncClipViewerCallback ) )
 484     {
 485         m_pfncClipViewerCallback = NULL;
 486
 487         // unregister if input parameter is NULL and we previously registered
 488         // as clipboard viewer
 489         ChangeClipboardChain( m_hwndMtaOleReqWnd, m_hwndNextClipViewer );
 490         m_hwndNextClipViewer = NULL;
 491     }
 492
 493     return bRet;
 494 }
 495
 496 LRESULT CMtaOleClipboard::onSetClipboard( IDataObject* pIDataObject )
 497 {
 498     return static_cast<LRESULT>( OleSetClipboard( pIDataObject ) );
 499 }
 500
 501 LRESULT CMtaOleClipboard::onGetClipboard( LPSTREAM* ppStream )
 502 {
 503     OSL_ASSERT(NULL != ppStream);
 504
 505     IDataObjectPtr pIDataObject;
 506
 507     // forward the request to the OleClipboard
 508     HRESULT hr = OleGetClipboard( &pIDataObject );
 509     if ( SUCCEEDED( hr ) )
 510     {
 511         hr = MarshalIDataObjectInStream(pIDataObject.get(), ppStream);
 512         OSL_ENSURE(SUCCEEDED(hr), "marshalling cliboard data object failed");
 513     }
 514     return static_cast<LRESULT>(hr);
 515 }
 516
 517 // flush the ole-clipboard
 518
 519 LRESULT CMtaOleClipboard::onFlushClipboard( )
 520 {
 521     return static_cast<LRESULT>( OleFlushClipboard( ) );
 522 }
 523
 524 // handle clipboard chain change event
 525
 526 LRESULT CMtaOleClipboard::onChangeCBChain( HWND hWndRemove, HWND hWndNext )
 527 {
 528     if ( hWndRemove == m_hwndNextClipViewer )
 529         m_hwndNextClipViewer = hWndNext;
 530     else if ( IsWindow( m_hwndNextClipViewer ) )
 531     {
 532         // forward the message to the next one
 533         DWORD_PTR dwpResult;
 534         SendMessageTimeoutA(
 535             m_hwndNextClipViewer,
 536             WM_CHANGECBCHAIN,
 537             reinterpret_cast<WPARAM>(hWndRemove),
 538             reinterpret_cast<LPARAM>(hWndNext),
 539             SMTO_BLOCK,
 540             MAX_CLIPEVENT_PROCESSING_TIME,
 541             &dwpResult );
 542     }
 543
 544     return 0;
 545 }
 546
 547 // handle draw clipboard event
 548
 549 LRESULT CMtaOleClipboard::onDrawClipboard( )
 550 {
 551     // we don't send a notification if we are
 552     // registering ourself as clipboard
 553     if ( !m_bInRegisterClipViewer )
 554     {
 555         ClearableMutexGuard aGuard( m_ClipboardChangedEventCountMutex );
 556
 557         m_ClipboardChangedEventCount++;
 558         SetEvent( m_hClipboardChangedEvent );
 559
 560         aGuard.clear( );
 561     }
 562
 563     // forward the message to the next viewer in the chain
 564     if ( IsWindow( m_hwndNextClipViewer ) )
 565     {
 566         DWORD_PTR dwpResult;
 567         SendMessageTimeoutA(
 568             m_hwndNextClipViewer,
 569             WM_DRAWCLIPBOARD,
 570             static_cast< WPARAM >( 0 ),
 571             static_cast< LPARAM >( 0 ),
 572             SMTO_BLOCK,
 573             MAX_CLIPEVENT_PROCESSING_TIME,
 574             &dwpResult );
 575     }
 576
 577     return 0;
 578 }
 579
 580 // SendMessage so we don't need to supply the HWND if we send
 581 // something to our wrapped window
 582
 583 LRESULT CMtaOleClipboard::sendMessage( UINT msg, WPARAM wParam, LPARAM lParam )
 584 {
 585     return ::SendMessageA( m_hwndMtaOleReqWnd, msg, wParam, lParam );
 586 }
 587
 588 // PostMessage so we don't need to supply the HWND if we send
 589 // something to our wrapped window
 590
 591 bool CMtaOleClipboard::postMessage( UINT msg, WPARAM wParam, LPARAM lParam )
 592 {
 593     return PostMessageA( m_hwndMtaOleReqWnd, msg, wParam, lParam ) ? true : false;
 594 }
 595
 596 // the window proc
 597
 598 LRESULT CALLBACK CMtaOleClipboard::mtaOleReqWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
 599 {
 600     LRESULT lResult = 0;
 601
 602     // get a connection to the class-instance via the static member
 603     CMtaOleClipboard* pImpl = CMtaOleClipboard::s_theMtaOleClipboardInst;
 604     OSL_ASSERT( NULL != pImpl );
 605
 606     switch( uMsg )
 607     {
 608     case MSG_SETCLIPBOARD:
 609         {
 610             IDataObject* pIDataObject = reinterpret_cast< IDataObject* >( wParam );
 611             pImpl->onSetClipboard( pIDataObject );
 612
 613             // in setClipboard we did acquire the
 614             // interface pointer in order to prevent
 615             // destruction of the object before the
 616             // ole clipboard can acquire the interface
 617             // now we release the interface so that
 618             // our lostOwnership mechanism works
 619             // remember: pIDataObject may be NULL
 620             if ( pIDataObject )
 621                 pIDataObject->Release( );
 622         }
 623         break;
 624
 625     case MSG_GETCLIPBOARD:
 626         {
 627             MsgCtx* aMsgCtx = reinterpret_cast< MsgCtx* >( lParam );
 628             OSL_ASSERT( aMsgCtx );
 629
 630             aMsgCtx->hr = pImpl->onGetClipboard( reinterpret_cast< LPSTREAM* >(wParam) );
 631             aMsgCtx->aCondition.set( );
 632         }
 633         break;
 634
 635     case MSG_FLUSHCLIPBOARD:
 636         {
 637             MsgCtx* aMsgCtx = reinterpret_cast< MsgCtx* >( lParam );
 638             OSL_ASSERT( aMsgCtx );
 639
 640             aMsgCtx->hr = pImpl->onFlushClipboard( );
 641             aMsgCtx->aCondition.set( );
 642         }
 643         break;
 644
 645     case MSG_REGCLIPVIEWER:
 646         {
 647             MsgCtx* aMsgCtx = reinterpret_cast< MsgCtx* >( lParam );
 648             OSL_ASSERT( aMsgCtx );
 649
 650             pImpl->onRegisterClipViewer( reinterpret_cast<CMtaOleClipboard::LPFNC_CLIPVIEWER_CALLBACK_t>(wParam) );
 651             aMsgCtx->aCondition.set( );
 652         }
 653         break;
 654
 655     case WM_CHANGECBCHAIN:
 656         lResult = pImpl->onChangeCBChain(
 657             reinterpret_cast< HWND >( wParam ), reinterpret_cast< HWND >( lParam ) );
 658         break;
 659
 660     case WM_DRAWCLIPBOARD:
 661         lResult = pImpl->onDrawClipboard( );
 662         break;
 663
 664     case MSG_SHUTDOWN:
 665         DestroyWindow( pImpl->m_hwndMtaOleReqWnd );
 666         break;
 667
 668     // force the sta thread to end
 669     case WM_DESTROY:
 670         PostQuitMessage( 0 );
 671         break;
 672
 673     default:
 674         lResult = DefWindowProcA( hWnd, uMsg, wParam, lParam );
 675         break;
 676     }
 677
 678     return lResult;
 679 }
 680
 681 void CMtaOleClipboard::createMtaOleReqWnd( )
 682 {
 683     WNDCLASSEXA  wcex;
 684
 685     HINSTANCE hInst = GetModuleHandleA( CLIPSRV_DLL_NAME );
 686     OSL_ENSURE( NULL != hInst, "The name of the clipboard service dll must have changed" );
 687
 688     ZeroMemory( &wcex, sizeof( WNDCLASSEXA ) );
 689
 690     wcex.cbSize         = sizeof(WNDCLASSEXA);
 691     wcex.style          = 0;
 692     wcex.lpfnWndProc    = static_cast< WNDPROC >( CMtaOleClipboard::mtaOleReqWndProc );
 693     wcex.cbClsExtra     = 0;
 694     wcex.cbWndExtra     = 0;
 695     wcex.hInstance      = hInst;
 696     wcex.hIcon          = NULL;
 697     wcex.hCursor        = NULL;
 698     wcex.hbrBackground  = NULL;
 699     wcex.lpszMenuName   = NULL;
 700     wcex.lpszClassName  = g_szWndClsName;
 701     wcex.hIconSm        = NULL;
 702
 703     m_MtaOleReqWndClassAtom = RegisterClassExA( &wcex );
 704
 705     if ( 0 != m_MtaOleReqWndClassAtom )
 706         m_hwndMtaOleReqWnd = CreateWindowA(
 707             g_szWndClsName, NULL, 0, 0, 0, 0, 0, NULL, NULL, hInst, NULL );
 708 }
 709
 710 unsigned int CMtaOleClipboard::run( )
 711 {
 712     #if OSL_DEBUG_LEVEL > 0
 713     HRESULT hr =
 714     #endif
 715         OleInitialize( NULL );
 716     OSL_ASSERT( SUCCEEDED( hr ) );
 717
 718     createMtaOleReqWnd( );
 719
 720     unsigned int nRet;
 721
 722     if ( IsWindow( m_hwndMtaOleReqWnd ) )
 723     {
 724         if ( NULL != m_hEvtThrdReady )
 725             SetEvent( m_hEvtThrdReady );
 726
 727         // pumping messages
 728         MSG msg;
 729         while( GetMessageA( &msg, NULL, 0, 0 ) )
 730             DispatchMessageA( &msg );
 731
 732         nRet = 0;
 733     }
 734     else
 735         nRet = ~0U;
 736
 737     OleUninitialize( );
 738
 739     return nRet;
 740 }
 741
 742 unsigned int WINAPI CMtaOleClipboard::oleThreadProc( LPVOID pParam )
 743 {
 744     osl_setThreadName("CMtaOleClipboard::run()");
 745
 746     CMtaOleClipboard* pInst =
 747         reinterpret_cast<CMtaOleClipboard*>( pParam );
 748     OSL_ASSERT( NULL != pInst );
 749
 750     return pInst->run( );
 751 }
 752
 753 unsigned int WINAPI CMtaOleClipboard::clipboardChangedNotifierThreadProc( LPVOID pParam )
 754 {
 755     osl_setThreadName("CMtaOleClipboard::clipboardChangedNotifierThreadProc()");
 756     CMtaOleClipboard* pInst = reinterpret_cast< CMtaOleClipboard* >( pParam );
 757     OSL_ASSERT( NULL != pInst );
 758
 759     CoInitialize( NULL );
 760
 761     // assuming we don't need a lock for
 762     // a boolean variable like m_bRun...
 763     while ( pInst->m_bRunClipboardNotifierThread )
 764     {
 765         // wait for clipboard changed or terminate event
 766         WaitForMultipleObjects( 2, pInst->m_hClipboardChangedNotifierEvents, false, INFINITE );
 767
 768         ClearableMutexGuard aGuard( pInst->m_ClipboardChangedEventCountMutex );
 769
 770         if ( pInst->m_ClipboardChangedEventCount > 0 )
 771         {
 772             pInst->m_ClipboardChangedEventCount--;
 773             if ( 0 == pInst->m_ClipboardChangedEventCount )
 774                 ResetEvent( pInst->m_hClipboardChangedEvent );
 775
 776             aGuard.clear( );
 777
 778             // nobody should touch m_pfncClipViewerCallback while we do
 779             MutexGuard aClipViewerGuard( pInst->m_pfncClipViewerCallbackMutex );
 780
 781             // notify all clipboard listener
 782             if ( pInst->m_pfncClipViewerCallback )
 783                 pInst->m_pfncClipViewerCallback( );
 784         }
 785         else
 786             aGuard.clear( );
 787     }
 788
 789     CoUninitialize( );
 790
 791     return 0;
 792 }
 793
 794 bool CMtaOleClipboard::WaitForThreadReady( ) const
 795 {
 796     bool bRet = false;
 797
 798     if ( NULL != m_hEvtThrdReady )
 799     {
 800         DWORD dwResult = WaitForSingleObject(
 801             m_hEvtThrdReady, MAX_WAITTIME );
 802         bRet = ( dwResult == WAIT_OBJECT_0 );
 803     }
 804
 805     return bRet;
 806 }
 807
 808 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */