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