src/os2/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        thread.cpp
   3 // Purpose:     wxThread Implementation. For Unix ports, see e.g. src/gtk
   4 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
   5 // Modified by: David Webster
   6 // Created:     04/22/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
   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 <stdio.h>
  22
  23 #include "wx/module.h"
  24 #include "wx/intl.h"
  25 #include "wx/utils.h"
  26 #include "wx/log.h"
  27 #include "wx/thread.h"
  28
  29 #define INCL_DOSSEMAPHORES
  30 #define INCL_DOSPROCESS
  31 #define INCL_ERRORS
  32 #include <os2.h>
  33 #include <bseerr.h>
  34
  35 // the possible states of the thread ("=>" shows all possible transitions from
  36 // this state)
  37 enum wxThreadState
  38 {
  39     STATE_NEW,          // didn't start execution yet (=> RUNNING)
  40     STATE_RUNNING,      // thread is running (=> PAUSED, CANCELED)
  41     STATE_PAUSED,       // thread is temporarily suspended (=> RUNNING)
  42     STATE_CANCELED,     // thread should terminate a.s.a.p. (=> EXITED)
  43     STATE_EXITED        // thread is terminating
  44 };
  45
  46 // ----------------------------------------------------------------------------
  47 // static variables
  48 // ----------------------------------------------------------------------------
  49
  50 // id of the main thread - the one which can call GUI functions without first
  51 // calling wxMutexGuiEnter()
  52 static ULONG                        s_ulIdMainThread = 0;
  53 wxMutex*                            p_wxMainMutex;
  54
  55 // OS2 substitute for Tls pointer the current parent thread object
  56 wxThread*                           m_pThread;    // pointer to the wxWindows thread object
  57
  58 // if it's FALSE, some secondary thread is holding the GUI lock
  59 static bool gs_bGuiOwnedByMainThread = TRUE;
  60
  61 // critical section which controls access to all GUI functions: any secondary
  62 // thread (i.e. except the main one) must enter this crit section before doing
  63 // any GUI calls
  64 static wxCriticalSection *gs_pCritsectGui = NULL;
  65
  66 // critical section which protects s_nWaitingForGui variable
  67 static wxCriticalSection *gs_pCritsectWaitingForGui = NULL;
  68
  69 // number of threads waiting for GUI in wxMutexGuiEnter()
  70 static size_t gs_nWaitingForGui = 0;
  71
  72 // are we waiting for a thread termination?
  73 static bool gs_bWaitingForThread = FALSE;
  74
  75 // ============================================================================
  76 // OS/2 implementation of thread classes
  77 // ============================================================================
  78
  79 // ----------------------------------------------------------------------------
  80 // wxMutex implementation
  81 // ----------------------------------------------------------------------------
  82 class wxMutexInternal
  83 {
  84 public:
  85     HMTX                            m_vMutex;
  86 };
  87
  88 wxMutex::wxMutex()
  89 {
  90     APIRET                          ulrc;
  91
  92     m_internal = new wxMutexInternal;
  93     ulrc = ::DosCreateMutexSem(NULL, &m_internal->m_vMutex, 0L, FALSE);
  94     if (ulrc != 0)
  95     {
  96         wxLogSysError(_("Can not create mutex."));
  97     }
  98     m_locked = 0;
  99 }
 100
 101 wxMutex::~wxMutex()
 102 {
 103     if (m_locked > 0)
 104         wxLogDebug(wxT("Warning: freeing a locked mutex (%d locks)."), m_locked);
 105     ::DosCloseMutexSem(m_internal->m_vMutex);
 106     m_internal->m_vMutex = NULL;
 107 }
 108
 109 wxMutexError wxMutex::Lock()
 110 {
 111     APIRET                          ulrc;
 112
 113     ulrc = ::DosRequestMutexSem(m_internal->m_vMutex, SEM_INDEFINITE_WAIT);
 114
 115     switch (ulrc)
 116     {
 117         case ERROR_TOO_MANY_SEM_REQUESTS:
 118             return wxMUTEX_BUSY;
 119
 120         case NO_ERROR:
 121             // ok
 122             break;
 123
 124         case ERROR_INVALID_HANDLE:
 125         case ERROR_INTERRUPT:
 126         case ERROR_SEM_OWNER_DIED:
 127             wxLogSysError(_("Couldn't acquire a mutex lock"));
 128             return wxMUTEX_MISC_ERROR;
 129
 130         case ERROR_TIMEOUT:
 131         default:
 132             wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
 133     }
 134     m_locked++;
 135     return wxMUTEX_NO_ERROR;
 136 }
 137
 138 wxMutexError wxMutex::TryLock()
 139 {
 140     ULONG                           ulrc;
 141
 142     ulrc = ::DosRequestMutexSem(m_internal->m_vMutex, SEM_IMMEDIATE_RETURN /*0L*/);
 143     if (ulrc == ERROR_TIMEOUT || ulrc == ERROR_TOO_MANY_SEM_REQUESTS)
 144         return wxMUTEX_BUSY;
 145
 146     m_locked++;
 147     return wxMUTEX_NO_ERROR;
 148 }
 149
 150 wxMutexError wxMutex::Unlock()
 151 {
 152     APIRET                          ulrc;
 153
 154     if (m_locked > 0)
 155         m_locked--;
 156
 157     ulrc = ::DosReleaseMutexSem(m_internal->m_vMutex);
 158     if (ulrc != 0)
 159     {
 160         wxLogSysError(_("Couldn't release a mutex"));
 161         return wxMUTEX_MISC_ERROR;
 162     }
 163     return wxMUTEX_NO_ERROR;
 164 }
 165
 166 // ----------------------------------------------------------------------------
 167 // wxCondition implementation
 168 // ----------------------------------------------------------------------------
 169
 170 class wxConditionInternal
 171 {
 172 public:
 173     inline wxConditionInternal ()
 174     {
 175         ::DosCreateEventSem(NULL, &m_vEvent, DC_SEM_SHARED, FALSE);
 176         if (!m_vEvent)
 177         {
 178             wxLogSysError(_("Can not create event semaphore."));
 179         }
 180         m_nWaiters = 0;
 181     }
 182
 183     inline bool Wait(
 184       unsigned long                 ulTimeout
 185     )
 186     {
 187         APIRET                      ulrc;
 188
 189         m_nWaiters++;
 190         ulrc = ::DosWaitEventSem(m_vEvent, ulTimeout);
 191         m_nWaiters--;
 192         return (ulrc != ERROR_TIMEOUT);
 193     }
 194
 195     inline ~wxConditionInternal ()
 196     {
 197         APIRET                      ulrc;
 198
 199         if (m_vEvent)
 200         {
 201             ulrc = ::DosCloseEventSem(m_vEvent);
 202             if (!ulrc)
 203             {
 204                 wxLogLastError("DosCloseEventSem(m_vEvent)");
 205             }
 206         }
 207     }
 208
 209     HEV                             m_vEvent;
 210     int                             m_nWaiters;
 211 };
 212
 213 wxCondition::wxCondition()
 214 {
 215     APIRET                          ulrc;
 216     ULONG                           ulCount;
 217
 218     m_internal = new wxConditionInternal;
 219     ulrc = ::DosCreateEventSem(NULL, &m_internal->m_vEvent, 0L, FALSE);
 220     if (ulrc != 0)
 221     {
 222         wxLogSysError(_("Can not create event object."));
 223     }
 224     m_internal->m_nWaiters = 0;
 225     // ?? just for good measure?
 226     ::DosResetEventSem(m_internal->m_vEvent, &ulCount);
 227 }
 228
 229 wxCondition::~wxCondition()
 230 {
 231     ::DosCloseEventSem(m_internal->m_vEvent);
 232     delete m_internal;
 233     m_internal = NULL;
 234 }
 235
 236 void wxCondition::Wait()
 237 {
 238     (void)m_internal->Wait(SEM_INDEFINITE_WAIT);
 239 }
 240
 241 bool wxCondition::Wait(
 242   unsigned long                     lSec
 243 , unsigned long                     lNsec)
 244 {
 245     return m_internal->Wait(lSec*1000 + lNsec/1000000);
 246 }
 247
 248 void wxCondition::Signal()
 249 {
 250     ::DosPostEventSem(m_internal->m_vEvent);
 251 }
 252
 253 void wxCondition::Broadcast()
 254 {
 255     int                             i;
 256
 257     for (i = 0; i < m_internal->m_nWaiters; i++)
 258     {
 259         if (::DosPostEventSem(m_internal->m_vEvent) != 0)
 260         {
 261             wxLogSysError(_("Couldn't change the state of event object."));
 262         }
 263     }
 264 }
 265
 266 // ----------------------------------------------------------------------------
 267 // wxCriticalSection implementation
 268 // ----------------------------------------------------------------------------
 269
 270 wxCriticalSection::wxCriticalSection()
 271 {
 272 }
 273
 274 wxCriticalSection::~wxCriticalSection()
 275 {
 276 }
 277
 278 void wxCriticalSection::Enter()
 279 {
 280     ::DosEnterCritSec();
 281 }
 282
 283 void wxCriticalSection::Leave()
 284 {
 285     ::DosExitCritSec();
 286 }
 287
 288 // ----------------------------------------------------------------------------
 289 // wxThread implementation
 290 // ----------------------------------------------------------------------------
 291
 292 // wxThreadInternal class
 293 // ----------------------
 294
 295 class wxThreadInternal
 296 {
 297 public:
 298     inline wxThreadInternal()
 299     {
 300         m_hThread = 0;
 301         m_eState = STATE_NEW;
 302         m_nPriority = 0;
 303     }
 304
 305     ~wxThreadInternal()
 306     {
 307         Free();
 308     }
 309
 310     void Free()
 311     {
 312         if (m_hThread)
 313         {
 314             ::DosExit(0,0);
 315             m_hThread = 0;
 316         }
 317     }
 318
 319     // create a new (suspended) thread (for the given thread object)
 320     bool Create( wxThread*    pThread
 321                 ,unsigned int uStackSize
 322                );
 323
 324     // suspend/resume/terminate
 325     bool Suspend();
 326     bool Resume();
 327     inline void Cancel() { m_eState = STATE_CANCELED; }
 328
 329     // thread state
 330     inline void SetState(wxThreadState eState) { m_eState = eState; }
 331     inline wxThreadState GetState() const { return m_eState; }
 332
 333     // thread priority
 334     void                SetPriority(unsigned int nPriority);
 335     inline unsigned int GetPriority() const { return m_nPriority; }
 336
 337     // thread handle and id
 338     inline TID GetHandle() const { return m_hThread; }
 339     TID  GetId() const { return m_hThread; }
 340
 341     // thread function
 342     static DWORD OS2ThreadStart(wxThread *thread);
 343
 344 private:
 345     // Threads in OS/2 have only an ID, so m_hThread is both it's handle and ID
 346     // PM also has no real Tls mechanism to index pointers by so we'll just
 347     // keep track of the wxWindows parent object here.
 348     TID                             m_hThread;    // handle and ID of the thread
 349     wxThreadState                   m_eState;     // state, see wxThreadState enum
 350     unsigned int                    m_nPriority;  // thread priority in "wx" units
 351 };
 352
 353 ULONG wxThreadInternal::OS2ThreadStart(
 354   wxThread*                         pThread
 355 )
 356 {
 357     m_pThread = pThread;
 358
 359     DWORD                           dwRet = (DWORD)pThread->Entry();
 360
 361     // enter m_critsect before changing the thread state
 362     pThread->m_critsect.Enter();
 363
 364     bool                            bWasCancelled = pThread->m_internal->GetState() == STATE_CANCELED;
 365
 366     pThread->m_internal->SetState(STATE_EXITED);
 367     pThread->m_critsect.Leave();
 368
 369     pThread->OnExit();
 370
 371     // if the thread was cancelled (from Delete()), then it the handle is still
 372     // needed there
 373     if (pThread->IsDetached() && !bWasCancelled)
 374     {
 375         // auto delete
 376         delete pThread;
 377     }
 378     //else: the joinable threads handle will be closed when Wait() is done
 379     return dwRet;
 380 }
 381
 382 void wxThreadInternal::SetPriority(
 383   unsigned int                      nPriority
 384 )
 385 {
 386     // translate wxWindows priority to the PM one
 387     ULONG                           ulOS2_Priority;
 388     ULONG                           ulrc;
 389
 390     m_nPriority = nPriority;
 391
 392     if (m_nPriority <= 20)
 393         ulOS2_Priority = PRTYC_NOCHANGE;
 394     else if (m_nPriority <= 40)
 395         ulOS2_Priority = PRTYC_IDLETIME;
 396     else if (m_nPriority <= 60)
 397         ulOS2_Priority = PRTYC_REGULAR;
 398     else if (m_nPriority <= 80)
 399         ulOS2_Priority = PRTYC_TIMECRITICAL;
 400     else if (m_nPriority <= 100)
 401         ulOS2_Priority = PRTYC_FOREGROUNDSERVER;
 402     else
 403     {
 404         wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
 405         ulOS2_Priority = PRTYC_REGULAR;
 406     }
 407     ulrc = ::DosSetPriority( PRTYS_THREAD
 408                             ,ulOS2_Priority
 409                             ,0
 410                             ,(ULONG)m_hThread
 411                            );
 412     if (ulrc != 0)
 413     {
 414         wxLogSysError(_("Can't set thread priority"));
 415     }
 416 }
 417
 418 bool wxThreadInternal::Create(
 419   wxThread*                         pThread
 420 , unsigned int                      uStackSize
 421 )
 422 {
 423     APIRET                          ulrc;
 424
 425     ulrc = ::DosCreateThread( &m_hThread
 426                              ,(PFNTHREAD)wxThreadInternal::OS2ThreadStart
 427                              ,(ULONG)pThread
 428                              ,CREATE_SUSPENDED | STACK_SPARSE
 429                              ,(ULONG)uStackSize
 430                             );
 431     if(ulrc != 0)
 432     {
 433         wxLogSysError(_("Can't create thread"));
 434
 435         return FALSE;
 436     }
 437     if (m_nPriority != WXTHREAD_DEFAULT_PRIORITY)
 438     {
 439         SetPriority(m_nPriority);
 440     }
 441     return(TRUE);
 442 }
 443
 444 bool wxThreadInternal::Suspend()
 445 {
 446     ULONG                           ulrc = ::DosSuspendThread(m_hThread);
 447
 448     if (ulrc != 0)
 449     {
 450         wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
 451         return FALSE;
 452     }
 453     m_eState = STATE_PAUSED;
 454     return TRUE;
 455 }
 456
 457 bool wxThreadInternal::Resume()
 458 {
 459     ULONG                           ulrc = ::DosResumeThread(m_hThread);
 460
 461     if (ulrc != 0)
 462     {
 463         wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
 464         return FALSE;
 465     }
 466     m_eState = STATE_PAUSED;
 467     return TRUE;
 468 }
 469
 470 // static functions
 471 // ----------------
 472
 473 wxThread *wxThread::This()
 474 {
 475     wxThread*                       pThread = m_pThread;
 476     return pThread;
 477 }
 478
 479 bool wxThread::IsMain()
 480 {
 481     PTIB                            ptib;
 482     PPIB                            ppib;
 483
 484     ::DosGetInfoBlocks(&ptib, &ppib);
 485
 486     if (ptib->tib_ptib2->tib2_ultid == s_ulIdMainThread)
 487         return TRUE;
 488     return FALSE;
 489 }
 490
 491 #ifdef Yield
 492     #undef Yield
 493 #endif
 494
 495 void wxThread::Yield()
 496 {
 497     ::DosSleep(0);
 498 }
 499
 500 void wxThread::Sleep(
 501   unsigned long                     ulMilliseconds
 502 )
 503 {
 504     ::DosSleep(ulMilliseconds);
 505 }
 506
 507 // ctor and dtor
 508 // -------------
 509
 510 wxThread::wxThread(wxThreadKind kind)
 511 {
 512     m_internal = new wxThreadInternal();
 513
 514     m_isDetached = kind == wxTHREAD_DETACHED;
 515 }
 516
 517 wxThread::~wxThread()
 518 {
 519     delete m_internal;
 520 }
 521
 522 // create/start thread
 523 // -------------------
 524
 525 wxThreadError wxThread::Create(
 526   unsigned int                      uStackSize
 527 )
 528 {
 529     if ( !m_internal->Create(this, uStackSize) )
 530         return wxTHREAD_NO_RESOURCE;
 531
 532     return wxTHREAD_NO_ERROR;
 533 }
 534
 535 wxThreadError wxThread::Run()
 536 {
 537     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 538
 539     if ( m_internal->GetState() != STATE_NEW )
 540     {
 541         // actually, it may be almost any state at all, not only STATE_RUNNING
 542         return wxTHREAD_RUNNING;
 543     }
 544     return Resume();
 545 }
 546
 547 // suspend/resume thread
 548 // ---------------------
 549
 550 wxThreadError wxThread::Pause()
 551 {
 552     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 553
 554     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 555 }
 556
 557 wxThreadError wxThread::Resume()
 558 {
 559     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 560
 561     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 562 }
 563
 564 // stopping thread
 565 // ---------------
 566
 567 wxThread::ExitCode wxThread::Wait()
 568 {
 569     // although under Windows we can wait for any thread, it's an error to
 570     // wait for a detached one in wxWin API
 571     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
 572                  _T("can't wait for detached thread") );
 573     ExitCode rc = (ExitCode)-1;
 574     (void)Delete(&rc);
 575     m_internal->Free();
 576     return(rc);
 577 }
 578
 579 wxThreadError wxThread::Delete(ExitCode *pRc)
 580 {
 581     ExitCode rc = 0;
 582
 583     // Delete() is always safe to call, so consider all possible states
 584     if (IsPaused())
 585         Resume();
 586
 587     TID                             hThread = m_internal->GetHandle();
 588
 589     if (IsRunning())
 590     {
 591         if (IsMain())
 592         {
 593             // set flag for wxIsWaitingForThread()
 594             gs_bWaitingForThread = TRUE;
 595
 596 #if wxUSE_GUI
 597             wxBeginBusyCursor();
 598 #endif // wxUSE_GUI
 599         }
 600
 601         // ask the thread to terminate
 602         {
 603             wxCriticalSectionLocker lock(m_critsect);
 604             m_internal->Cancel();
 605         }
 606
 607 #if wxUSE_GUI
 608         // need a way to finish GUI processing before killing the thread
 609         // until then we just exit
 610
 611         if ((gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread())
 612         {
 613             wxMutexGuiLeave();
 614         }
 615 #else // !wxUSE_GUI
 616
 617         // can't wait for yourself to end under OS/2 so just quit
 618
 619 #endif // wxUSE_GUI/!wxUSE_GUI
 620
 621         if ( IsMain() )
 622         {
 623             gs_bWaitingForThread = FALSE;
 624
 625 #if wxUSE_GUI
 626             wxEndBusyCursor();
 627 #endif // wxUSE_GUI
 628         }
 629     }
 630
 631     ::DosExit(0, 0);
 632     // probably won't get this far, but
 633     if (IsDetached())
 634     {
 635         delete this;
 636     }
 637
 638     if ( pRc )
 639         *pRc = rc;
 640
 641     return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
 642 }
 643
 644 wxThreadError wxThread::Kill()
 645 {
 646     if (!IsRunning())
 647         return wxTHREAD_NOT_RUNNING;
 648
 649     ::DosKillThread(m_internal->GetHandle());
 650     m_internal->Free();
 651     if (IsDetached())
 652     {
 653         delete this;
 654     }
 655     return wxTHREAD_NO_ERROR;
 656 }
 657
 658 void wxThread::Exit(
 659   ExitCode                          pStatus
 660 )
 661 {
 662     m_internal->Free();
 663     delete this;
 664     ::DosExit(EXIT_THREAD, ULONG(pStatus));
 665     wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
 666 }
 667
 668 void wxThread::SetPriority(
 669   unsigned int                      nPrio
 670 )
 671 {
 672     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 673
 674     m_internal->SetPriority(nPrio);
 675 }
 676
 677 unsigned int wxThread::GetPriority() const
 678 {
 679     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 680
 681     return m_internal->GetPriority();
 682 }
 683
 684 unsigned long wxThread::GetId() const
 685 {
 686     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 687
 688     return (unsigned long)m_internal->GetId();
 689 }
 690
 691 bool wxThread::IsRunning() const
 692 {
 693     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 694
 695     return(m_internal->GetState() == STATE_RUNNING);
 696 }
 697
 698 bool wxThread::IsAlive() const
 699 {
 700     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 701
 702     return (m_internal->GetState() == STATE_RUNNING) ||
 703            (m_internal->GetState() == STATE_PAUSED);
 704 }
 705
 706 bool wxThread::IsPaused() const
 707 {
 708     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 709
 710     return (m_internal->GetState() == STATE_PAUSED);
 711 }
 712
 713 bool wxThread::TestDestroy()
 714 {
 715     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 716
 717     return m_internal->GetState() == STATE_CANCELED;
 718 }
 719
 720 // ----------------------------------------------------------------------------
 721 // Automatic initialization for thread module
 722 // ----------------------------------------------------------------------------
 723
 724 class wxThreadModule : public wxModule
 725 {
 726 public:
 727     virtual bool OnInit();
 728     virtual void OnExit();
 729
 730 private:
 731     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 732 };
 733
 734 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 735
 736 bool wxThreadModule::OnInit()
 737 {
 738     gs_pCritsectWaitingForGui = new wxCriticalSection();
 739
 740     gs_pCritsectGui = new wxCriticalSection();
 741     gs_pCritsectGui->Enter();
 742
 743     PTIB                            ptib;
 744     PPIB                            ppib;
 745
 746     ::DosGetInfoBlocks(&ptib, &ppib);
 747
 748     s_ulIdMainThread = ptib->tib_ptib2->tib2_ultid;
 749     return TRUE;
 750 }
 751
 752 void wxThreadModule::OnExit()
 753 {
 754     if (gs_pCritsectGui)
 755     {
 756         gs_pCritsectGui->Leave();
 757 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
 758         delete gs_pCritsectGui;
 759 #endif
 760         gs_pCritsectGui = NULL;
 761     }
 762
 763 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
 764     wxDELETE(gs_pCritsectWaitingForGui);
 765 #endif
 766 }
 767
 768 // ----------------------------------------------------------------------------
 769 // Helper functions
 770 // ----------------------------------------------------------------------------
 771
 772 // Does nothing under OS/2 [for now]
 773 void WXDLLEXPORT wxWakeUpMainThread()
 774 {
 775 }
 776
 777 void WXDLLEXPORT wxMutexGuiLeave()
 778 {
 779     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 780
 781     if ( wxThread::IsMain() )
 782     {
 783         gs_bGuiOwnedByMainThread = FALSE;
 784     }
 785     else
 786     {
 787         // decrement the number of waiters now
 788         wxASSERT_MSG(gs_nWaitingForGui > 0,
 789                       wxT("calling wxMutexGuiLeave() without entering it first?") );
 790
 791         gs_nWaitingForGui--;
 792
 793         wxWakeUpMainThread();
 794     }
 795
 796     gs_pCritsectGui->Leave();
 797 }
 798
 799 void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
 800 {
 801     wxASSERT_MSG( wxThread::IsMain(),
 802                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
 803
 804     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 805
 806     if (gs_nWaitingForGui == 0)
 807     {
 808         // no threads are waiting for GUI - so we may acquire the lock without
 809         // any danger (but only if we don't already have it)
 810         if (!wxGuiOwnedByMainThread())
 811         {
 812             gs_pCritsectGui->Enter();
 813
 814             gs_bGuiOwnedByMainThread = TRUE;
 815         }
 816         //else: already have it, nothing to do
 817     }
 818     else
 819     {
 820         // some threads are waiting, release the GUI lock if we have it
 821         if (wxGuiOwnedByMainThread())
 822         {
 823             wxMutexGuiLeave();
 824         }
 825         //else: some other worker thread is doing GUI
 826     }
 827 }
 828
 829 bool WXDLLEXPORT wxGuiOwnedByMainThread()
 830 {
 831     return gs_bGuiOwnedByMainThread;
 832 }
 833
 834 bool WXDLLEXPORT wxIsWaitingForThread()
 835 {
 836     return gs_bWaitingForThread;
 837 }
 838
 839 #endif
 840   // wxUSE_THREADS