]> git.saurik.com Git - wxWidgets.git/blame - src/msw/thread.cpp
Enable variadic macros for VC9 and later.
[wxWidgets.git] / src / msw / thread.cpp
CommitLineData
2bda0e17 1/////////////////////////////////////////////////////////////////////////////
9e84b847 2// Name: src/msw/thread.cpp
2bda0e17
KB
3// Purpose: wxThread Implementation
4// Author: Original from Wolfram Gloger/Guilhem Lavaux
bee503b0 5// Modified by: Vadim Zeitlin to make it work :-)
2bda0e17
KB
6// Created: 04/22/98
7// RCS-ID: $Id$
9e84b847
VZ
8// Copyright: (c) Wolfram Gloger (1996, 1997), Guilhem Lavaux (1998);
9// Vadim Zeitlin (1999-2002)
65571936 10// Licence: wxWindows licence
2bda0e17
KB
11/////////////////////////////////////////////////////////////////////////////
12
3222fde2
VZ
13// ----------------------------------------------------------------------------
14// headers
15// ----------------------------------------------------------------------------
16
a3b46648 17// For compilers that support precompilation, includes "wx.h".
2bda0e17
KB
18#include "wx/wxprec.h"
19
20#if defined(__BORLANDC__)
3222fde2 21 #pragma hdrstop
2bda0e17
KB
22#endif
23
670f9935
WS
24#if wxUSE_THREADS
25
26#include "wx/thread.h"
27
2bda0e17 28#ifndef WX_PRECOMP
60ab3272
VS
29 #include "wx/intl.h"
30 #include "wx/app.h"
02761f6c 31 #include "wx/module.h"
2bda0e17
KB
32#endif
33
e2478fde 34#include "wx/apptrait.h"
d3f8206c 35#include "wx/scopeguard.h"
e2478fde 36
0d0512bd 37#include "wx/msw/private.h"
a6c2e2c7 38#include "wx/msw/missing.h"
d3f8206c 39#include "wx/msw/seh.h"
3222fde2 40
d3f8206c 41#include "wx/except.h"
2bda0e17 42
b9697cb4
VZ
43#include "wx/dynlib.h"
44
b568d04f
VZ
45// must have this symbol defined to get _beginthread/_endthread declarations
46#ifndef _MT
47 #define _MT
48#endif
49
9f51f2b6
VZ
50#if defined(__BORLANDC__)
51 #if !defined(__MT__)
52 // I can't set -tWM in the IDE (anyone?) so have to do this
53 #define __MT__
54 #endif
55
56 #if !defined(__MFC_COMPAT__)
57 // Needed to know about _beginthreadex etc..
58 #define __MFC_COMPAT__
59 #endif
60#endif // BC++
61
62// define wxUSE_BEGIN_THREAD if the compiler has _beginthreadex() function
63// which should be used instead of Win32 ::CreateThread() if possible
e0256755
GRG
64#if defined(__VISUALC__) || \
65 (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \
9f51f2b6 66 (defined(__GNUG__) && defined(__MSVCRT__)) || \
2415cf67 67 defined(__WATCOMC__)
ccebc98a 68
4676948b 69#ifndef __WXWINCE__
9f51f2b6
VZ
70 #undef wxUSE_BEGIN_THREAD
71 #define wxUSE_BEGIN_THREAD
8536082d
BJ
72#endif
73
4676948b
JS
74#endif
75
9f51f2b6
VZ
76#ifdef wxUSE_BEGIN_THREAD
77 // this is where _beginthreadex() is declared
b568d04f 78 #include <process.h>
9f51f2b6 79
d79c9c67
VZ
80 // the return type of the thread function entry point: notice that this
81 // type can't hold a pointer under Win64
82 typedef unsigned THREAD_RETVAL;
9f51f2b6
VZ
83
84 // the calling convention of the thread function entry point
85 #define THREAD_CALLCONV __stdcall
86#else
87 // the settings for CreateThread()
88 typedef DWORD THREAD_RETVAL;
89 #define THREAD_CALLCONV WINAPI
b568d04f
VZ
90#endif
91
3f49efdb
VZ
92static const THREAD_RETVAL THREAD_ERROR_EXIT = (THREAD_RETVAL)-1;
93
b568d04f
VZ
94// ----------------------------------------------------------------------------
95// constants
96// ----------------------------------------------------------------------------
97
bf1852e1
VZ
98// the possible states of the thread ("=>" shows all possible transitions from
99// this state)
100enum wxThreadState
101{
102 STATE_NEW, // didn't start execution yet (=> RUNNING)
103 STATE_RUNNING, // thread is running (=> PAUSED, CANCELED)
104 STATE_PAUSED, // thread is temporarily suspended (=> RUNNING)
105 STATE_CANCELED, // thread should terminate a.s.a.p. (=> EXITED)
106 STATE_EXITED // thread is terminating
2bda0e17
KB
107};
108
3222fde2 109// ----------------------------------------------------------------------------
b568d04f 110// this module globals
3222fde2 111// ----------------------------------------------------------------------------
2bda0e17 112
bf1852e1 113// TLS index of the slot where we store the pointer to the current thread
b568d04f 114static DWORD gs_tlsThisThread = 0xFFFFFFFF;
bf1852e1 115
3222fde2
VZ
116// id of the main thread - the one which can call GUI functions without first
117// calling wxMutexGuiEnter()
f9226383 118wxThreadIdType wxThread::ms_idMainThread = 0;
bee503b0 119
3ef22a5b
VZ
120// if it's false, some secondary thread is holding the GUI lock
121static bool gs_bGuiOwnedByMainThread = true;
2bda0e17 122
3222fde2
VZ
123// critical section which controls access to all GUI functions: any secondary
124// thread (i.e. except the main one) must enter this crit section before doing
125// any GUI calls
b568d04f 126static wxCriticalSection *gs_critsectGui = NULL;
bee503b0 127
b568d04f
VZ
128// critical section which protects gs_nWaitingForGui variable
129static wxCriticalSection *gs_critsectWaitingForGui = NULL;
bee503b0 130
3ef22a5b
VZ
131// critical section which serializes WinThreadStart() and WaitForTerminate()
132// (this is a potential bottleneck, we use a single crit sect for all threads
133// in the system, but normally time spent inside it should be quite short)
134static wxCriticalSection *gs_critsectThreadDelete = NULL;
135
bee503b0 136// number of threads waiting for GUI in wxMutexGuiEnter()
b568d04f 137static size_t gs_nWaitingForGui = 0;
2bda0e17 138
bf1852e1 139// are we waiting for a thread termination?
3ef22a5b 140static bool gs_waitingForThread = false;
bf1852e1 141
3222fde2 142// ============================================================================
9e84b847 143// Windows implementation of thread and related classes
3222fde2
VZ
144// ============================================================================
145
146// ----------------------------------------------------------------------------
9e84b847
VZ
147// wxCriticalSection
148// ----------------------------------------------------------------------------
149
3ad41c28 150wxCriticalSection::wxCriticalSection( wxCriticalSectionType WXUNUSED(critSecType) )
9e84b847 151{
1c6f2414
WS
152 wxCOMPILE_TIME_ASSERT( sizeof(CRITICAL_SECTION) <= sizeof(wxCritSectBuffer),
153 wxCriticalSectionBufferTooSmall );
154
9e84b847
VZ
155 ::InitializeCriticalSection((CRITICAL_SECTION *)m_buffer);
156}
157
158wxCriticalSection::~wxCriticalSection()
159{
160 ::DeleteCriticalSection((CRITICAL_SECTION *)m_buffer);
161}
162
163void wxCriticalSection::Enter()
164{
165 ::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
166}
167
b9697cb4
VZ
168bool wxCriticalSection::TryEnter()
169{
170#if wxUSE_DYNLIB_CLASS
171 typedef BOOL
172 (WINAPI *TryEnterCriticalSection_t)(LPCRITICAL_SECTION lpCriticalSection);
173
174 static TryEnterCriticalSection_t
175 pfnTryEnterCriticalSection = (TryEnterCriticalSection_t)
176 wxDynamicLibrary(wxT("kernel32.dll")).
177 GetSymbol(wxT("TryEnterCriticalSection"));
178
179 return pfnTryEnterCriticalSection
180 ? (*pfnTryEnterCriticalSection)((CRITICAL_SECTION *)m_buffer) != 0
181 : false;
182#else
183 return false;
184#endif
185}
186
9e84b847
VZ
187void wxCriticalSection::Leave()
188{
189 ::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
190}
191
192// ----------------------------------------------------------------------------
193// wxMutex
3222fde2 194// ----------------------------------------------------------------------------
0d0512bd 195
3222fde2
VZ
196class wxMutexInternal
197{
2bda0e17 198public:
9e84b847
VZ
199 wxMutexInternal(wxMutexType mutexType);
200 ~wxMutexInternal();
7f684264 201
9e84b847
VZ
202 bool IsOk() const { return m_mutex != NULL; }
203
204 wxMutexError Lock() { return LockTimeout(INFINITE); }
696d13ee
VZ
205 wxMutexError Lock(unsigned long ms) { return LockTimeout(ms); }
206 wxMutexError TryLock();
9e84b847
VZ
207 wxMutexError Unlock();
208
209private:
210 wxMutexError LockTimeout(DWORD milliseconds);
7f684264 211
7f684264 212 HANDLE m_mutex;
1654ef4c 213
424c9ce7 214 unsigned long m_owningThread;
424c9ce7 215 wxMutexType m_type;
22f3361e 216
c0c133e1 217 wxDECLARE_NO_COPY_CLASS(wxMutexInternal);
2bda0e17
KB
218};
219
9e84b847 220// all mutexes are recursive under Win32 so we don't use mutexType
424c9ce7 221wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
2bda0e17 222{
9e84b847
VZ
223 // create a nameless (hence intra process and always private) mutex
224 m_mutex = ::CreateMutex
225 (
226 NULL, // default secutiry attributes
696d13ee 227 FALSE, // not initially locked
9e84b847
VZ
228 NULL // no name
229 );
a6b0bd49 230
424c9ce7
RR
231 m_type = mutexType;
232 m_owningThread = 0;
424c9ce7 233
9e84b847
VZ
234 if ( !m_mutex )
235 {
9a83f860 236 wxLogLastError(wxT("CreateMutex()"));
9e84b847 237 }
1654ef4c 238
2bda0e17
KB
239}
240
9e84b847 241wxMutexInternal::~wxMutexInternal()
2bda0e17 242{
9e84b847 243 if ( m_mutex )
7f684264 244 {
9e84b847
VZ
245 if ( !::CloseHandle(m_mutex) )
246 {
9a83f860 247 wxLogLastError(wxT("CloseHandle(mutex)"));
9e84b847 248 }
7f684264 249 }
2bda0e17
KB
250}
251
696d13ee
VZ
252wxMutexError wxMutexInternal::TryLock()
253{
254 const wxMutexError rc = LockTimeout(0);
255
256 // we have a special return code for timeout in this case
257 return rc == wxMUTEX_TIMEOUT ? wxMUTEX_BUSY : rc;
258}
259
9e84b847 260wxMutexError wxMutexInternal::LockTimeout(DWORD milliseconds)
2bda0e17 261{
424c9ce7
RR
262 if (m_type == wxMUTEX_DEFAULT)
263 {
264 // Don't allow recursive
375f364e 265 if (m_owningThread != 0)
424c9ce7
RR
266 {
267 if (m_owningThread == wxThread::GetCurrentId())
268 return wxMUTEX_DEAD_LOCK;
269 }
270 }
271
9e84b847 272 DWORD rc = ::WaitForSingleObject(m_mutex, milliseconds);
9e84b847
VZ
273 switch ( rc )
274 {
1654ef4c
VZ
275 case WAIT_ABANDONED:
276 // the previous caller died without releasing the mutex, so even
277 // though we did get it, log a message about this
9a83f860 278 wxLogDebug(wxT("WaitForSingleObject() returned WAIT_ABANDONED"));
1654ef4c
VZ
279 // fall through
280
3222fde2
VZ
281 case WAIT_OBJECT_0:
282 // ok
283 break;
2bda0e17 284
3222fde2 285 case WAIT_TIMEOUT:
696d13ee 286 return wxMUTEX_TIMEOUT;
9e84b847 287
3222fde2 288 default:
223d09f6 289 wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
9e84b847 290 // fall through
3222fde2 291
9e84b847 292 case WAIT_FAILED:
9a83f860 293 wxLogLastError(wxT("WaitForSingleObject(mutex)"));
9e84b847
VZ
294 return wxMUTEX_MISC_ERROR;
295 }
2bda0e17 296
424c9ce7 297 if (m_type == wxMUTEX_DEFAULT)
1654ef4c 298 {
424c9ce7 299 // required for checking recursiveness
424c9ce7
RR
300 m_owningThread = wxThread::GetCurrentId();
301 }
1654ef4c 302
3222fde2 303 return wxMUTEX_NO_ERROR;
2bda0e17
KB
304}
305
9e84b847 306wxMutexError wxMutexInternal::Unlock()
2bda0e17 307{
375f364e
RR
308 // required for checking recursiveness
309 m_owningThread = 0;
310
9e84b847 311 if ( !::ReleaseMutex(m_mutex) )
3222fde2 312 {
9a83f860 313 wxLogLastError(wxT("ReleaseMutex()"));
9e84b847 314
3222fde2
VZ
315 return wxMUTEX_MISC_ERROR;
316 }
a6b0bd49 317
3222fde2 318 return wxMUTEX_NO_ERROR;
2bda0e17
KB
319}
320
be809868 321// --------------------------------------------------------------------------
9e84b847 322// wxSemaphore
be809868
VZ
323// --------------------------------------------------------------------------
324
9e84b847 325// a trivial wrapper around Win32 semaphore
be809868 326class wxSemaphoreInternal
3222fde2 327{
2bda0e17 328public:
9e84b847 329 wxSemaphoreInternal(int initialcount, int maxcount);
be809868
VZ
330 ~wxSemaphoreInternal();
331
9e84b847 332 bool IsOk() const { return m_semaphore != NULL; }
be809868 333
9e84b847 334 wxSemaError Wait() { return WaitTimeout(INFINITE); }
918dc519
VZ
335
336 wxSemaError TryWait()
337 {
338 wxSemaError rc = WaitTimeout(0);
339 if ( rc == wxSEMA_TIMEOUT )
340 rc = wxSEMA_BUSY;
341
342 return rc;
343 }
344
9e84b847 345 wxSemaError WaitTimeout(unsigned long milliseconds);
be809868 346
9e84b847 347 wxSemaError Post();
be809868
VZ
348
349private:
350 HANDLE m_semaphore;
22f3361e 351
c0c133e1 352 wxDECLARE_NO_COPY_CLASS(wxSemaphoreInternal);
be809868
VZ
353};
354
9e84b847 355wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
be809868 356{
4a268913 357#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 300)
be809868 358 if ( maxcount == 0 )
b568d04f 359 {
be809868
VZ
360 // make it practically infinite
361 maxcount = INT_MAX;
362 }
4d1c1c3c 363
9e84b847
VZ
364 m_semaphore = ::CreateSemaphore
365 (
366 NULL, // default security attributes
367 initialcount,
368 maxcount,
369 NULL // no name
370 );
4676948b 371#endif
be809868
VZ
372 if ( !m_semaphore )
373 {
9a83f860 374 wxLogLastError(wxT("CreateSemaphore()"));
b568d04f 375 }
be809868
VZ
376}
377
378wxSemaphoreInternal::~wxSemaphoreInternal()
379{
9e84b847 380 if ( m_semaphore )
b568d04f 381 {
9e84b847
VZ
382 if ( !::CloseHandle(m_semaphore) )
383 {
9a83f860 384 wxLogLastError(wxT("CloseHandle(semaphore)"));
9e84b847 385 }
be809868
VZ
386 }
387}
b568d04f 388
9e84b847 389wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
be809868 390{
9e84b847 391 DWORD rc = ::WaitForSingleObject( m_semaphore, milliseconds );
be809868 392
9e84b847 393 switch ( rc )
be809868
VZ
394 {
395 case WAIT_OBJECT_0:
9e84b847 396 return wxSEMA_NO_ERROR;
b568d04f 397
be809868 398 case WAIT_TIMEOUT:
918dc519 399 return wxSEMA_TIMEOUT;
be809868
VZ
400
401 default:
9a83f860 402 wxLogLastError(wxT("WaitForSingleObject(semaphore)"));
b568d04f
VZ
403 }
404
9e84b847 405 return wxSEMA_MISC_ERROR;
be809868
VZ
406}
407
9e84b847 408wxSemaError wxSemaphoreInternal::Post()
be809868 409{
4a268913 410#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 300)
9e84b847 411 if ( !::ReleaseSemaphore(m_semaphore, 1, NULL /* ptr to previous count */) )
4d1c1c3c 412 {
a0020fcd
VZ
413 if ( GetLastError() == ERROR_TOO_MANY_POSTS )
414 {
415 return wxSEMA_OVERFLOW;
416 }
417 else
418 {
9a83f860 419 wxLogLastError(wxT("ReleaseSemaphore"));
a0020fcd
VZ
420 return wxSEMA_MISC_ERROR;
421 }
9e84b847 422 }
be809868 423
9e84b847 424 return wxSEMA_NO_ERROR;
a0020fcd
VZ
425#else
426 return wxSEMA_MISC_ERROR;
427#endif
be809868 428}
4d1c1c3c 429
3222fde2
VZ
430// ----------------------------------------------------------------------------
431// wxThread implementation
432// ----------------------------------------------------------------------------
433
bf1852e1
VZ
434// wxThreadInternal class
435// ----------------------
436
3222fde2
VZ
437class wxThreadInternal
438{
2bda0e17 439public:
3ef22a5b 440 wxThreadInternal(wxThread *thread)
bf1852e1 441 {
3ef22a5b 442 m_thread = thread;
bf1852e1
VZ
443 m_hThread = 0;
444 m_state = STATE_NEW;
445 m_priority = WXTHREAD_DEFAULT_PRIORITY;
3ef22a5b 446 m_nRef = 1;
bf1852e1
VZ
447 }
448
b568d04f
VZ
449 ~wxThreadInternal()
450 {
451 Free();
452 }
453
454 void Free()
455 {
456 if ( m_hThread )
457 {
458 if ( !::CloseHandle(m_hThread) )
459 {
f6bcfd97 460 wxLogLastError(wxT("CloseHandle(thread)"));
b568d04f
VZ
461 }
462
463 m_hThread = 0;
464 }
465 }
466
bf1852e1 467 // create a new (suspended) thread (for the given thread object)
6fe73788 468 bool Create(wxThread *thread, unsigned int stackSize);
bf1852e1 469
68d41720
VZ
470 // wait for the thread to terminate, either by itself, or by asking it
471 // (politely, this is not Kill()!) to do it
3ef22a5b
VZ
472 wxThreadError WaitForTerminate(wxCriticalSection& cs,
473 wxThread::ExitCode *pRc,
b95a7c31 474 wxThreadWait waitMode,
3ef22a5b 475 wxThread *threadToDelete = NULL);
68d41720
VZ
476
477 // kill the thread unconditionally
478 wxThreadError Kill();
479
bf1852e1
VZ
480 // suspend/resume/terminate
481 bool Suspend();
482 bool Resume();
483 void Cancel() { m_state = STATE_CANCELED; }
484
485 // thread state
486 void SetState(wxThreadState state) { m_state = state; }
487 wxThreadState GetState() const { return m_state; }
488
489 // thread priority
b568d04f 490 void SetPriority(unsigned int priority);
bf1852e1
VZ
491 unsigned int GetPriority() const { return m_priority; }
492
493 // thread handle and id
494 HANDLE GetHandle() const { return m_hThread; }
495 DWORD GetId() const { return m_tid; }
496
d3f8206c 497 // the thread function forwarding to DoThreadStart
9f51f2b6 498 static THREAD_RETVAL THREAD_CALLCONV WinThreadStart(void *thread);
2bda0e17 499
d3f8206c
VZ
500 // really start the thread (if it's not already dead)
501 static THREAD_RETVAL DoThreadStart(wxThread *thread);
502
5b53617d
VZ
503 // call OnExit() on the thread
504 static void DoThreadOnExit(wxThread *thread);
505
506
3ef22a5b
VZ
507 void KeepAlive()
508 {
509 if ( m_thread->IsDetached() )
510 ::InterlockedIncrement(&m_nRef);
511 }
512
513 void LetDie()
514 {
515 if ( m_thread->IsDetached() && !::InterlockedDecrement(&m_nRef) )
516 delete m_thread;
517 }
518
bf1852e1 519private:
3ef22a5b
VZ
520 // the thread we're associated with
521 wxThread *m_thread;
522
bf1852e1
VZ
523 HANDLE m_hThread; // handle of the thread
524 wxThreadState m_state; // state, see wxThreadState enum
525 unsigned int m_priority; // thread priority in "wx" units
526 DWORD m_tid; // thread id
22f3361e 527
3ef22a5b
VZ
528 // number of threads which need this thread to remain alive, when the count
529 // reaches 0 we kill the owning wxThread -- and die ourselves with it
530 LONG m_nRef;
531
c0c133e1 532 wxDECLARE_NO_COPY_CLASS(wxThreadInternal);
2bda0e17
KB
533};
534
3ef22a5b
VZ
535// small class which keeps a thread alive during its lifetime
536class wxThreadKeepAlive
537{
538public:
539 wxThreadKeepAlive(wxThreadInternal& thrImpl) : m_thrImpl(thrImpl)
540 { m_thrImpl.KeepAlive(); }
541 ~wxThreadKeepAlive()
542 { m_thrImpl.LetDie(); }
543
544private:
545 wxThreadInternal& m_thrImpl;
546};
547
5b53617d
VZ
548/* static */
549void wxThreadInternal::DoThreadOnExit(wxThread *thread)
550{
551 wxTRY
552 {
553 thread->OnExit();
554 }
555 wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
556}
557
558/* static */
d3f8206c
VZ
559THREAD_RETVAL wxThreadInternal::DoThreadStart(wxThread *thread)
560{
5b53617d
VZ
561 wxON_BLOCK_EXIT1(DoThreadOnExit, thread);
562
3f49efdb 563 THREAD_RETVAL rc = THREAD_ERROR_EXIT;
d3f8206c
VZ
564
565 wxTRY
566 {
d3f8206c
VZ
567 // store the thread object in the TLS
568 if ( !::TlsSetValue(gs_tlsThisThread, thread) )
569 {
4c51a665 570 wxLogSysError(_("Cannot start thread: error writing TLS."));
d3f8206c 571
3f49efdb 572 return THREAD_ERROR_EXIT;
d3f8206c
VZ
573 }
574
d79c9c67 575 rc = wxPtrToUInt(thread->Entry());
d3f8206c
VZ
576 }
577 wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
578
579 return rc;
580}
3ef22a5b 581
5b53617d 582/* static */
08d7397c 583THREAD_RETVAL THREAD_CALLCONV wxThreadInternal::WinThreadStart(void *param)
2bda0e17 584{
3f49efdb 585 THREAD_RETVAL rc = THREAD_ERROR_EXIT;
3ef22a5b
VZ
586
587 wxThread * const thread = (wxThread *)param;
f6bcfd97 588
d3f8206c
VZ
589 // each thread has its own SEH translator so install our own a.s.a.p.
590 DisableAutomaticSETranslator();
591
f6bcfd97
BP
592 // first of all, check whether we hadn't been cancelled already and don't
593 // start the user code at all then
0f00be4b 594 const bool hasExited = thread->m_internal->GetState() == STATE_EXITED;
5eba4394 595
5b53617d
VZ
596 // run the thread function itself inside a SEH try/except block
597 wxSEH_TRY
bf1852e1 598 {
5b53617d
VZ
599 if ( hasExited )
600 DoThreadOnExit(thread);
601 else
d3f8206c 602 rc = DoThreadStart(thread);
5eba4394 603 }
3f49efdb 604 wxSEH_HANDLE(THREAD_ERROR_EXIT)
5b53617d 605
5eba4394 606
5eba4394
DS
607 // save IsDetached because thread object can be deleted by joinable
608 // threads after state is changed to STATE_EXITED.
d3f8206c 609 const bool isDetached = thread->IsDetached();
0f00be4b 610 if ( !hasExited )
5eba4394 611 {
f6bcfd97 612 // enter m_critsect before changing the thread state
d3f8206c
VZ
613 //
614 // NB: can't use wxCriticalSectionLocker here as we use SEH and it's
615 // incompatible with C++ object dtors
616 thread->m_critsect.Enter();
f6bcfd97 617 thread->m_internal->SetState(STATE_EXITED);
d3f8206c 618 thread->m_critsect.Leave();
f6bcfd97 619 }
b568d04f 620
3ef22a5b 621 // the thread may delete itself now if it wants, we don't need it any more
0f00be4b
VZ
622 if ( isDetached )
623 thread->m_internal->LetDie();
bf1852e1 624
b568d04f 625 return rc;
2bda0e17
KB
626}
627
b568d04f 628void wxThreadInternal::SetPriority(unsigned int priority)
2bda0e17 629{
b568d04f 630 m_priority = priority;
3222fde2 631
77ffb593 632 // translate wxWidgets priority to the Windows one
bf1852e1
VZ
633 int win_priority;
634 if (m_priority <= 20)
635 win_priority = THREAD_PRIORITY_LOWEST;
636 else if (m_priority <= 40)
637 win_priority = THREAD_PRIORITY_BELOW_NORMAL;
638 else if (m_priority <= 60)
639 win_priority = THREAD_PRIORITY_NORMAL;
640 else if (m_priority <= 80)
641 win_priority = THREAD_PRIORITY_ABOVE_NORMAL;
642 else if (m_priority <= 100)
643 win_priority = THREAD_PRIORITY_HIGHEST;
3222fde2
VZ
644 else
645 {
223d09f6 646 wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
bf1852e1 647 win_priority = THREAD_PRIORITY_NORMAL;
3222fde2
VZ
648 }
649
b568d04f 650 if ( !::SetThreadPriority(m_hThread, win_priority) )
bee503b0
VZ
651 {
652 wxLogSysError(_("Can't set thread priority"));
653 }
b568d04f
VZ
654}
655
6fe73788 656bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
b568d04f 657{
50ef4401 658 wxASSERT_MSG( m_state == STATE_NEW && !m_hThread,
9a83f860 659 wxT("Create()ing thread twice?") );
50ef4401 660
b568d04f
VZ
661 // for compilers which have it, we should use C RTL function for thread
662 // creation instead of Win32 API one because otherwise we will have memory
663 // leaks if the thread uses C RTL (and most threads do)
9f51f2b6 664#ifdef wxUSE_BEGIN_THREAD
414c639c
VZ
665
666 // Watcom is reported to not like 0 stack size (which means "use default"
667 // for the other compilers and is also the default value for stackSize)
668#ifdef __WATCOMC__
669 if ( !stackSize )
670 stackSize = 10240;
671#endif // __WATCOMC__
672
9f51f2b6
VZ
673 m_hThread = (HANDLE)_beginthreadex
674 (
6fe73788
RL
675 NULL, // default security
676 stackSize,
677 wxThreadInternal::WinThreadStart, // entry point
678 thread,
679 CREATE_SUSPENDED,
680 (unsigned int *)&m_tid
9f51f2b6 681 );
611cb666 682#else // compiler doesn't have _beginthreadex
b568d04f
VZ
683 m_hThread = ::CreateThread
684 (
685 NULL, // default security
414c639c 686 stackSize, // stack size
9f51f2b6 687 wxThreadInternal::WinThreadStart, // thread entry point
b568d04f
VZ
688 (LPVOID)thread, // parameter
689 CREATE_SUSPENDED, // flags
690 &m_tid // [out] thread id
691 );
611cb666 692#endif // _beginthreadex/CreateThread
b568d04f
VZ
693
694 if ( m_hThread == NULL )
695 {
696 wxLogSysError(_("Can't create thread"));
697
3ef22a5b 698 return false;
b568d04f
VZ
699 }
700
701 if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
702 {
703 SetPriority(m_priority);
704 }
3222fde2 705
3ef22a5b 706 return true;
2bda0e17
KB
707}
708
68d41720
VZ
709wxThreadError wxThreadInternal::Kill()
710{
df191bfe
VZ
711 m_thread->OnKill();
712
3f49efdb 713 if ( !::TerminateThread(m_hThread, THREAD_ERROR_EXIT) )
68d41720
VZ
714 {
715 wxLogSysError(_("Couldn't terminate thread"));
716
717 return wxTHREAD_MISC_ERROR;
718 }
719
720 Free();
721
722 return wxTHREAD_NO_ERROR;
723}
724
725wxThreadError
3ef22a5b
VZ
726wxThreadInternal::WaitForTerminate(wxCriticalSection& cs,
727 wxThread::ExitCode *pRc,
b95a7c31 728 wxThreadWait waitMode,
3ef22a5b 729 wxThread *threadToDelete)
68d41720 730{
3ef22a5b
VZ
731 // prevent the thread C++ object from disappearing as long as we are using
732 // it here
733 wxThreadKeepAlive keepAlive(*this);
734
735
736 // we may either wait passively for the thread to terminate (when called
737 // from Wait()) or ask it to terminate (when called from Delete())
738 bool shouldDelete = threadToDelete != NULL;
739
3f49efdb 740 DWORD rc = 0;
68d41720 741
0f00be4b
VZ
742 // we might need to resume the thread if it's currently stopped
743 bool shouldResume = false;
68d41720 744
0f00be4b
VZ
745 // as Delete() (which calls us) is always safe to call we need to consider
746 // all possible states
68d41720
VZ
747 {
748 wxCriticalSectionLocker lock(cs);
749
750 if ( m_state == STATE_NEW )
751 {
3ef22a5b 752 if ( shouldDelete )
68d41720 753 {
63fa42b3
VZ
754 // WinThreadStart() will see it and terminate immediately, no
755 // need to cancel the thread -- but we still need to resume it
756 // to let it run
68d41720
VZ
757 m_state = STATE_EXITED;
758
0f00be4b
VZ
759 // we must call Resume() as the thread hasn't been initially
760 // resumed yet (and as Resume() it knows about STATE_EXITED
761 // special case, it won't touch it and WinThreadStart() will
762 // just exit immediately)
763 shouldResume = true;
3ef22a5b 764 shouldDelete = false;
68d41720 765 }
0f00be4b
VZ
766 //else: shouldResume is correctly set to false here, wait until
767 // someone else runs the thread and it finishes
68d41720 768 }
0f00be4b 769 else // running, paused, cancelled or even exited
68d41720
VZ
770 {
771 shouldResume = m_state == STATE_PAUSED;
772 }
773 }
774
775 // resume the thread if it is paused
776 if ( shouldResume )
777 Resume();
778
0f00be4b
VZ
779 // ask the thread to terminate
780 if ( shouldDelete )
68d41720 781 {
0f00be4b 782 wxCriticalSectionLocker lock(cs);
68d41720 783
0f00be4b
VZ
784 Cancel();
785 }
68d41720 786
486fa396
VZ
787 if ( threadToDelete )
788 threadToDelete->OnDelete();
68d41720 789
0f00be4b
VZ
790 // now wait for thread to finish
791 if ( wxThread::IsMain() )
792 {
793 // set flag for wxIsWaitingForThread()
794 gs_waitingForThread = true;
795 }
796
797 // we can't just wait for the thread to terminate because it might be
798 // calling some GUI functions and so it will never terminate before we
799 // process the Windows messages that result from these functions
800 // (note that even in console applications we might have to process
801 // messages if we use wxExecute() or timers or ...)
802 DWORD result wxDUMMY_INITIALIZE(0);
803 do
804 {
805 if ( wxThread::IsMain() )
68d41720 806 {
0f00be4b
VZ
807 // give the thread we're waiting for chance to do the GUI call
808 // it might be in
809 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
68d41720 810 {
0f00be4b 811 wxMutexGuiLeave();
68d41720 812 }
0f00be4b 813 }
68d41720 814
e570a44b
VZ
815 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
816 if ( traits )
817 {
b95a7c31 818 result = traits->WaitForThread(m_hThread, waitMode);
e570a44b
VZ
819 }
820 else // can't wait for the thread
821 {
822 // so kill it below
823 result = 0xFFFFFFFF;
824 }
0f00be4b
VZ
825
826 switch ( result )
827 {
828 case 0xFFFFFFFF:
829 // error
4c51a665 830 wxLogSysError(_("Cannot wait for thread termination"));
0f00be4b
VZ
831 Kill();
832 return wxTHREAD_KILLED;
833
834 case WAIT_OBJECT_0:
835 // thread we're waiting for terminated
836 break;
837
838 case WAIT_OBJECT_0 + 1:
839 // new message arrived, process it -- but only if we're the
840 // main thread as we don't support processing messages in
841 // the other ones
842 //
843 // NB: we still must include QS_ALLINPUT even when waiting
844 // in a secondary thread because if it had created some
845 // window somehow (possible not even using wxWidgets)
846 // the system might dead lock then
847 if ( wxThread::IsMain() )
848 {
0f00be4b 849 if ( traits && !traits->DoMessageFromThreadWait() )
68d41720 850 {
0f00be4b
VZ
851 // WM_QUIT received: kill the thread
852 Kill();
68d41720 853
0f00be4b
VZ
854 return wxTHREAD_KILLED;
855 }
856 }
857 break;
68d41720 858
0f00be4b
VZ
859 default:
860 wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
68d41720 861 }
0f00be4b
VZ
862 } while ( result != WAIT_OBJECT_0 );
863
864 if ( wxThread::IsMain() )
865 {
866 gs_waitingForThread = false;
68d41720
VZ
867 }
868
0f00be4b 869
68d41720
VZ
870 // although the thread might be already in the EXITED state it might not
871 // have terminated yet and so we are not sure that it has actually
872 // terminated if the "if" above hadn't been taken
7d0bf46a 873 for ( ;; )
68d41720 874 {
3f49efdb 875 if ( !::GetExitCodeThread(m_hThread, &rc) )
68d41720
VZ
876 {
877 wxLogLastError(wxT("GetExitCodeThread"));
878
3f49efdb 879 rc = THREAD_ERROR_EXIT;
7d0bf46a
VZ
880
881 break;
68d41720 882 }
7d0bf46a 883
3f49efdb 884 if ( rc != STILL_ACTIVE )
7d0bf46a
VZ
885 break;
886
887 // give the other thread some time to terminate, otherwise we may be
888 // starving it
889 ::Sleep(1);
890 }
68d41720
VZ
891
892 if ( pRc )
3f49efdb 893 *pRc = wxUIntToPtr(rc);
68d41720 894
3ef22a5b 895 // we don't need the thread handle any more in any case
4f45ba63
VZ
896 Free();
897
4f45ba63 898
3f49efdb 899 return rc == THREAD_ERROR_EXIT ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
68d41720
VZ
900}
901
bf1852e1 902bool wxThreadInternal::Suspend()
2bda0e17 903{
bf1852e1
VZ
904 DWORD nSuspendCount = ::SuspendThread(m_hThread);
905 if ( nSuspendCount == (DWORD)-1 )
bee503b0 906 {
4c51a665 907 wxLogSysError(_("Cannot suspend thread %x"), m_hThread);
bf1852e1 908
3ef22a5b 909 return false;
bee503b0 910 }
2bda0e17 911
bf1852e1
VZ
912 m_state = STATE_PAUSED;
913
3ef22a5b 914 return true;
a6b0bd49
VZ
915}
916
bf1852e1 917bool wxThreadInternal::Resume()
a6b0bd49 918{
bf1852e1 919 DWORD nSuspendCount = ::ResumeThread(m_hThread);
a6b0bd49
VZ
920 if ( nSuspendCount == (DWORD)-1 )
921 {
4c51a665 922 wxLogSysError(_("Cannot resume thread %x"), m_hThread);
a6b0bd49 923
3ef22a5b 924 return false;
a6b0bd49
VZ
925 }
926
f6bcfd97
BP
927 // don't change the state from STATE_EXITED because it's special and means
928 // we are going to terminate without running any user code - if we did it,
0f00be4b 929 // the code in WaitForTerminate() wouldn't work
f6bcfd97
BP
930 if ( m_state != STATE_EXITED )
931 {
932 m_state = STATE_RUNNING;
933 }
bee503b0 934
3ef22a5b 935 return true;
a6b0bd49
VZ
936}
937
bf1852e1
VZ
938// static functions
939// ----------------
940
941wxThread *wxThread::This()
a6b0bd49 942{
b568d04f 943 wxThread *thread = (wxThread *)::TlsGetValue(gs_tlsThisThread);
bf1852e1
VZ
944
945 // be careful, 0 may be a valid return value as well
946 if ( !thread && (::GetLastError() != NO_ERROR) )
a6b0bd49 947 {
bf1852e1 948 wxLogSysError(_("Couldn't get the current thread pointer"));
a6b0bd49 949
bf1852e1 950 // return NULL...
a6b0bd49
VZ
951 }
952
bf1852e1
VZ
953 return thread;
954}
955
bf1852e1
VZ
956void wxThread::Yield()
957{
b568d04f
VZ
958 // 0 argument to Sleep() is special and means to just give away the rest of
959 // our timeslice
bf1852e1
VZ
960 ::Sleep(0);
961}
962
ef8d96c2
VZ
963int wxThread::GetCPUCount()
964{
28a4627c
VZ
965 SYSTEM_INFO si;
966 GetSystemInfo(&si);
967
968 return si.dwNumberOfProcessors;
ef8d96c2
VZ
969}
970
4958ea8f
RD
971unsigned long wxThread::GetCurrentId()
972{
973 return (unsigned long)::GetCurrentThreadId();
974}
975
0c0d1521 976bool wxThread::SetConcurrency(size_t WXUNUSED_IN_WINCE(level))
ef8d96c2 977{
7010702f 978#ifdef __WXWINCE__
7010702f
WS
979 return false;
980#else
9a83f860 981 wxASSERT_MSG( IsMain(), wxT("should only be called from the main thread") );
28a4627c 982
ef8d96c2 983 // ok only for the default one
28a4627c
VZ
984 if ( level == 0 )
985 return 0;
986
987 // get system affinity mask first
988 HANDLE hProcess = ::GetCurrentProcess();
975b6bcf 989 DWORD_PTR dwProcMask, dwSysMask;
28a4627c
VZ
990 if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
991 {
9a83f860 992 wxLogLastError(wxT("GetProcessAffinityMask"));
28a4627c 993
3ef22a5b 994 return false;
28a4627c
VZ
995 }
996
997 // how many CPUs have we got?
998 if ( dwSysMask == 1 )
999 {
1000 // don't bother with all this complicated stuff - on a single
1001 // processor system it doesn't make much sense anyhow
1002 return level == 1;
1003 }
1004
1005 // calculate the process mask: it's a bit vector with one bit per
1006 // processor; we want to schedule the process to run on first level
1007 // CPUs
1008 DWORD bit = 1;
1009 while ( bit )
1010 {
1011 if ( dwSysMask & bit )
1012 {
1013 // ok, we can set this bit
1014 dwProcMask |= bit;
1015
1016 // another process added
8d7eaf91 1017 if ( --level == 0 )
28a4627c
VZ
1018 {
1019 // and that's enough
1020 break;
1021 }
1022 }
1023
1024 // next bit
1025 bit <<= 1;
1026 }
1027
1028 // could we set all bits?
1029 if ( level != 0 )
1030 {
9a83f860 1031 wxLogDebug(wxT("bad level %u in wxThread::SetConcurrency()"), level);
28a4627c 1032
3ef22a5b 1033 return false;
28a4627c
VZ
1034 }
1035
1036 // set it: we can't link to SetProcessAffinityMask() because it doesn't
1037 // exist in Win9x, use RT binding instead
1038
fdb9d2b8 1039 typedef BOOL (WINAPI *SETPROCESSAFFINITYMASK)(HANDLE, DWORD_PTR);
28a4627c
VZ
1040
1041 // can use static var because we're always in the main thread here
1042 static SETPROCESSAFFINITYMASK pfnSetProcessAffinityMask = NULL;
1043
1044 if ( !pfnSetProcessAffinityMask )
1045 {
9a83f860 1046 HMODULE hModKernel = ::LoadLibrary(wxT("kernel32"));
28a4627c
VZ
1047 if ( hModKernel )
1048 {
1049 pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
f6bcfd97 1050 ::GetProcAddress(hModKernel, "SetProcessAffinityMask");
28a4627c
VZ
1051 }
1052
1053 // we've discovered a MT version of Win9x!
1054 wxASSERT_MSG( pfnSetProcessAffinityMask,
9a83f860 1055 wxT("this system has several CPUs but no SetProcessAffinityMask function?") );
28a4627c
VZ
1056 }
1057
1058 if ( !pfnSetProcessAffinityMask )
1059 {
1060 // msg given above - do it only once
3ef22a5b 1061 return false;
28a4627c
VZ
1062 }
1063
696e1ea0 1064 if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
28a4627c 1065 {
9a83f860 1066 wxLogLastError(wxT("SetProcessAffinityMask"));
28a4627c 1067
3ef22a5b 1068 return false;
28a4627c 1069 }
975b6bcf 1070
3ef22a5b 1071 return true;
7010702f 1072#endif // __WXWINCE__/!__WXWINCE__
ef8d96c2
VZ
1073}
1074
b568d04f
VZ
1075// ctor and dtor
1076// -------------
1077
1078wxThread::wxThread(wxThreadKind kind)
1079{
3ef22a5b 1080 m_internal = new wxThreadInternal(this);
b568d04f
VZ
1081
1082 m_isDetached = kind == wxTHREAD_DETACHED;
1083}
1084
1085wxThread::~wxThread()
1086{
9fc3ad34 1087 delete m_internal;
b568d04f
VZ
1088}
1089
bf1852e1
VZ
1090// create/start thread
1091// -------------------
1092
6fe73788 1093wxThreadError wxThread::Create(unsigned int stackSize)
bf1852e1 1094{
b568d04f
VZ
1095 wxCriticalSectionLocker lock(m_critsect);
1096
6fe73788 1097 if ( !m_internal->Create(this, stackSize) )
bf1852e1 1098 return wxTHREAD_NO_RESOURCE;
bee503b0 1099
a6b0bd49 1100 return wxTHREAD_NO_ERROR;
2bda0e17
KB
1101}
1102
bf1852e1 1103wxThreadError wxThread::Run()
2bda0e17 1104{
bf1852e1
VZ
1105 wxCriticalSectionLocker lock(m_critsect);
1106
89a76d5d
FM
1107 wxCHECK_MSG( m_internal->GetState() == STATE_NEW, wxTHREAD_RUNNING,
1108 wxT("thread may only be started once after Create()") );
bf1852e1 1109
b568d04f 1110 // the thread has just been created and is still suspended - let it run
bf1852e1 1111 return Resume();
2bda0e17
KB
1112}
1113
bf1852e1
VZ
1114// suspend/resume thread
1115// ---------------------
1116
1117wxThreadError wxThread::Pause()
2bda0e17 1118{
bf1852e1
VZ
1119 wxCriticalSectionLocker lock(m_critsect);
1120
9fc3ad34 1121 return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
2bda0e17
KB
1122}
1123
bf1852e1 1124wxThreadError wxThread::Resume()
2bda0e17 1125{
bf1852e1
VZ
1126 wxCriticalSectionLocker lock(m_critsect);
1127
9fc3ad34 1128 return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
2bda0e17
KB
1129}
1130
bf1852e1
VZ
1131// stopping thread
1132// ---------------
1133
b95a7c31 1134wxThread::ExitCode wxThread::Wait(wxThreadWait waitMode)
b568d04f 1135{
d79c9c67 1136 ExitCode rc = wxUIntToPtr(THREAD_ERROR_EXIT);
3f49efdb 1137
b568d04f
VZ
1138 // although under Windows we can wait for any thread, it's an error to
1139 // wait for a detached one in wxWin API
3f49efdb 1140 wxCHECK_MSG( !IsDetached(), rc,
9a83f860 1141 wxT("wxThread::Wait(): can't wait for detached thread") );
b568d04f 1142
b95a7c31 1143 (void)m_internal->WaitForTerminate(m_critsect, &rc, waitMode);
b568d04f 1144
b568d04f
VZ
1145 return rc;
1146}
1147
b95a7c31 1148wxThreadError wxThread::Delete(ExitCode *pRc, wxThreadWait waitMode)
2bda0e17 1149{
b95a7c31 1150 return m_internal->WaitForTerminate(m_critsect, pRc, waitMode, this);
2bda0e17
KB
1151}
1152
bf1852e1 1153wxThreadError wxThread::Kill()
2bda0e17 1154{
bf1852e1
VZ
1155 if ( !IsRunning() )
1156 return wxTHREAD_NOT_RUNNING;
1157
68d41720 1158 wxThreadError rc = m_internal->Kill();
b568d04f
VZ
1159
1160 if ( IsDetached() )
1161 {
1162 delete this;
1163 }
57fd9bb2
VZ
1164 else // joinable
1165 {
1166 // update the status of the joinable thread
1167 wxCriticalSectionLocker lock(m_critsect);
1168 m_internal->SetState(STATE_EXITED);
1169 }
bf1852e1 1170
68d41720 1171 return rc;
2bda0e17
KB
1172}
1173
b568d04f 1174void wxThread::Exit(ExitCode status)
2bda0e17 1175{
66180c31
VZ
1176 wxThreadInternal::DoThreadOnExit(this);
1177
9fc3ad34 1178 m_internal->Free();
2bda0e17 1179
b568d04f
VZ
1180 if ( IsDetached() )
1181 {
1182 delete this;
1183 }
57fd9bb2
VZ
1184 else // joinable
1185 {
1186 // update the status of the joinable thread
1187 wxCriticalSectionLocker lock(m_critsect);
1188 m_internal->SetState(STATE_EXITED);
1189 }
b568d04f 1190
9f51f2b6 1191#ifdef wxUSE_BEGIN_THREAD
3f49efdb 1192 _endthreadex(wxPtrToUInt(status));
b568d04f 1193#else // !VC++
bf1852e1 1194 ::ExitThread((DWORD)status);
b568d04f 1195#endif // VC++/!VC++
2bda0e17 1196
223d09f6 1197 wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
bf1852e1 1198}
2bda0e17 1199
b568d04f
VZ
1200// priority setting
1201// ----------------
1202
bf1852e1
VZ
1203void wxThread::SetPriority(unsigned int prio)
1204{
1205 wxCriticalSectionLocker lock(m_critsect);
1206
9fc3ad34 1207 m_internal->SetPriority(prio);
bf1852e1 1208}
2bda0e17 1209
bf1852e1
VZ
1210unsigned int wxThread::GetPriority() const
1211{
f48a1159 1212 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
2bda0e17 1213
9fc3ad34 1214 return m_internal->GetPriority();
2bda0e17
KB
1215}
1216
b568d04f 1217unsigned long wxThread::GetId() const
2bda0e17 1218{
f48a1159 1219 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
bf1852e1 1220
9fc3ad34 1221 return (unsigned long)m_internal->GetId();
2bda0e17
KB
1222}
1223
72fd19a1
JS
1224bool wxThread::IsRunning() const
1225{
f48a1159 1226 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
bf1852e1 1227
9fc3ad34 1228 return m_internal->GetState() == STATE_RUNNING;
72fd19a1
JS
1229}
1230
1231bool wxThread::IsAlive() const
1232{
f48a1159 1233 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
bf1852e1 1234
9fc3ad34
VZ
1235 return (m_internal->GetState() == STATE_RUNNING) ||
1236 (m_internal->GetState() == STATE_PAUSED);
72fd19a1
JS
1237}
1238
a737331d
GL
1239bool wxThread::IsPaused() const
1240{
f48a1159 1241 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
a737331d 1242
9fc3ad34 1243 return m_internal->GetState() == STATE_PAUSED;
a737331d
GL
1244}
1245
8c10faf1 1246bool wxThread::TestDestroy()
2bda0e17 1247{
f48a1159 1248 wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
bf1852e1 1249
9fc3ad34 1250 return m_internal->GetState() == STATE_CANCELED;
2bda0e17
KB
1251}
1252
3222fde2
VZ
1253// ----------------------------------------------------------------------------
1254// Automatic initialization for thread module
1255// ----------------------------------------------------------------------------
2bda0e17 1256
3222fde2 1257class wxThreadModule : public wxModule
a6b0bd49 1258{
3222fde2
VZ
1259public:
1260 virtual bool OnInit();
1261 virtual void OnExit();
d524867f 1262
3222fde2
VZ
1263private:
1264 DECLARE_DYNAMIC_CLASS(wxThreadModule)
1265};
d524867f
RR
1266
1267IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
1268
3222fde2 1269bool wxThreadModule::OnInit()
d524867f 1270{
bf1852e1 1271 // allocate TLS index for storing the pointer to the current thread
b568d04f
VZ
1272 gs_tlsThisThread = ::TlsAlloc();
1273 if ( gs_tlsThisThread == 0xFFFFFFFF )
bf1852e1
VZ
1274 {
1275 // in normal circumstances it will only happen if all other
1276 // TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
1277 // words, this should never happen
f6bcfd97 1278 wxLogSysError(_("Thread module initialization failed: impossible to allocate index in thread local storage"));
bf1852e1 1279
3ef22a5b 1280 return false;
bf1852e1
VZ
1281 }
1282
1283 // main thread doesn't have associated wxThread object, so store 0 in the
1284 // TLS instead
b568d04f 1285 if ( !::TlsSetValue(gs_tlsThisThread, (LPVOID)0) )
bf1852e1 1286 {
b568d04f
VZ
1287 ::TlsFree(gs_tlsThisThread);
1288 gs_tlsThisThread = 0xFFFFFFFF;
bf1852e1 1289
4c51a665 1290 wxLogSysError(_("Thread module initialization failed: cannot store value in thread local storage"));
bf1852e1 1291
3ef22a5b 1292 return false;
bf1852e1
VZ
1293 }
1294
b568d04f 1295 gs_critsectWaitingForGui = new wxCriticalSection();
bee503b0 1296
b568d04f
VZ
1297 gs_critsectGui = new wxCriticalSection();
1298 gs_critsectGui->Enter();
bee503b0 1299
3ef22a5b
VZ
1300 gs_critsectThreadDelete = new wxCriticalSection;
1301
f9226383 1302 wxThread::ms_idMainThread = wxThread::GetCurrentId();
3222fde2 1303
3ef22a5b 1304 return true;
d524867f
RR
1305}
1306
3222fde2 1307void wxThreadModule::OnExit()
d524867f 1308{
b568d04f 1309 if ( !::TlsFree(gs_tlsThisThread) )
bf1852e1 1310 {
f6bcfd97 1311 wxLogLastError(wxT("TlsFree failed."));
bf1852e1
VZ
1312 }
1313
5276b0a5 1314 wxDELETE(gs_critsectThreadDelete);
3ef22a5b 1315
b568d04f 1316 if ( gs_critsectGui )
3222fde2 1317 {
b568d04f 1318 gs_critsectGui->Leave();
5276b0a5 1319 wxDELETE(gs_critsectGui);
3222fde2 1320 }
bee503b0 1321
5276b0a5 1322 wxDELETE(gs_critsectWaitingForGui);
3222fde2
VZ
1323}
1324
bee503b0 1325// ----------------------------------------------------------------------------
b568d04f 1326// under Windows, these functions are implemented using a critical section and
3222fde2 1327// not a mutex, so the names are a bit confusing
bee503b0
VZ
1328// ----------------------------------------------------------------------------
1329
d254213e 1330void wxMutexGuiEnterImpl()
3222fde2 1331{
bee503b0
VZ
1332 // this would dead lock everything...
1333 wxASSERT_MSG( !wxThread::IsMain(),
223d09f6 1334 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
bee503b0
VZ
1335
1336 // the order in which we enter the critical sections here is crucial!!
1337
1338 // set the flag telling to the main thread that we want to do some GUI
1339 {
b568d04f 1340 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
bee503b0 1341
b568d04f 1342 gs_nWaitingForGui++;
bee503b0
VZ
1343 }
1344
1345 wxWakeUpMainThread();
1346
1347 // now we may block here because the main thread will soon let us in
1348 // (during the next iteration of OnIdle())
b568d04f 1349 gs_critsectGui->Enter();
3222fde2
VZ
1350}
1351
d254213e 1352void wxMutexGuiLeaveImpl()
3222fde2 1353{
b568d04f 1354 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
bee503b0
VZ
1355
1356 if ( wxThread::IsMain() )
1357 {
3ef22a5b 1358 gs_bGuiOwnedByMainThread = false;
bee503b0
VZ
1359 }
1360 else
1361 {
4d1c1c3c 1362 // decrement the number of threads waiting for GUI access now
b568d04f 1363 wxASSERT_MSG( gs_nWaitingForGui > 0,
223d09f6 1364 wxT("calling wxMutexGuiLeave() without entering it first?") );
bee503b0 1365
b568d04f 1366 gs_nWaitingForGui--;
bee503b0
VZ
1367
1368 wxWakeUpMainThread();
1369 }
1370
b568d04f 1371 gs_critsectGui->Leave();
bee503b0
VZ
1372}
1373
0c2f35dc 1374void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
bee503b0
VZ
1375{
1376 wxASSERT_MSG( wxThread::IsMain(),
223d09f6 1377 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
bee503b0 1378
b568d04f 1379 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
bee503b0 1380
b568d04f 1381 if ( gs_nWaitingForGui == 0 )
bee503b0
VZ
1382 {
1383 // no threads are waiting for GUI - so we may acquire the lock without
1384 // any danger (but only if we don't already have it)
1385 if ( !wxGuiOwnedByMainThread() )
1386 {
b568d04f 1387 gs_critsectGui->Enter();
bee503b0 1388
3ef22a5b 1389 gs_bGuiOwnedByMainThread = true;
bee503b0
VZ
1390 }
1391 //else: already have it, nothing to do
1392 }
1393 else
1394 {
1395 // some threads are waiting, release the GUI lock if we have it
1396 if ( wxGuiOwnedByMainThread() )
1397 {
1398 wxMutexGuiLeave();
1399 }
1400 //else: some other worker thread is doing GUI
1401 }
1402}
1403
0c2f35dc 1404bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
bee503b0 1405{
b568d04f 1406 return gs_bGuiOwnedByMainThread;
bee503b0
VZ
1407}
1408
1409// wake up the main thread if it's in ::GetMessage()
0c2f35dc 1410void WXDLLIMPEXP_BASE wxWakeUpMainThread()
bee503b0
VZ
1411{
1412 // sending any message would do - hopefully WM_NULL is harmless enough
3cc63190 1413 if ( !::PostThreadMessage(wxThread::GetMainId(), WM_NULL, 0, 0) )
bee503b0
VZ
1414 {
1415 // should never happen
f6bcfd97 1416 wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
bee503b0 1417 }
3222fde2 1418}
d524867f 1419
0c2f35dc 1420bool WXDLLIMPEXP_BASE wxIsWaitingForThread()
bf1852e1 1421{
b568d04f 1422 return gs_waitingForThread;
bf1852e1
VZ
1423}
1424
9e84b847
VZ
1425// ----------------------------------------------------------------------------
1426// include common implementation code
1427// ----------------------------------------------------------------------------
1428
1429#include "wx/thrimpl.cpp"
1430
3222fde2 1431#endif // wxUSE_THREADS