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