]> git.saurik.com Git - wxWidgets.git/blob - src/os2/thread.cpp
Use line width code from GTK+ print in GNOME print
[wxWidgets.git] / src / os2 / thread.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/os2/thread.cpp
3 // Purpose: wxThread Implementation
4 // Author: Original from Wolfram Gloger/Guilhem Lavaux/David Webster
5 // Modified by: Stefan Neis
6 // Created: 04/22/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Neis (2003)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ----------------------------------------------------------------------------
13 // headers
14 // ----------------------------------------------------------------------------
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #if wxUSE_THREADS
20
21 #include "wx/thread.h"
22
23 #ifndef WX_PRECOMP
24 #include "wx/intl.h"
25 #include "wx/log.h"
26 #include "wx/app.h"
27 #include "wx/module.h"
28 #endif //WX_PRECOMP
29
30 #include "wx/apptrait.h"
31 #include "wx/utils.h"
32
33 #include <stdio.h>
34
35 #define INCL_DOSSEMAPHORES
36 #define INCL_DOSPROCESS
37 #define INCL_DOSMISC
38 #define INCL_ERRORS
39 #include <os2.h>
40 #ifndef __EMX__
41 #include <bseerr.h>
42 #endif
43 // the possible states of the thread ("=>" shows all possible transitions from
44 // this state)
45 enum wxThreadState
46 {
47 STATE_NEW, // didn't start execution yet (=> RUNNING)
48 STATE_RUNNING, // thread is running (=> PAUSED, CANCELED)
49 STATE_PAUSED, // thread is temporarily suspended (=> RUNNING)
50 STATE_CANCELED, // thread should terminate a.s.a.p. (=> EXITED)
51 STATE_EXITED // thread is terminating
52 };
53
54 // ----------------------------------------------------------------------------
55 // this module's globals
56 // ----------------------------------------------------------------------------
57
58 // id of the main thread - the one which can call GUI functions without first
59 // calling wxMutexGuiEnter()
60 static ULONG s_ulIdMainThread = 1;
61 wxMutex* p_wxMainMutex;
62
63 // OS2 substitute for Tls pointer the current parent thread object
64 wxThread* m_pThread; // pointer to the wxWidgets thread object
65
66 // if it's false, some secondary thread is holding the GUI lock
67 static bool gs_bGuiOwnedByMainThread = true;
68
69 // critical section which controls access to all GUI functions: any secondary
70 // thread (i.e. except the main one) must enter this crit section before doing
71 // any GUI calls
72 static wxCriticalSection *gs_pCritsectGui = NULL;
73
74 // critical section which protects s_nWaitingForGui variable
75 static wxCriticalSection *gs_pCritsectWaitingForGui = NULL;
76
77 // number of threads waiting for GUI in wxMutexGuiEnter()
78 static size_t gs_nWaitingForGui = 0;
79
80 // are we waiting for a thread termination?
81 static bool gs_bWaitingForThread = false;
82
83 // ============================================================================
84 // OS/2 implementation of thread and related classes
85 // ============================================================================
86
87 // ----------------------------------------------------------------------------
88 // wxMutex implementation
89 // ----------------------------------------------------------------------------
90 class wxMutexInternal
91 {
92 public:
93 wxMutexInternal(wxMutexType mutexType);
94 ~wxMutexInternal();
95
96 bool IsOk() const { return m_vMutex != NULL; }
97
98 wxMutexError Lock() { return LockTimeout(SEM_INDEFINITE_WAIT); }
99 wxMutexError Lock(unsigned long ms) { return LockTimeout(ms); }
100 wxMutexError TryLock();
101 wxMutexError Unlock();
102
103 private:
104 wxMutexError LockTimeout(ULONG ulMilliseconds);
105 HMTX m_vMutex;
106 };
107
108 // all mutexes are "pseudo-"recursive under OS2 so we don't use mutexType
109 // (Calls to DosRequestMutexSem and DosReleaseMutexSem can be nested, but
110 // the request count for a semaphore cannot exceed 65535. If an attempt is
111 // made to exceed this number, ERROR_TOO_MANY_SEM_REQUESTS is returned.)
112 wxMutexInternal::wxMutexInternal(wxMutexType WXUNUSED(eMutexType))
113 {
114 APIRET ulrc = ::DosCreateMutexSem(NULL, &m_vMutex, 0L, FALSE);
115 if (ulrc != 0)
116 {
117 wxLogSysError(_("Can not create mutex."));
118 m_vMutex = NULL;
119 }
120 }
121
122 wxMutexInternal::~wxMutexInternal()
123 {
124 if (m_vMutex)
125 {
126 if (::DosCloseMutexSem(m_vMutex))
127 wxLogLastError(_T("DosCloseMutexSem(mutex)"));
128 }
129 }
130
131 wxMutexError wxMutexInternal::TryLock()
132 {
133 const wxMutexError rc = LockTimeout( SEM_IMMEDIATE_RETURN );
134
135 // we have a special return code for timeout in this case
136 return rc == wxMUTEX_TIMEOUT ? wxMUTEX_BUSY : rc;
137 }
138
139 wxMutexError wxMutexInternal::LockTimeout(ULONG ulMilliseconds)
140 {
141 APIRET ulrc;
142
143 ulrc = ::DosRequestMutexSem(m_vMutex, ulMilliseconds);
144
145 switch (ulrc)
146 {
147 case ERROR_TIMEOUT:
148 return wxMUTEX_TIMEOUT;
149 case ERROR_TOO_MANY_SEM_REQUESTS:
150 return wxMUTEX_BUSY;
151
152 case NO_ERROR:
153 // ok
154 break;
155
156 case ERROR_INVALID_HANDLE:
157 case ERROR_INTERRUPT:
158 case ERROR_SEM_OWNER_DIED:
159 wxLogSysError(_("Couldn't acquire a mutex lock"));
160 return wxMUTEX_MISC_ERROR;
161
162 default:
163 wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
164 return wxMUTEX_MISC_ERROR;
165 }
166 return wxMUTEX_NO_ERROR;
167 }
168
169 wxMutexError wxMutexInternal::Unlock()
170 {
171 APIRET ulrc;
172
173 ulrc = ::DosReleaseMutexSem(m_vMutex);
174 if (ulrc != 0)
175 {
176 wxLogSysError(_("Couldn't release a mutex"));
177 return wxMUTEX_MISC_ERROR;
178 }
179 return wxMUTEX_NO_ERROR;
180 }
181
182 // --------------------------------------------------------------------------
183 // wxSemaphore
184 // --------------------------------------------------------------------------
185
186 // a trivial wrapper around OS2 event semaphore
187 class wxSemaphoreInternal
188 {
189 public:
190 wxSemaphoreInternal(int initialcount, int maxcount);
191 ~wxSemaphoreInternal();
192
193 bool IsOk() const { return m_vEvent != NULL; }
194
195 wxSemaError Wait() { return WaitTimeout(SEM_INDEFINITE_WAIT); }
196 wxSemaError TryWait() { return WaitTimeout(SEM_IMMEDIATE_RETURN); }
197 wxSemaError WaitTimeout(unsigned long milliseconds);
198
199 wxSemaError Post();
200
201 private:
202 HEV m_vEvent;
203 HMTX m_vMutex;
204 int m_count;
205 int m_maxcount;
206 };
207
208 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
209 {
210 APIRET ulrc;
211 if ( maxcount == 0 )
212 {
213 // make it practically infinite
214 maxcount = INT_MAX;
215 }
216
217 m_count = initialcount;
218 m_maxcount = maxcount;
219 ulrc = ::DosCreateMutexSem(NULL, &m_vMutex, 0L, FALSE);
220 if (ulrc != 0)
221 {
222 wxLogLastError(_T("DosCreateMutexSem()"));
223 m_vMutex = NULL;
224 m_vEvent = NULL;
225 return;
226 }
227 ulrc = ::DosCreateEventSem(NULL, &m_vEvent, 0L, FALSE);
228 if ( ulrc != 0)
229 {
230 wxLogLastError(_T("DosCreateEventSem()"));
231 ::DosCloseMutexSem(m_vMutex);
232 m_vMutex = NULL;
233 m_vEvent = NULL;
234 }
235 if (initialcount)
236 ::DosPostEventSem(m_vEvent);
237 }
238
239 wxSemaphoreInternal::~wxSemaphoreInternal()
240 {
241 if ( m_vEvent )
242 {
243 if ( ::DosCloseEventSem(m_vEvent) )
244 {
245 wxLogLastError(_T("DosCloseEventSem(semaphore)"));
246 }
247 if ( ::DosCloseMutexSem(m_vMutex) )
248 {
249 wxLogLastError(_T("DosCloseMutexSem(semaphore)"));
250 }
251 else
252 m_vEvent = NULL;
253 }
254 }
255
256 wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long ulMilliseconds)
257 {
258 APIRET ulrc;
259 do {
260 ulrc = ::DosWaitEventSem(m_vEvent, ulMilliseconds );
261 switch ( ulrc )
262 {
263 case NO_ERROR:
264 break;
265
266 case ERROR_TIMEOUT:
267 if (ulMilliseconds == SEM_IMMEDIATE_RETURN)
268 return wxSEMA_BUSY;
269 else
270 return wxSEMA_TIMEOUT;
271
272 default:
273 wxLogLastError(_T("DosWaitEventSem(semaphore)"));
274 return wxSEMA_MISC_ERROR;
275 }
276 ulrc = :: DosRequestMutexSem(m_vMutex, ulMilliseconds);
277 switch ( ulrc )
278 {
279 case NO_ERROR:
280 // ok
281 break;
282
283 case ERROR_TIMEOUT:
284 case ERROR_TOO_MANY_SEM_REQUESTS:
285 if (ulMilliseconds == SEM_IMMEDIATE_RETURN)
286 return wxSEMA_BUSY;
287 else
288 return wxSEMA_TIMEOUT;
289
290 default:
291 wxFAIL_MSG(wxT("DosRequestMutexSem(mutex)"));
292 return wxSEMA_MISC_ERROR;
293 }
294 bool OK = false;
295 if (m_count > 0)
296 {
297 m_count--;
298 OK = true;
299 }
300 else
301 {
302 ULONG ulPostCount;
303 ::DosResetEventSem(m_vEvent, &ulPostCount);
304 }
305 ::DosReleaseMutexSem(m_vMutex);
306 if (OK)
307 return wxSEMA_NO_ERROR;
308 } while (ulMilliseconds == SEM_INDEFINITE_WAIT);
309
310 if (ulMilliseconds == SEM_IMMEDIATE_RETURN)
311 return wxSEMA_BUSY;
312 return wxSEMA_TIMEOUT;
313 }
314
315 wxSemaError wxSemaphoreInternal::Post()
316 {
317 APIRET ulrc;
318 ulrc = ::DosRequestMutexSem(m_vMutex, SEM_INDEFINITE_WAIT);
319 if (ulrc != NO_ERROR)
320 return wxSEMA_MISC_ERROR;
321 bool OK = false;
322 if (m_count < m_maxcount)
323 {
324 m_count++;
325 ulrc = ::DosPostEventSem(m_vEvent);
326 OK = true;
327 }
328 ::DosReleaseMutexSem(m_vMutex);
329 if (!OK)
330 return wxSEMA_OVERFLOW;
331 if ( ulrc != NO_ERROR && ulrc != ERROR_ALREADY_POSTED )
332 {
333 wxLogLastError(_T("DosPostEventSem(semaphore)"));
334
335 return wxSEMA_MISC_ERROR;
336 }
337
338 return wxSEMA_NO_ERROR;
339 }
340
341 // ----------------------------------------------------------------------------
342 // wxThread implementation
343 // ----------------------------------------------------------------------------
344
345 // wxThreadInternal class
346 // ----------------------
347
348 class wxThreadInternal
349 {
350 public:
351 inline wxThreadInternal()
352 {
353 m_hThread = 0;
354 m_eState = STATE_NEW;
355 m_nPriority = WXTHREAD_DEFAULT_PRIORITY;
356 }
357
358 ~wxThreadInternal()
359 {
360 m_hThread = 0;
361 }
362
363 // create a new (suspended) thread (for the given thread object)
364 bool Create( wxThread* pThread
365 ,unsigned int uStackSize
366 );
367
368 // suspend/resume/terminate
369 bool Suspend();
370 bool Resume();
371 inline void Cancel() { m_eState = STATE_CANCELED; }
372
373 // thread state
374 inline void SetState(wxThreadState eState) { m_eState = eState; }
375 inline wxThreadState GetState() const { return m_eState; }
376
377 // thread priority
378 void SetPriority(unsigned int nPriority);
379 inline unsigned int GetPriority() const { return m_nPriority; }
380
381 // thread handle and id
382 inline TID GetHandle() const { return m_hThread; }
383 TID GetId() const { return m_hThread; }
384
385 // thread function
386 static void OS2ThreadStart(void* pParam);
387
388 private:
389 // Threads in OS/2 have only an ID, so m_hThread is both it's handle and ID
390 // PM also has no real Tls mechanism to index pointers by so we'll just
391 // keep track of the wxWidgets parent object here.
392 TID m_hThread; // handle and ID of the thread
393 wxThreadState m_eState; // state, see wxThreadState enum
394 unsigned int m_nPriority; // thread priority in "wx" units
395 };
396
397 void wxThreadInternal::OS2ThreadStart( void * pParam )
398 {
399 DWORD dwRet;
400 bool bWasCancelled;
401
402 wxThread *pThread = (wxThread *)pParam;
403
404 // first of all, wait for the thread to be started.
405 pThread->m_critsect.Enter();
406 pThread->m_critsect.Leave();
407 // Now check whether we hadn't been cancelled already and don't
408 // start the user code at all in this case.
409 if ( pThread->m_internal->GetState() == STATE_EXITED )
410 {
411 dwRet = (DWORD)-1;
412 bWasCancelled = true;
413 }
414 else // do run thread
415 {
416 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
417 unsigned long ulHab;
418 if (traits)
419 traits->InitializeGui(ulHab);
420 dwRet = (DWORD)pThread->Entry();
421 if (traits)
422 traits->TerminateGui(ulHab);
423
424 // enter m_critsect before changing the thread state
425 pThread->m_critsect.Enter();
426
427 bWasCancelled = pThread->m_internal->GetState() == STATE_CANCELED;
428
429 pThread->m_internal->SetState(STATE_EXITED);
430 pThread->m_critsect.Leave();
431 }
432 pThread->OnExit();
433
434 // if the thread was cancelled (from Delete()), then it the handle is still
435 // needed there
436 if (pThread->IsDetached() && !bWasCancelled)
437 {
438 // auto delete
439 delete pThread;
440 }
441 //else: the joinable threads handle will be closed when Wait() is done
442 return;
443 }
444
445 void wxThreadInternal::SetPriority(
446 unsigned int nPriority
447 )
448 {
449 // translate wxWidgets priority to the PM one
450 ULONG ulOS2_PriorityClass;
451 ULONG ulOS2_SubPriority;
452 ULONG ulrc;
453
454 m_nPriority = nPriority;
455 if (m_nPriority <= 25)
456 ulOS2_PriorityClass = PRTYC_IDLETIME;
457 else if (m_nPriority <= 50)
458 ulOS2_PriorityClass = PRTYC_REGULAR;
459 else if (m_nPriority <= 75)
460 ulOS2_PriorityClass = PRTYC_TIMECRITICAL;
461 else if (m_nPriority <= 100)
462 ulOS2_PriorityClass = PRTYC_FOREGROUNDSERVER;
463 else
464 {
465 wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
466 ulOS2_PriorityClass = PRTYC_REGULAR;
467 }
468 ulOS2_SubPriority = (ULONG) (((m_nPriority - 1) % 25 + 1) * 31.0 / 25);
469 ulrc = ::DosSetPriority( PRTYS_THREAD
470 ,ulOS2_PriorityClass
471 ,ulOS2_SubPriority
472 ,(ULONG)m_hThread
473 );
474 if (ulrc != 0)
475 {
476 wxLogSysError(_("Can't set thread priority"));
477 }
478 }
479
480 bool wxThreadInternal::Create( wxThread* pThread,
481 unsigned int uStackSize)
482 {
483 int tid;
484
485 if (!uStackSize)
486 uStackSize = 131072;
487
488 pThread->m_critsect.Enter();
489 tid = _beginthread(wxThreadInternal::OS2ThreadStart,
490 NULL, uStackSize, pThread);
491 if(tid == -1)
492 {
493 wxLogSysError(_("Can't create thread"));
494
495 return false;
496 }
497 m_hThread = tid;
498 if (m_nPriority != WXTHREAD_DEFAULT_PRIORITY)
499 {
500 SetPriority(m_nPriority);
501 }
502
503 return true;
504 }
505
506 bool wxThreadInternal::Suspend()
507 {
508 ULONG ulrc = ::DosSuspendThread(m_hThread);
509
510 if (ulrc != 0)
511 {
512 wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
513 return false;
514 }
515 m_eState = STATE_PAUSED;
516
517 return true;
518 }
519
520 bool wxThreadInternal::Resume()
521 {
522 ULONG ulrc = ::DosResumeThread(m_hThread);
523
524 if (ulrc != 0)
525 {
526 wxLogSysError(_("Can not resume thread %lu"), m_hThread);
527 return false;
528 }
529
530 // don't change the state from STATE_EXITED because it's special and means
531 // we are going to terminate without running any user code - if we did it,
532 // the codei n Delete() wouldn't work
533 if ( m_eState != STATE_EXITED )
534 {
535 m_eState = STATE_RUNNING;
536 }
537
538 return true;
539 }
540
541 // static functions
542 // ----------------
543
544 wxThread *wxThread::This()
545 {
546 wxThread* pThread = m_pThread;
547 return pThread;
548 }
549
550 bool wxThread::IsMain()
551 {
552 PTIB ptib;
553 PPIB ppib;
554
555 ::DosGetInfoBlocks(&ptib, &ppib);
556
557 if (ptib->tib_ptib2->tib2_ultid == s_ulIdMainThread)
558 return true;
559
560 return false;
561 }
562
563 #ifdef Yield
564 #undef Yield
565 #endif
566
567 void wxThread::Yield()
568 {
569 ::DosSleep(0);
570 }
571
572 void wxThread::Sleep(
573 unsigned long ulMilliseconds
574 )
575 {
576 ::DosSleep(ulMilliseconds);
577 }
578
579 int wxThread::GetCPUCount()
580 {
581 ULONG CPUCount;
582 APIRET ulrc;
583 ulrc = ::DosQuerySysInfo(26, 26, (void *)&CPUCount, sizeof(ULONG));
584 // QSV_NUMPROCESSORS(26) is typically not defined in header files
585
586 if (ulrc != 0)
587 CPUCount = 1;
588
589 return CPUCount;
590 }
591
592 unsigned long wxThread::GetCurrentId()
593 {
594 PTIB ptib;
595 PPIB ppib;
596
597 ::DosGetInfoBlocks(&ptib, &ppib);
598 return (unsigned long) ptib->tib_ptib2->tib2_ultid;
599 }
600
601 bool wxThread::SetConcurrency(size_t level)
602 {
603 wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
604
605 // ok only for the default one
606 if ( level == 0 )
607 return 0;
608
609 // Don't know how to realize this on OS/2.
610 return level == 1;
611 }
612
613 // ctor and dtor
614 // -------------
615
616 wxThread::wxThread(wxThreadKind kind)
617 {
618 m_internal = new wxThreadInternal();
619
620 m_isDetached = kind == wxTHREAD_DETACHED;
621 }
622
623 wxThread::~wxThread()
624 {
625 delete m_internal;
626 }
627
628 // create/start thread
629 // -------------------
630
631 wxThreadError wxThread::Create(
632 unsigned int uStackSize
633 )
634 {
635 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
636
637 if ( !m_internal->Create(this, uStackSize) )
638 return wxTHREAD_NO_RESOURCE;
639
640 return wxTHREAD_NO_ERROR;
641 }
642
643 wxThreadError wxThread::Run()
644 {
645 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
646
647 if ( m_internal->GetState() != STATE_NEW )
648 {
649 // actually, it may be almost any state at all, not only STATE_RUNNING
650 return wxTHREAD_RUNNING;
651 }
652 return Resume();
653 }
654
655 // suspend/resume thread
656 // ---------------------
657
658 wxThreadError wxThread::Pause()
659 {
660 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
661
662 return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
663 }
664
665 wxThreadError wxThread::Resume()
666 {
667 if (m_internal->GetState() == STATE_NEW)
668 {
669 m_internal->SetState(STATE_RUNNING);
670 m_critsect.Leave();
671 return wxTHREAD_NO_ERROR;
672 }
673
674 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
675
676 return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
677 }
678
679 // stopping thread
680 // ---------------
681
682 wxThread::ExitCode wxThread::Wait()
683 {
684 // although under Windows we can wait for any thread, it's an error to
685 // wait for a detached one in wxWin API
686 wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
687 _T("can't wait for detached thread") );
688 ExitCode rc = (ExitCode)-1;
689 (void)Delete(&rc);
690 return(rc);
691 }
692
693 wxThreadError wxThread::Delete(ExitCode *pRc)
694 {
695 ExitCode rc = 0;
696
697 // Delete() is always safe to call, so consider all possible states
698
699 // we might need to resume the thread, but we might also not need to cancel
700 // it if it doesn't run yet
701 bool shouldResume = false,
702 shouldCancel = true,
703 isRunning = false;
704
705 // check if the thread already started to run
706 {
707 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
708
709 if ( m_internal->GetState() == STATE_NEW )
710 {
711 // WinThreadStart() will see it and terminate immediately, no need
712 // to cancel the thread - but we still need to resume it to let it
713 // run
714 m_internal->SetState(STATE_EXITED);
715
716 Resume(); // it knows about STATE_EXITED special case
717
718 shouldCancel = false;
719 isRunning = true;
720
721 // shouldResume is correctly set to false here
722 }
723 else
724 {
725 shouldResume = IsPaused();
726 }
727 }
728
729 // resume the thread if it is paused
730 if ( shouldResume )
731 Resume();
732
733 TID hThread = m_internal->GetHandle();
734
735 if ( isRunning || IsRunning())
736 {
737 if (IsMain())
738 {
739 // set flag for wxIsWaitingForThread()
740 gs_bWaitingForThread = true;
741 }
742
743 // ask the thread to terminate
744 if ( shouldCancel )
745 {
746 wxCriticalSectionLocker lock(m_critsect);
747
748 m_internal->Cancel();
749 }
750
751 #if 0
752 // we can't just wait for the thread to terminate because it might be
753 // calling some GUI functions and so it will never terminate before we
754 // process the Windows messages that result from these functions
755 DWORD result = 0; // suppress warnings from broken compilers
756 do
757 {
758 if ( IsMain() )
759 {
760 // give the thread we're waiting for chance to do the GUI call
761 // it might be in
762 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
763 {
764 wxMutexGuiLeave();
765 }
766 }
767
768 result = ::DosWaitThread(&hThread, DCWW_NOWAIT);
769 // FIXME: We ought to have a message processing loop here!!
770
771 switch ( result )
772 {
773 case ERROR_INTERRUPT:
774 case ERROR_THREAD_NOT_TERMINATED:
775 break;
776 case ERROR_INVALID_THREADID:
777 case NO_ERROR:
778 // thread we're waiting for just terminated
779 // or even does not exist any more.
780 result = NO_ERROR;
781 break;
782 default:
783 wxFAIL_MSG(wxT("unexpected result of DosWaitThread"));
784 }
785 if ( IsMain() )
786 {
787 // event processing - needed if we are the main thread
788 // to give other threads a chance to do remaining GUI
789 // processing and terminate cleanly.
790 wxTheApp->HandleSockets();
791 if (wxTheApp->Pending())
792 if ( !wxTheApp->DoMessage() )
793 {
794 // WM_QUIT received: kill the thread
795 Kill();
796
797 return wxTHREAD_KILLED;
798 }
799 else
800 wxUsleep(10);
801 }
802 else
803 wxUsleep(10);
804 } while ( result != NO_ERROR );
805 #else // !wxUSE_GUI
806 // simply wait for the thread to terminate
807 //
808 // OTOH, even console apps create windows (in wxExecute, for WinSock
809 // &c), so may be use MsgWaitForMultipleObject() too here?
810 if ( ::DosWaitThread(&hThread, DCWW_WAIT) != NO_ERROR )
811 {
812 wxFAIL_MSG(wxT("unexpected result of DosWaitThread"));
813 }
814 #endif // wxUSE_GUI/!wxUSE_GUI
815
816 if ( IsMain() )
817 {
818 gs_bWaitingForThread = false;
819 }
820 }
821
822 #if 0
823 // although the thread might be already in the EXITED state it might not
824 // have terminated yet and so we are not sure that it has actually
825 // terminated if the "if" above hadn't been taken
826 do
827 {
828 if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
829 {
830 wxLogLastError(wxT("GetExitCodeThread"));
831
832 rc = (ExitCode)-1;
833 }
834 } while ( (DWORD)rc == STILL_ACTIVE );
835 #endif
836
837 if ( IsDetached() )
838 {
839 // if the thread exits normally, this is done in WinThreadStart, but in
840 // this case it would have been too early because
841 // MsgWaitForMultipleObject() would fail if the thread handle was
842 // closed while we were waiting on it, so we must do it here
843 delete this;
844 }
845
846 if ( pRc )
847 *pRc = rc;
848
849 return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
850 }
851
852 wxThreadError wxThread::Kill()
853 {
854 if (!IsRunning())
855 return wxTHREAD_NOT_RUNNING;
856
857 ::DosKillThread(m_internal->GetHandle());
858 if (IsDetached())
859 {
860 delete this;
861 }
862 return wxTHREAD_NO_ERROR;
863 }
864
865 void wxThread::Exit(ExitCode WXUNUSED(pStatus))
866 {
867 delete this;
868 _endthread();
869 wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
870 }
871
872 void wxThread::SetPriority(
873 unsigned int nPrio
874 )
875 {
876 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
877
878 m_internal->SetPriority(nPrio);
879 }
880
881 unsigned int wxThread::GetPriority() const
882 {
883 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
884
885 return m_internal->GetPriority();
886 }
887
888 unsigned long wxThread::GetId() const
889 {
890 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
891
892 return (unsigned long)m_internal->GetId();
893 }
894
895 bool wxThread::IsRunning() const
896 {
897 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
898
899 return(m_internal->GetState() == STATE_RUNNING);
900 }
901
902 bool wxThread::IsAlive() const
903 {
904 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
905
906 return (m_internal->GetState() == STATE_RUNNING) ||
907 (m_internal->GetState() == STATE_PAUSED);
908 }
909
910 bool wxThread::IsPaused() const
911 {
912 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
913
914 return (m_internal->GetState() == STATE_PAUSED);
915 }
916
917 bool wxThread::TestDestroy()
918 {
919 wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
920
921 return m_internal->GetState() == STATE_CANCELED;
922 }
923
924 // ----------------------------------------------------------------------------
925 // Automatic initialization for thread module
926 // ----------------------------------------------------------------------------
927
928 class wxThreadModule : public wxModule
929 {
930 public:
931 virtual bool OnInit();
932 virtual void OnExit();
933
934 private:
935 DECLARE_DYNAMIC_CLASS(wxThreadModule)
936 };
937
938 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
939
940 bool wxThreadModule::OnInit()
941 {
942 gs_pCritsectWaitingForGui = new wxCriticalSection();
943
944 gs_pCritsectGui = new wxCriticalSection();
945 gs_pCritsectGui->Enter();
946
947 PTIB ptib;
948 PPIB ppib;
949
950 ::DosGetInfoBlocks(&ptib, &ppib);
951
952 s_ulIdMainThread = ptib->tib_ptib2->tib2_ultid;
953 return true;
954 }
955
956 void wxThreadModule::OnExit()
957 {
958 if (gs_pCritsectGui)
959 {
960 gs_pCritsectGui->Leave();
961 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
962 delete gs_pCritsectGui;
963 #endif
964 gs_pCritsectGui = NULL;
965 }
966
967 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
968 wxDELETE(gs_pCritsectWaitingForGui);
969 #endif
970 }
971
972 // ----------------------------------------------------------------------------
973 // Helper functions
974 // ----------------------------------------------------------------------------
975
976 // wake up the main thread if it's in ::GetMessage()
977 void WXDLLEXPORT wxWakeUpMainThread()
978 {
979 #if 0
980 if ( !::WinPostQueueMsg(wxTheApp->m_hMq, WM_NULL, 0, 0) )
981 {
982 // should never happen
983 wxLogLastError(wxT("WinPostMessage(WM_NULL)"));
984 }
985 #endif
986 }
987
988 void WXDLLEXPORT wxMutexGuiEnter()
989 {
990 // this would dead lock everything...
991 wxASSERT_MSG( !wxThread::IsMain(),
992 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
993
994 // the order in which we enter the critical sections here is crucial!!
995
996 // set the flag telling to the main thread that we want to do some GUI
997 {
998 wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
999
1000 gs_nWaitingForGui++;
1001 }
1002
1003 wxWakeUpMainThread();
1004
1005 // now we may block here because the main thread will soon let us in
1006 // (during the next iteration of OnIdle())
1007 gs_pCritsectGui->Enter();
1008 }
1009
1010 void WXDLLEXPORT wxMutexGuiLeave()
1011 {
1012 wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
1013
1014 if ( wxThread::IsMain() )
1015 {
1016 gs_bGuiOwnedByMainThread = false;
1017 }
1018 else
1019 {
1020 // decrement the number of waiters now
1021 wxASSERT_MSG(gs_nWaitingForGui > 0,
1022 wxT("calling wxMutexGuiLeave() without entering it first?") );
1023
1024 gs_nWaitingForGui--;
1025
1026 wxWakeUpMainThread();
1027 }
1028
1029 gs_pCritsectGui->Leave();
1030 }
1031
1032 void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
1033 {
1034 wxASSERT_MSG( wxThread::IsMain(),
1035 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1036
1037 wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
1038
1039 if (gs_nWaitingForGui == 0)
1040 {
1041 // no threads are waiting for GUI - so we may acquire the lock without
1042 // any danger (but only if we don't already have it)
1043 if (!wxGuiOwnedByMainThread())
1044 {
1045 gs_pCritsectGui->Enter();
1046
1047 gs_bGuiOwnedByMainThread = true;
1048 }
1049 //else: already have it, nothing to do
1050 }
1051 else
1052 {
1053 // some threads are waiting, release the GUI lock if we have it
1054 if (wxGuiOwnedByMainThread())
1055 {
1056 wxMutexGuiLeave();
1057 }
1058 //else: some other worker thread is doing GUI
1059 }
1060 }
1061
1062 bool WXDLLEXPORT wxGuiOwnedByMainThread()
1063 {
1064 return gs_bGuiOwnedByMainThread;
1065 }
1066
1067 bool WXDLLEXPORT wxIsWaitingForThread()
1068 {
1069 return gs_bWaitingForThread;
1070 }
1071
1072 // ----------------------------------------------------------------------------
1073 // include common implementation code
1074 // ----------------------------------------------------------------------------
1075
1076 #include "wx/thrimpl.cpp"
1077
1078 #endif
1079 // wxUSE_THREADS