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