]> git.saurik.com Git - wxWidgets.git/blob - include/wx/thread.h
Avoid virtual function hiding.
[wxWidgets.git] / include / wx / thread.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/thread.h
3 // Purpose: Thread API
4 // Author: Guilhem Lavaux
5 // Modified by: Vadim Zeitlin (modifications partly inspired by omnithreads
6 // package from Olivetti & Oracle Research Laboratory)
7 // Created: 04/13/98
8 // RCS-ID: $Id$
9 // Copyright: (c) Guilhem Lavaux
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 #ifndef _WX_THREAD_H_
14 #define _WX_THREAD_H_
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // get the value of wxUSE_THREADS configuration flag
21 #include "wx/defs.h"
22
23 #if wxUSE_THREADS
24
25 // only for wxUSE_THREADS - otherwise we'd get undefined symbols
26 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
27 #pragma interface "thread.h"
28 #endif
29
30 // Windows headers define it
31 #ifdef Yield
32 #undef Yield
33 #endif
34
35 // ----------------------------------------------------------------------------
36 // constants
37 // ----------------------------------------------------------------------------
38
39 enum wxMutexError
40 {
41 wxMUTEX_NO_ERROR = 0, // operation completed successfully
42 wxMUTEX_INVALID, // mutex hasn't been initialized
43 wxMUTEX_DEAD_LOCK, // mutex is already locked by the calling thread
44 wxMUTEX_BUSY, // mutex is already locked by another thread
45 wxMUTEX_UNLOCKED, // attempt to unlock a mutex which is not locked
46 wxMUTEX_MISC_ERROR // any other error
47 };
48
49 enum wxCondError
50 {
51 wxCOND_NO_ERROR = 0,
52 wxCOND_INVALID,
53 wxCOND_TIMEOUT, // WaitTimeout() has timed out
54 wxCOND_MISC_ERROR
55 };
56
57 enum wxSemaError
58 {
59 wxSEMA_NO_ERROR = 0,
60 wxSEMA_INVALID, // semaphore hasn't been initialized successfully
61 wxSEMA_BUSY, // returned by TryWait() if Wait() would block
62 wxSEMA_TIMEOUT, // returned by WaitTimeout()
63 wxSEMA_OVERFLOW, // Post() would increase counter past the max
64 wxSEMA_MISC_ERROR
65 };
66
67 enum wxThreadError
68 {
69 wxTHREAD_NO_ERROR = 0, // No error
70 wxTHREAD_NO_RESOURCE, // No resource left to create a new thread
71 wxTHREAD_RUNNING, // The thread is already running
72 wxTHREAD_NOT_RUNNING, // The thread isn't running
73 wxTHREAD_KILLED, // Thread we waited for had to be killed
74 wxTHREAD_MISC_ERROR // Some other error
75 };
76
77 enum wxThreadKind
78 {
79 wxTHREAD_DETACHED,
80 wxTHREAD_JOINABLE
81 };
82
83 // defines the interval of priority
84 enum
85 {
86 WXTHREAD_MIN_PRIORITY = 0u,
87 WXTHREAD_DEFAULT_PRIORITY = 50u,
88 WXTHREAD_MAX_PRIORITY = 100u
89 };
90
91 // There are 2 types of mutexes: normal mutexes and recursive ones. The attempt
92 // to lock a normal mutex by a thread which already owns it results in
93 // undefined behaviour (it always works under Windows, it will almost always
94 // result in a deadlock under Unix). Locking a recursive mutex in such
95 // situation always succeeds and it must be unlocked as many times as it has
96 // been locked.
97 //
98 // However recursive mutexes have several important drawbacks: first, in the
99 // POSIX implementation, they're less efficient. Second, and more importantly,
100 // they CAN NOT BE USED WITH CONDITION VARIABLES under Unix! Using them with
101 // wxCondition will work under Windows and some Unices (notably Linux) but will
102 // deadlock under other Unix versions (e.g. Solaris). As it might be difficult
103 // to ensure that a recursive mutex is not used with wxCondition, it is a good
104 // idea to avoid using recursive mutexes at all. Also, the last problem with
105 // them is that some (older) Unix versions don't support this at all -- which
106 // results in a configure warning when building and a deadlock when using them.
107 enum wxMutexType
108 {
109 // normal mutex: try to always use this one
110 wxMUTEX_DEFAULT,
111
112 // recursive mutex: don't use these ones with wxCondition
113 wxMUTEX_RECURSIVE
114 };
115
116 // forward declarations
117 class WXDLLIMPEXP_BASE wxThreadHelper;
118 class WXDLLIMPEXP_BASE wxConditionInternal;
119 class WXDLLIMPEXP_BASE wxMutexInternal;
120 class WXDLLIMPEXP_BASE wxSemaphoreInternal;
121 class WXDLLIMPEXP_BASE wxThreadInternal;
122
123 // ----------------------------------------------------------------------------
124 // A mutex object is a synchronization object whose state is set to signaled
125 // when it is not owned by any thread, and nonsignaled when it is owned. Its
126 // name comes from its usefulness in coordinating mutually-exclusive access to
127 // a shared resource. Only one thread at a time can own a mutex object.
128 // ----------------------------------------------------------------------------
129
130 // you should consider wxMutexLocker whenever possible instead of directly
131 // working with wxMutex class - it is safer
132 class WXDLLIMPEXP_BASE wxMutex
133 {
134 public:
135 // constructor & destructor
136 // ------------------------
137
138 // create either default (always safe) or recursive mutex
139 wxMutex(wxMutexType mutexType = wxMUTEX_DEFAULT);
140
141 // destroys the mutex kernel object
142 ~wxMutex();
143
144 // test if the mutex has been created successfully
145 bool IsOk() const;
146
147 // mutex operations
148 // ----------------
149
150 // Lock the mutex, blocking on it until it is unlocked by the other thread.
151 // The result of locking a mutex already locked by the current thread
152 // depend on the mutex type.
153 //
154 // The caller must call Unlock() later if Lock() returned wxMUTEX_NO_ERROR.
155 wxMutexError Lock();
156
157 // Try to lock the mutex: if it is currently locked, return immediately
158 // with an error. Otherwise the caller must call Unlock().
159 wxMutexError TryLock();
160
161 // Unlock the mutex. It is an error to unlock an already unlocked mutex
162 wxMutexError Unlock();
163
164 protected:
165 wxMutexInternal *m_internal;
166
167 friend class wxConditionInternal;
168
169 DECLARE_NO_COPY_CLASS(wxMutex)
170 };
171
172 // a helper class which locks the mutex in the ctor and unlocks it in the dtor:
173 // this ensures that mutex is always unlocked, even if the function returns or
174 // throws an exception before it reaches the end
175 class WXDLLIMPEXP_BASE wxMutexLocker
176 {
177 public:
178 // lock the mutex in the ctor
179 wxMutexLocker(wxMutex& mutex)
180 : m_isOk(FALSE), m_mutex(mutex)
181 { m_isOk = ( m_mutex.Lock() == wxMUTEX_NO_ERROR ); }
182
183 // returns TRUE if mutex was successfully locked in ctor
184 bool IsOk() const
185 { return m_isOk; }
186
187 // unlock the mutex in dtor
188 ~wxMutexLocker()
189 { if ( IsOk() ) m_mutex.Unlock(); }
190
191 private:
192 // no assignment operator nor copy ctor
193 wxMutexLocker(const wxMutexLocker&);
194 wxMutexLocker& operator=(const wxMutexLocker&);
195
196 bool m_isOk;
197 wxMutex& m_mutex;
198 };
199
200 // ----------------------------------------------------------------------------
201 // Critical section: this is the same as mutex but is only visible to the
202 // threads of the same process. For the platforms which don't have native
203 // support for critical sections, they're implemented entirely in terms of
204 // mutexes.
205 //
206 // NB: wxCriticalSection object does not allocate any memory in its ctor
207 // which makes it possible to have static globals of this class
208 // ----------------------------------------------------------------------------
209
210 // in order to avoid any overhead under platforms where critical sections are
211 // just mutexes make all wxCriticalSection class functions inline
212 #if !defined(__WXMSW__)
213 #define wxCRITSECT_IS_MUTEX 1
214
215 #define wxCRITSECT_INLINE inline
216 #else // MSW
217 #define wxCRITSECT_IS_MUTEX 0
218
219 #define wxCRITSECT_INLINE
220 #endif // MSW/!MSW
221
222 // you should consider wxCriticalSectionLocker whenever possible instead of
223 // directly working with wxCriticalSection class - it is safer
224 class WXDLLIMPEXP_BASE wxCriticalSection
225 {
226 public:
227 // ctor & dtor
228 wxCRITSECT_INLINE wxCriticalSection();
229 wxCRITSECT_INLINE ~wxCriticalSection();
230
231 // enter the section (the same as locking a mutex)
232 wxCRITSECT_INLINE void Enter();
233
234 // leave the critical section (same as unlocking a mutex)
235 wxCRITSECT_INLINE void Leave();
236
237 private:
238 #if wxCRITSECT_IS_MUTEX
239 wxMutex m_mutex;
240 #elif defined(__WXMSW__)
241 // we can't allocate any memory in the ctor, so use placement new -
242 // unfortunately, we have to hardcode the sizeof() here because we can't
243 // include windows.h from this public header and we also have to use the
244 // union to force the correct (i.e. maximal) alignment
245 //
246 // if CRITICAL_SECTION size changes in Windows, you'll get an assert from
247 // thread.cpp and will need to increase the buffer size
248 //
249 // finally, we need this typedef instead of declaring m_buffer directly
250 // because otherwise the assert mentioned above wouldn't compile with some
251 // compilers (notably CodeWarrior 8)
252 #ifdef __WIN64__
253 typedef char wxCritSectBuffer[40];
254 #else // __WIN32__
255 typedef char wxCritSectBuffer[24];
256 #endif
257 union
258 {
259 unsigned long m_dummy1;
260 void *m_dummy2;
261
262 wxCritSectBuffer m_buffer;
263 };
264 #endif // Unix&OS2/Win32
265
266 DECLARE_NO_COPY_CLASS(wxCriticalSection)
267 };
268
269 #if wxCRITSECT_IS_MUTEX
270 // implement wxCriticalSection using mutexes
271 inline wxCriticalSection::wxCriticalSection() { }
272 inline wxCriticalSection::~wxCriticalSection() { }
273
274 inline void wxCriticalSection::Enter() { (void)m_mutex.Lock(); }
275 inline void wxCriticalSection::Leave() { (void)m_mutex.Unlock(); }
276 #endif // wxCRITSECT_IS_MUTEX
277
278 #undef wxCRITSECT_INLINE
279 #undef wxCRITSECT_IS_MUTEX
280
281 // wxCriticalSectionLocker is the same to critical sections as wxMutexLocker is
282 // to th mutexes
283 class WXDLLIMPEXP_BASE wxCriticalSectionLocker
284 {
285 public:
286 wxCriticalSectionLocker(wxCriticalSection& cs)
287 : m_critsect(cs)
288 {
289 m_critsect.Enter();
290 }
291
292 ~wxCriticalSectionLocker()
293 {
294 m_critsect.Leave();
295 }
296
297 private:
298 wxCriticalSection& m_critsect;
299
300 DECLARE_NO_COPY_CLASS(wxCriticalSectionLocker)
301 };
302
303 // ----------------------------------------------------------------------------
304 // wxCondition models a POSIX condition variable which allows one (or more)
305 // thread(s) to wait until some condition is fulfilled
306 // ----------------------------------------------------------------------------
307
308 class WXDLLIMPEXP_BASE wxCondition
309 {
310 public:
311 // Each wxCondition object is associated with a (single) wxMutex object.
312 // The mutex object MUST be locked before calling Wait()
313 wxCondition(wxMutex& mutex);
314
315 // dtor is not virtual, don't use this class polymorphically
316 ~wxCondition();
317
318 // return TRUE if the condition has been created successfully
319 bool IsOk() const;
320
321 // NB: the associated mutex MUST be locked beforehand by the calling thread
322 //
323 // it atomically releases the lock on the associated mutex
324 // and starts waiting to be woken up by a Signal()/Broadcast()
325 // once its signaled, then it will wait until it can reacquire
326 // the lock on the associated mutex object, before returning.
327 wxCondError Wait();
328
329 // exactly as Wait() except that it may also return if the specified
330 // timeout ellapses even if the condition hasn't been signalled: in this
331 // case, the return value is FALSE, otherwise (i.e. in case of a normal
332 // return) it is TRUE
333 //
334 // the timeeout parameter specifies a interval that needs to be waited in
335 // milliseconds
336 wxCondError WaitTimeout(unsigned long milliseconds);
337
338 // NB: the associated mutex may or may not be locked by the calling thread
339 //
340 // this method unblocks one thread if any are blocking on the condition.
341 // if no thread is blocking in Wait(), then the signal is NOT remembered
342 // The thread which was blocking on Wait(), will then reacquire the lock
343 // on the associated mutex object before returning
344 wxCondError Signal();
345
346 // NB: the associated mutex may or may not be locked by the calling thread
347 //
348 // this method unblocks all threads if any are blocking on the condition.
349 // if no thread is blocking in Wait(), then the signal is NOT remembered
350 // The threads which were blocking on Wait(), will then reacquire the lock
351 // on the associated mutex object before returning.
352 wxCondError Broadcast();
353
354
355 // deprecated version, don't use
356 bool Wait(unsigned long milliseconds)
357 { return WaitTimeout(milliseconds) == wxCOND_NO_ERROR; }
358
359 private:
360 wxConditionInternal *m_internal;
361
362 DECLARE_NO_COPY_CLASS(wxCondition)
363 };
364
365 // ----------------------------------------------------------------------------
366 // wxSemaphore: a counter limiting the number of threads concurrently accessing
367 // a shared resource
368 // ----------------------------------------------------------------------------
369
370 class WXDLLIMPEXP_BASE wxSemaphore
371 {
372 public:
373 // specifying a maxcount of 0 actually makes wxSemaphore behave as if there
374 // is no upper limit, if maxcount is 1 the semaphore behaves as a mutex
375 wxSemaphore( int initialcount = 0, int maxcount = 0 );
376
377 // dtor is not virtual, don't use this class polymorphically
378 ~wxSemaphore();
379
380 // return TRUE if the semaphore has been created successfully
381 bool IsOk() const;
382
383 // wait indefinitely, until the semaphore count goes beyond 0
384 // and then decrement it and return (this method might have been called
385 // Acquire())
386 wxSemaError Wait();
387
388 // same as Wait(), but does not block, returns wxSEMA_NO_ERROR if
389 // successful and wxSEMA_BUSY if the count is currently zero
390 wxSemaError TryWait();
391
392 // same as Wait(), but as a timeout limit, returns wxSEMA_NO_ERROR if the
393 // semaphore was acquired and wxSEMA_TIMEOUT if the timeout has ellapsed
394 wxSemaError WaitTimeout(unsigned long milliseconds);
395
396 // increments the semaphore count and signals one of the waiting threads
397 wxSemaError Post();
398
399 private:
400 wxSemaphoreInternal *m_internal;
401
402 DECLARE_NO_COPY_CLASS(wxSemaphore)
403 };
404
405 // ----------------------------------------------------------------------------
406 // wxThread: class encpasulating a thread of execution
407 // ----------------------------------------------------------------------------
408
409 // there are two different kinds of threads: joinable and detached (default)
410 // ones. Only joinable threads can return a return code and only detached
411 // threads auto-delete themselves - the user should delete the joinable
412 // threads manually.
413
414 // NB: in the function descriptions the words "this thread" mean the thread
415 // created by the wxThread object while "main thread" is the thread created
416 // during the process initialization (a.k.a. the GUI thread)
417
418 // On VMS thread pointers are 64 bits (also needed for other systems???
419 #ifdef __VMS
420 typedef unsigned long long wxThreadIdType;
421 #else
422 typedef unsigned long wxThreadIdType;
423 #endif
424
425 class WXDLLIMPEXP_BASE wxThread
426 {
427 public:
428 // the return type for the thread function
429 typedef void *ExitCode;
430
431 // static functions
432 // Returns the wxThread object for the calling thread. NULL is returned
433 // if the caller is the main thread (but it's recommended to use
434 // IsMain() and only call This() for threads other than the main one
435 // because NULL is also returned on error). If the thread wasn't
436 // created with wxThread class, the returned value is undefined.
437 static wxThread *This();
438
439 // Returns true if current thread is the main thread.
440 static bool IsMain();
441
442 // Release the rest of our time slice leting the other threads run
443 static void Yield();
444
445 // Sleep during the specified period of time in milliseconds
446 //
447 // NB: at least under MSW worker threads can not call ::wxSleep()!
448 static void Sleep(unsigned long milliseconds);
449
450 // get the number of system CPUs - useful with SetConcurrency()
451 // (the "best" value for it is usually number of CPUs + 1)
452 //
453 // Returns -1 if unknown, number of CPUs otherwise
454 static int GetCPUCount();
455
456 // Get the platform specific thread ID and return as a long. This
457 // can be used to uniquely identify threads, even if they are not
458 // wxThreads. This is used by wxPython.
459 static wxThreadIdType GetCurrentId();
460
461 // sets the concurrency level: this is, roughly, the number of threads
462 // the system tries to schedule to run in parallel. 0 means the
463 // default value (usually acceptable, but may not yield the best
464 // performance for this process)
465 //
466 // Returns TRUE on success, FALSE otherwise (if not implemented, for
467 // example)
468 static bool SetConcurrency(size_t level);
469
470 // constructor only creates the C++ thread object and doesn't create (or
471 // start) the real thread
472 wxThread(wxThreadKind kind = wxTHREAD_DETACHED);
473
474 // functions that change the thread state: all these can only be called
475 // from _another_ thread (typically the thread that created this one, e.g.
476 // the main thread), not from the thread itself
477
478 // create a new thread and optionally set the stack size on
479 // platforms that support that - call Run() to start it
480 // (special cased for watcom which won't accept 0 default)
481
482 wxThreadError Create(unsigned int stackSize = 0);
483
484 // starts execution of the thread - from the moment Run() is called
485 // the execution of wxThread::Entry() may start at any moment, caller
486 // shouldn't suppose that it starts after (or before) Run() returns.
487 wxThreadError Run();
488
489 // stops the thread if it's running and deletes the wxThread object if
490 // this is a detached thread freeing its memory - otherwise (for
491 // joinable threads) you still need to delete wxThread object
492 // yourself.
493 //
494 // this function only works if the thread calls TestDestroy()
495 // periodically - the thread will only be deleted the next time it
496 // does it!
497 //
498 // will fill the rc pointer with the thread exit code if it's !NULL
499 wxThreadError Delete(ExitCode *rc = (ExitCode *)NULL);
500
501 // waits for a joinable thread to finish and returns its exit code
502 //
503 // Returns (ExitCode)-1 on error (for example, if the thread is not
504 // joinable)
505 ExitCode Wait();
506
507 // kills the thread without giving it any chance to clean up - should
508 // not be used in normal circumstances, use Delete() instead. It is a
509 // dangerous function that should only be used in the most extreme
510 // cases!
511 //
512 // The wxThread object is deleted by Kill() if the thread is
513 // detachable, but you still have to delete it manually for joinable
514 // threads.
515 wxThreadError Kill();
516
517 // pause a running thread: as Delete(), this only works if the thread
518 // calls TestDestroy() regularly
519 wxThreadError Pause();
520
521 // resume a paused thread
522 wxThreadError Resume();
523
524 // priority
525 // Sets the priority to "prio": see WXTHREAD_XXX_PRIORITY constants
526 //
527 // NB: the priority can only be set before the thread is created
528 void SetPriority(unsigned int prio);
529
530 // Get the current priority.
531 unsigned int GetPriority() const;
532
533 // thread status inquiries
534 // Returns true if the thread is alive: i.e. running or suspended
535 bool IsAlive() const;
536 // Returns true if the thread is running (not paused, not killed).
537 bool IsRunning() const;
538 // Returns true if the thread is suspended
539 bool IsPaused() const;
540
541 // is the thread of detached kind?
542 bool IsDetached() const { return m_isDetached; }
543
544 // Get the thread ID - a platform dependent number which uniquely
545 // identifies a thread inside a process
546 wxThreadIdType GetId() const;
547
548 // called when the thread exits - in the context of this thread
549 //
550 // NB: this function will not be called if the thread is Kill()ed
551 virtual void OnExit() { }
552
553 // dtor is public, but the detached threads should never be deleted - use
554 // Delete() instead (or leave the thread terminate by itself)
555 virtual ~wxThread();
556
557 protected:
558 // Returns TRUE if the thread was asked to terminate: this function should
559 // be called by the thread from time to time, otherwise the main thread
560 // will be left forever in Delete()!
561 bool TestDestroy();
562
563 // exits from the current thread - can be called only from this thread
564 void Exit(ExitCode exitcode = 0);
565
566 // entry point for the thread - called by Run() and executes in the context
567 // of this thread.
568 virtual void *Entry() = 0;
569
570 private:
571 // no copy ctor/assignment operator
572 wxThread(const wxThread&);
573 wxThread& operator=(const wxThread&);
574
575 friend class wxThreadInternal;
576
577 // the (platform-dependent) thread class implementation
578 wxThreadInternal *m_internal;
579
580 // protects access to any methods of wxThreadInternal object
581 wxCriticalSection m_critsect;
582
583 // true if the thread is detached, false if it is joinable
584 bool m_isDetached;
585 };
586
587 // wxThreadHelperThread class
588 // --------------------------
589
590 class WXDLLIMPEXP_BASE wxThreadHelperThread : public wxThread
591 {
592 public:
593 // constructor only creates the C++ thread object and doesn't create (or
594 // start) the real thread
595 wxThreadHelperThread(wxThreadHelper& owner)
596 : wxThread(wxTHREAD_JOINABLE), m_owner(owner)
597 { }
598
599 protected:
600 // entry point for the thread -- calls Entry() in owner.
601 virtual void *Entry();
602
603 private:
604 // the owner of the thread
605 wxThreadHelper& m_owner;
606
607 // no copy ctor/assignment operator
608 wxThreadHelperThread(const wxThreadHelperThread&);
609 wxThreadHelperThread& operator=(const wxThreadHelperThread&);
610 };
611
612 // ----------------------------------------------------------------------------
613 // wxThreadHelper: this class implements the threading logic to run a
614 // background task in another object (such as a window). It is a mix-in: just
615 // derive from it to implement a threading background task in your class.
616 // ----------------------------------------------------------------------------
617
618 class WXDLLIMPEXP_BASE wxThreadHelper
619 {
620 private:
621 void KillThread()
622 {
623 if ( m_thread )
624 {
625 m_thread->Kill();
626 delete m_thread;
627 }
628 }
629
630 public:
631 // constructor only initializes m_thread to NULL
632 wxThreadHelper() : m_thread(NULL) { }
633
634 // destructor deletes m_thread
635 virtual ~wxThreadHelper() { KillThread(); }
636
637 // create a new thread (and optionally set the stack size on platforms that
638 // support/need that), call Run() to start it
639 wxThreadError Create(unsigned int stackSize = 0)
640 {
641 KillThread();
642
643 m_thread = new wxThreadHelperThread(*this);
644
645 return m_thread->Create(stackSize);
646 }
647
648 // entry point for the thread - called by Run() and executes in the context
649 // of this thread.
650 virtual void *Entry() = 0;
651
652 // returns a pointer to the thread which can be used to call Run()
653 wxThread *GetThread() const { return m_thread; }
654
655 protected:
656 wxThread *m_thread;
657 };
658
659 // call Entry() in owner, put it down here to avoid circular declarations
660 inline void *wxThreadHelperThread::Entry()
661 {
662 return m_owner.Entry();
663 }
664
665 // ----------------------------------------------------------------------------
666 // Automatic initialization
667 // ----------------------------------------------------------------------------
668
669 // GUI mutex handling.
670 void WXDLLIMPEXP_BASE wxMutexGuiEnter();
671 void WXDLLIMPEXP_BASE wxMutexGuiLeave();
672
673 // macros for entering/leaving critical sections which may be used without
674 // having to take them inside "#if wxUSE_THREADS"
675 #define wxENTER_CRIT_SECT(cs) (cs).Enter()
676 #define wxLEAVE_CRIT_SECT(cs) (cs).Leave()
677 #define wxCRIT_SECT_DECLARE(cs) static wxCriticalSection cs
678 #define wxCRIT_SECT_DECLARE_MEMBER(cs) wxCriticalSection cs
679 #define wxCRIT_SECT_LOCKER(name, cs) wxCriticalSectionLocker name(cs)
680
681 // function for checking if we're in the main thread which may be used whether
682 // wxUSE_THREADS is 0 or 1
683 inline bool wxIsMainThread() { return wxThread::IsMain(); }
684
685 #else // !wxUSE_THREADS
686
687 // no thread support
688 inline void WXDLLIMPEXP_BASE wxMutexGuiEnter() { }
689 inline void WXDLLIMPEXP_BASE wxMutexGuiLeave() { }
690
691 // macros for entering/leaving critical sections which may be used without
692 // having to take them inside "#if wxUSE_THREADS"
693 #define wxENTER_CRIT_SECT(cs)
694 #define wxLEAVE_CRIT_SECT(cs)
695 #define wxCRIT_SECT_DECLARE(cs)
696 #define wxCRIT_SECT_DECLARE_MEMBER(cs)
697 #define wxCRIT_SECT_LOCKER(name, cs)
698
699 // if there is only one thread, it is always the main one
700 inline bool wxIsMainThread() { return true; }
701
702 #endif // wxUSE_THREADS/!wxUSE_THREADS
703
704 // mark part of code as being a critical section: this macro declares a
705 // critical section with the given name and enters it immediately and leaves
706 // it at the end of the current scope
707 //
708 // example:
709 //
710 // int Count()
711 // {
712 // static int s_counter = 0;
713 //
714 // wxCRITICAL_SECTION(counter);
715 //
716 // return ++s_counter;
717 // }
718 //
719 // this function is MT-safe in presence of the threads but there is no
720 // overhead when the library is compiled without threads
721 #define wxCRITICAL_SECTION(name) \
722 wxCRIT_SECT_DECLARE(s_cs##name); \
723 wxCRIT_SECT_LOCKER(cs##name##Locker, s_cs##name)
724
725 // automatically lock GUI mutex in ctor and unlock it in dtor
726 class WXDLLIMPEXP_BASE wxMutexGuiLocker
727 {
728 public:
729 wxMutexGuiLocker() { wxMutexGuiEnter(); }
730 ~wxMutexGuiLocker() { wxMutexGuiLeave(); }
731 };
732
733 // -----------------------------------------------------------------------------
734 // implementation only until the end of file
735 // -----------------------------------------------------------------------------
736
737 #if wxUSE_THREADS
738
739 #if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXPM__) || defined(__EMX__)
740 // unlock GUI if there are threads waiting for and lock it back when
741 // there are no more of them - should be called periodically by the main
742 // thread
743 extern void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter();
744
745 // returns TRUE if the main thread has GUI lock
746 extern bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread();
747
748 #ifndef __WXPM__
749 // wakes up the main thread if it's sleeping inside ::GetMessage()
750 extern void WXDLLIMPEXP_BASE wxWakeUpMainThread();
751 #endif // !OS/2
752
753 // return TRUE if the main thread is waiting for some other to terminate:
754 // wxApp then should block all "dangerous" messages
755 extern bool WXDLLIMPEXP_BASE wxIsWaitingForThread();
756 #endif // MSW, Mac, OS/2
757
758 #endif // wxUSE_THREADS
759
760 #endif // _WX_THREAD_H_
761