Rename wxWebNavigationError to wxWebViewNavigationError and wxWebNavigationEvent...

[wxWidgets.git] / src / unix / threadpsx.cpp

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 48beb9ca6cff5e0fec4d81868e327ba4b5adb955..22fefee76d267440e3ab5aaa46abe801a26219f3 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        threadpsx.cpp
+// Name:        src/unix/threadpsx.cpp

 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
 // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
 // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore


@@ -21,28 +21,32 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "thread.h"
-#endif
-
-#include "wx/defs.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 #if wxUSE_THREADS
 
 #include "wx/thread.h"
 
 #if wxUSE_THREADS
 
 #include "wx/thread.h"

-#include "wx/module.h"
-#include "wx/utils.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
-#include "wx/timer.h"
+#include "wx/except.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/app.h"
+    #include "wx/dynarray.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/utils.h"
+    #include "wx/timer.h"
+    #include "wx/stopwatch.h"
+    #include "wx/module.h"
+#endif

 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>

-#if HAVE_SCHED_H
+#include <sys/time.h>           // needed for at least __QNX__
+#ifdef HAVE_SCHED_H

     #include <sched.h>
 #endif
 
     #include <sched.h>
 #endif
 


@@ -53,8 +57,12 @@
 // we use wxFFile under Linux in GetCPUCount()
 #ifdef __LINUX__
     #include "wx/ffile.h"
 // we use wxFFile under Linux in GetCPUCount()
 #ifdef __LINUX__
     #include "wx/ffile.h"

+    #include <sys/resource.h>   // for setpriority()

 #endif
 
 #endif
 

+#define THR_ID_CAST(id)  (reinterpret_cast<void*>(id))
+#define THR_ID(thr)      THR_ID_CAST((thr)->GetId())
+

 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------


@@ -71,8 +79,11 @@ enum wxThreadState
 // the exit value of a thread which has been cancelled
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 
 // the exit value of a thread which has been cancelled
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 

-// our trace mask
-#define TRACE_THREADS   _T("thread")
+// trace mask for wxThread operations
+#define TRACE_THREADS   wxT("thread")
+
+// you can get additional debugging messages for the semaphore operations
+#define TRACE_SEMA      wxT("semaphore")

 
 // ----------------------------------------------------------------------------
 // private functions
 
 // ----------------------------------------------------------------------------
 // private functions


@@ -82,10 +93,13 @@ static void ScheduleThreadForDeletion();
 static void DeleteThread(wxThread *This);
 
 // ----------------------------------------------------------------------------
 static void DeleteThread(wxThread *This);
 
 // ----------------------------------------------------------------------------

-// types
+// private classes

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+// an (non owning) array of pointers to threads
+WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
+
+// an entry for a thread we can wait for

 
 // -----------------------------------------------------------------------------
 // global data
 
 // -----------------------------------------------------------------------------
 // global data


@@ -96,8 +110,15 @@ WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 // be left in memory
 static wxArrayThread gs_allThreads;
 
 // be left in memory
 static wxArrayThread gs_allThreads;
 

+// a mutex to protect gs_allThreads
+static wxMutex *gs_mutexAllThreads = NULL;
+

 // the id of the main thread
 // the id of the main thread

-static pthread_t gs_tidMain;
+//
+// we suppose that 0 is not a valid pthread_t value but in principle this might
+// be false (e.g. if it's a selector-like value), wxThread::IsMain() would need
+// to be updated in such case
+wxThreadIdType wxThread::ms_idMainThread = 0;

 
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
 
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;


@@ -107,16 +128,27 @@ static pthread_key_t gs_keySelf;
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted

-static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
+static wxMutex *gs_mutexDeleteThread = NULL;

 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted

-static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
+static wxCondition *gs_condAllDeleted = NULL;
+
+#ifndef __WXOSX__
+// this mutex must be acquired before any call to a GUI function
+// (it's not inside #if wxUSE_GUI because this file is compiled as part
+// of wxBase)
+static wxMutex *gs_mutexGui = NULL;
+#endif

 
 

-#if wxUSE_GUI
-    // this mutex must be acquired before any call to a GUI function
-    static wxMutex *gs_mutexGui;
-#endif // wxUSE_GUI
+// when we wait for a thread to exit, we're blocking on a condition which the
+// thread signals in its SignalExit() method -- but this condition can't be a
+// member of the thread itself as a detached thread may delete itself at any
+// moment and accessing the condition member of the thread after this would
+// result in a disaster
+//
+// so instead we maintain a global list of the structs below for the threads
+// we're interested in waiting on

 
 // ============================================================================
 // wxMutex implementation
 
 // ============================================================================
 // wxMutex implementation


@@ -126,98 +158,228 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 // wxMutexInternal
 // ----------------------------------------------------------------------------
 
 // wxMutexInternal
 // ----------------------------------------------------------------------------
 

+// this is a simple wrapper around pthread_mutex_t which provides error
+// checking

 class wxMutexInternal
 {
 public:
 class wxMutexInternal
 {
 public:

-    wxMutexInternal();
+    wxMutexInternal(wxMutexType mutexType);

     ~wxMutexInternal();
 
     wxMutexError Lock();
     ~wxMutexInternal();
 
     wxMutexError Lock();

+    wxMutexError Lock(unsigned long ms);

     wxMutexError TryLock();
     wxMutexError Unlock();
 
     wxMutexError TryLock();
     wxMutexError Unlock();
 

+    bool IsOk() const { return m_isOk; }
+
+private:
+    // convert the result of pthread_mutex_[timed]lock() call to wx return code
+    wxMutexError HandleLockResult(int err);
+

 private:
     pthread_mutex_t m_mutex;
 private:
     pthread_mutex_t m_mutex;

+    bool m_isOk;
+    wxMutexType m_type;
+    unsigned long m_owningThread;

 
 

+    // wxConditionInternal uses our m_mutex

     friend class wxConditionInternal;
 };
 
     friend class wxConditionInternal;
 };
 

-wxMutexInternal::wxMutexInternal()
+#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
+        wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
+// on some systems pthread_mutexattr_settype() is not in the headers (but it is
+// in the library, otherwise we wouldn't compile this code at all)
+extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
+#endif
+
+wxMutexInternal::wxMutexInternal(wxMutexType mutexType)

 {
 {

-    // support recursive locks like Win32, i.e. a thread can lock a mutex which
-    // it had itself already locked
-    //
-    // but initialization of recursive mutexes is non portable <sigh>, so try
-    // several methods
+    m_type = mutexType;
+    m_owningThread = 0;
+
+    int err;
+    switch ( mutexType )
+    {
+        case wxMUTEX_RECURSIVE:
+            // support recursive locks like Win32, i.e. a thread can lock a
+            // mutex which it had itself already locked
+            //
+            // unfortunately initialization of recursive mutexes is non
+            // portable, so try several methods

 #ifdef HAVE_PTHREAD_MUTEXATTR_T
 #ifdef HAVE_PTHREAD_MUTEXATTR_T

-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+            {
+                pthread_mutexattr_t attr;
+                pthread_mutexattr_init(&attr);
+                pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

 
 

-    pthread_mutex_init(&m_mutex, &attr);
+                err = pthread_mutex_init(&m_mutex, &attr);
+            }

 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)

-    // we can use this only as initializer so we have to assign it first to a
-    // temp var - assigning directly to m_mutex wouldn't even compile
-    pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-    m_mutex = mutex;
+            // we can use this only as initializer so we have to assign it
+            // first to a temp var - assigning directly to m_mutex wouldn't
+            // even compile
+            {
+                pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+                m_mutex = mutex;
+            }

 #else // no recursive mutexes
 #else // no recursive mutexes

-    pthread_mutex_init(&m_mutex, NULL);
-
-    // used by TryLock() below
-    #define NO_RECURSIVE_MUTEXES
+            err = EINVAL;

 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
 #endif // HAVE_PTHREAD_MUTEXATTR_T/...

+            break;
+
+        default:
+            wxFAIL_MSG( wxT("unknown mutex type") );
+            // fall through
+
+        case wxMUTEX_DEFAULT:
+            err = pthread_mutex_init(&m_mutex, NULL);
+            break;
+    }
+
+    m_isOk = err == 0;
+    if ( !m_isOk )
+    {
+        wxLogApiError( wxT("pthread_mutex_init()"), err);
+    }

 }
 
 wxMutexInternal::~wxMutexInternal()
 {
 }
 
 wxMutexInternal::~wxMutexInternal()
 {

-    pthread_mutex_destroy(&m_mutex);
+    if ( m_isOk )
+    {
+        int err = pthread_mutex_destroy(&m_mutex);
+        if ( err != 0 )
+        {
+            wxLogApiError( wxT("pthread_mutex_destroy()"), err);
+        }
+    }

 }
 
 wxMutexError wxMutexInternal::Lock()
 {
 }
 
 wxMutexError wxMutexInternal::Lock()
 {

-    int err = pthread_mutex_lock(&m_mutex);
+    if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0))
+    {
+        if (m_owningThread == wxThread::GetCurrentId())
+           return wxMUTEX_DEAD_LOCK;
+    }
+
+    return HandleLockResult(pthread_mutex_lock(&m_mutex));
+}
+
+wxMutexError wxMutexInternal::Lock(unsigned long ms)
+{
+#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
+    static const long MSEC_IN_SEC   = 1000;
+    static const long NSEC_IN_MSEC  = 1000000;
+    static const long NSEC_IN_USEC  = 1000;
+    static const long NSEC_IN_SEC   = MSEC_IN_SEC * NSEC_IN_MSEC;
+
+    time_t seconds = ms/MSEC_IN_SEC;
+    long nanoseconds = (ms % MSEC_IN_SEC) * NSEC_IN_MSEC;
+    timespec ts = { 0, 0 };
+
+    // normally we should use clock_gettime(CLOCK_REALTIME) here but this
+    // function is in librt and we don't link with it currently, so use
+    // gettimeofday() instead -- if it turns out that this is really too
+    // imprecise, we should modify configure to check if clock_gettime() is
+    // available and whether it requires -lrt and use it instead
+#if 0
+    if ( clock_gettime(CLOCK_REALTIME, &ts) == 0 )
+    {
+    }
+#else
+    struct timeval tv;
+    if ( wxGetTimeOfDay(&tv) != -1 )
+    {
+        ts.tv_sec = tv.tv_sec;
+        ts.tv_nsec = tv.tv_usec*NSEC_IN_USEC;
+    }
+#endif
+    else // fall back on system timer
+    {
+        ts.tv_sec = time(NULL);
+    }
+
+    ts.tv_sec += seconds;
+    ts.tv_nsec += nanoseconds;
+    if ( ts.tv_nsec > NSEC_IN_SEC )
+    {
+        ts.tv_sec += 1;
+        ts.tv_nsec -= NSEC_IN_SEC;
+    }
+
+    return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts));
+#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
+    wxUnusedVar(ms);
+
+    return wxMUTEX_MISC_ERROR;
+#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
+}
+
+wxMutexError wxMutexInternal::HandleLockResult(int err)
+{
+    // wxPrintf( "err %d\n", err );
+

     switch ( err )
     {
         case EDEADLK:
     switch ( err )
     {
         case EDEADLK:

-            wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+            // only error checking mutexes return this value and so it's an
+            // unexpected situation -- hence use assert, not wxLogDebug
+            wxFAIL_MSG( wxT("mutex deadlock prevented") );

             return wxMUTEX_DEAD_LOCK;
 
             return wxMUTEX_DEAD_LOCK;
 

-        default:
-            wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
-            // fall through
-

         case EINVAL:
         case EINVAL:

-            wxLogDebug(_T("Failed to lock the mutex."));
-            return wxMUTEX_MISC_ERROR;
+            wxLogDebug(wxT("pthread_mutex_[timed]lock(): mutex not initialized"));
+            break;
+
+        case ETIMEDOUT:
+            return wxMUTEX_TIMEOUT;

 
         case 0:
 
         case 0:

+            if (m_type == wxMUTEX_DEFAULT)
+                m_owningThread = wxThread::GetCurrentId();

             return wxMUTEX_NO_ERROR;
             return wxMUTEX_NO_ERROR;

+
+        default:
+            wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err);

     }
     }

+
+    return wxMUTEX_MISC_ERROR;

 }
 
 }
 

+

 wxMutexError wxMutexInternal::TryLock()
 {
     int err = pthread_mutex_trylock(&m_mutex);
     switch ( err )
     {
         case EBUSY:
 wxMutexError wxMutexInternal::TryLock()
 {
     int err = pthread_mutex_trylock(&m_mutex);
     switch ( err )
     {
         case EBUSY:

+            // not an error: mutex is already locked, but we're prepared for
+            // this

             return wxMUTEX_BUSY;
 
             return wxMUTEX_BUSY;
 

-        default:
-            wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
-            // fall through
-

         case EINVAL:
         case EINVAL:

-            wxLogDebug(_T("Failed to try to lock the mutex."));
-            return wxMUTEX_MISC_ERROR;
+            wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized."));
+            break;

 
         case 0:
 
         case 0:

+            if (m_type == wxMUTEX_DEFAULT)
+                m_owningThread = wxThread::GetCurrentId();

             return wxMUTEX_NO_ERROR;
             return wxMUTEX_NO_ERROR;

+
+        default:
+            wxLogApiError(wxT("pthread_mutex_trylock()"), err);

     }
     }

+
+    return wxMUTEX_MISC_ERROR;

 }
 
 wxMutexError wxMutexInternal::Unlock()
 {
 }
 
 wxMutexError wxMutexInternal::Unlock()
 {

+    m_owningThread = 0;
+

     int err = pthread_mutex_unlock(&m_mutex);
     switch ( err )
     {
     int err = pthread_mutex_unlock(&m_mutex);
     switch ( err )
     {


@@ -225,87 +387,18 @@ wxMutexError wxMutexInternal::Unlock()
             // we don't own the mutex
             return wxMUTEX_UNLOCKED;
 
             // we don't own the mutex
             return wxMUTEX_UNLOCKED;
 

-        default:
-            wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
-            // fall through
-

         case EINVAL:
         case EINVAL:

-            wxLogDebug(_T("Failed to unlock the mutex."));
-            return wxMUTEX_MISC_ERROR;
+            wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized."));
+            break;

 
         case 0:
             return wxMUTEX_NO_ERROR;
 
         case 0:
             return wxMUTEX_NO_ERROR;

-    }
-}
-
-// ----------------------------------------------------------------------------
-// wxMutex
-// ----------------------------------------------------------------------------
-
-// TODO: this is completely generic, move it to common code?
-
-wxMutex::wxMutex()
-{
-    m_internal = new wxMutexInternal;
-
-    m_locked = 0;
-}
-
-wxMutex::~wxMutex()
-{
-    if ( m_locked > 0 )
-        wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
-
-    delete m_internal;
-}

 
 

-wxMutexError wxMutex::Lock()
-{
-    wxMutexError err = m_internal->Lock();
-
-    if ( !err )
-    {
-        m_locked++;
-    }
-
-    return err;
-}
-
-wxMutexError wxMutex::TryLock()
-{
-    if ( m_locked )
-    {
-#ifdef NO_RECURSIVE_MUTEXES
-        return wxMUTEX_DEAD_LOCK;
-#else // have recursive mutexes on this platform
-        // we will succeed in locking it when we have it already locked
-        return wxMUTEX_NO_ERROR;
-#endif // recursive/non-recursive mutexes
-    }
-
-    wxMutexError err = m_internal->TryLock();
-    if ( !err )
-    {
-        m_locked++;
-    }
-
-    return err;
-}
-
-wxMutexError wxMutex::Unlock()
-{
-    if ( m_locked > 0 )
-    {
-        m_locked--;
-    }
-    else
-    {
-        wxLogDebug(wxT("Unlocking not locked mutex."));
-
-        return wxMUTEX_UNLOCKED;
+        default:
+            wxLogApiError(wxT("pthread_mutex_unlock()"), err);

     }
 
     }
 

-    return m_internal->Unlock();
+    return wxMUTEX_MISC_ERROR;

 }
 
 // ===========================================================================
 }
 
 // ===========================================================================


@@ -316,121 +409,77 @@ wxMutexError wxMutex::Unlock()
 // wxConditionInternal
 // ---------------------------------------------------------------------------
 
 // wxConditionInternal
 // ---------------------------------------------------------------------------
 

+// this is a wrapper around pthread_cond_t associated with a wxMutex (and hence
+// with a pthread_mutex_t)

 class wxConditionInternal
 {
 public:
 class wxConditionInternal
 {
 public:

-    wxConditionInternal( wxMutex *mutex );
+    wxConditionInternal(wxMutex& mutex);

     ~wxConditionInternal();
 
     ~wxConditionInternal();
 

-    void Wait();
-
-    bool Wait( const timespec *ts );
+    bool IsOk() const { return m_isOk && m_mutex.IsOk(); }

 
 

-    void Signal();
+    wxCondError Wait();
+    wxCondError WaitTimeout(unsigned long milliseconds);

 
 

-    void Broadcast();
+    wxCondError Signal();
+    wxCondError Broadcast();

 
 private:
 
 private:

+    // get the POSIX mutex associated with us
+    pthread_mutex_t *GetPMutex() const { return &m_mutex.m_internal->m_mutex; }

 
 

-    wxMutex *m_mutex;
+    wxMutex& m_mutex;

     pthread_cond_t m_cond;
     pthread_cond_t m_cond;

+
+    bool m_isOk;

 };
 
 };
 

-wxConditionInternal::wxConditionInternal( wxMutex *mutex )
+wxConditionInternal::wxConditionInternal(wxMutex& mutex)
+                   : m_mutex(mutex)

 {
 {

-    m_mutex = mutex;
-    if ( pthread_cond_init( &m_cond, NULL ) != 0 )
-    {
-        wxLogDebug(_T("pthread_cond_init() failed"));
-    }
-}
+    int err = pthread_cond_init(&m_cond, NULL /* default attributes */);

 
 

-wxConditionInternal::~wxConditionInternal()
-{
-    if ( pthread_cond_destroy( &m_cond ) != 0 )
-    {
-        wxLogDebug(_T("pthread_cond_destroy() failed"));
-    }
-}
+    m_isOk = err == 0;

 
 

-void wxConditionInternal::Wait()
-{
-    if ( pthread_cond_wait( &m_cond, &(m_mutex->m_internal->m_mutex) ) != 0 )
+    if ( !m_isOk )

     {
     {

-        wxLogDebug(_T("pthread_cond_wait() failed"));
-    }
-}
-
-bool wxConditionInternal::Wait( const timespec *ts )
-{
-    int result = pthread_cond_timedwait( &m_cond,
-                                         &(m_mutex->m_internal->m_mutex),
-                                         ts );
-    if ( result == ETIMEDOUT )
-        return FALSE;
-
-    wxASSERT_MSG( result == 0, _T("pthread_cond_timedwait() failed") );
-
-    return TRUE;
-}
-
-void wxConditionInternal::Signal()
-{
-    int result = pthread_cond_signal( &m_cond );
-    if ( result != 0 )
-{
-        wxFAIL_MSG( _T("pthread_cond_signal() failed") );
+        wxLogApiError(wxT("pthread_cond_init()"), err);

     }
 }
 
     }
 }
 

-void wxConditionInternal::Broadcast()
-{
-    int result = pthread_cond_broadcast( &m_cond );
-    if ( result != 0 )
+wxConditionInternal::~wxConditionInternal()

 {
 {

-        wxFAIL_MSG( _T("pthread_cond_broadcast() failed") );
+    if ( m_isOk )
+    {
+        int err = pthread_cond_destroy(&m_cond);
+        if ( err != 0 )
+        {
+            wxLogApiError(wxT("pthread_cond_destroy()"), err);
+        }

     }
 }
 
     }
 }
 

-
-// ---------------------------------------------------------------------------
-// wxCondition
-// ---------------------------------------------------------------------------
-
-wxCondition::wxCondition( wxMutex *mutex )
+wxCondError wxConditionInternal::Wait()

 {
 {

-    if ( !mutex )
+    int err = pthread_cond_wait(&m_cond, GetPMutex());
+    if ( err != 0 )

     {
     {

-        wxFAIL_MSG( _T("NULL mutex in wxCondition ctor") );
+        wxLogApiError(wxT("pthread_cond_wait()"), err);

 
 

-        m_internal = NULL;
+        return wxCOND_MISC_ERROR;

     }
     }

-    else
-    {
-        m_internal = new wxConditionInternal( mutex );
-    }
-}
-
-wxCondition::~wxCondition()
-{
-    delete m_internal;
-}

 
 

-void wxCondition::Wait()
-{
-    if ( m_internal )
-        m_internal->Wait();
+    return wxCOND_NO_ERROR;

 }
 
 }
 

-bool wxCondition::Wait( unsigned long timeout_millis )
+wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)

 {
 {

-    wxCHECK_MSG( m_internal, FALSE, _T("can't wait on uninitalized condition") );
-

     wxLongLong curtime = wxGetLocalTimeMillis();
     wxLongLong curtime = wxGetLocalTimeMillis();

-    curtime += timeout_millis;
+    curtime += milliseconds;

     wxLongLong temp = curtime / 1000;
     int sec = temp.GetLo();
     wxLongLong temp = curtime / 1000;
     int sec = temp.GetLo();

-    temp = temp * 1000;
+    temp *= 1000;

     temp = curtime - temp;
     int millis = temp.GetLo();
 
     temp = curtime - temp;
     int millis = temp.GetLo();
 


@@ -439,19 +488,46 @@ bool wxCondition::Wait( unsigned long timeout_millis )
     tspec.tv_sec = sec;
     tspec.tv_nsec = millis * 1000L * 1000L;
 
     tspec.tv_sec = sec;
     tspec.tv_nsec = millis * 1000L * 1000L;
 

-    return m_internal->Wait(&tspec);
+    int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
+    switch ( err )
+    {
+        case ETIMEDOUT:
+            return wxCOND_TIMEOUT;
+
+        case 0:
+            return wxCOND_NO_ERROR;
+
+        default:
+            wxLogApiError(wxT("pthread_cond_timedwait()"), err);
+    }
+
+    return wxCOND_MISC_ERROR;

 }
 
 }
 

-void wxCondition::Signal()
+wxCondError wxConditionInternal::Signal()

 {
 {

-    if ( m_internal )
-        m_internal->Signal();
+    int err = pthread_cond_signal(&m_cond);
+    if ( err != 0 )
+    {
+        wxLogApiError(wxT("pthread_cond_signal()"), err);
+
+        return wxCOND_MISC_ERROR;
+    }
+
+    return wxCOND_NO_ERROR;

 }
 
 }
 

-void wxCondition::Broadcast()
+wxCondError wxConditionInternal::Broadcast()

 {
 {

-    if ( m_internal )
-        m_internal->Broadcast();
+    int err = pthread_cond_broadcast(&m_cond);
+    if ( err != 0 )
+    {
+        wxLogApiError(wxT("pthread_cond_broadcast()"), err);
+
+        return wxCOND_MISC_ERROR;
+    }
+
+    return wxCOND_NO_ERROR;

 }
 
 // ===========================================================================
 }
 
 // ===========================================================================


@@ -462,221 +538,139 @@ void wxCondition::Broadcast()
 // wxSemaphoreInternal
 // ---------------------------------------------------------------------------
 
 // wxSemaphoreInternal
 // ---------------------------------------------------------------------------
 

+// we implement the semaphores using mutexes and conditions instead of using
+// the sem_xxx() POSIX functions because they're not widely available and also
+// because it's impossible to implement WaitTimeout() using them

 class wxSemaphoreInternal
 {
 public:
 class wxSemaphoreInternal
 {
 public:

-    wxSemaphoreInternal( int initialcount, int maxcount );
+    wxSemaphoreInternal(int initialcount, int maxcount);

 
 

-    void Wait();
-    bool TryWait();
+    bool IsOk() const { return m_isOk; }

 
 

-    bool Wait( unsigned long timeout_millis );
+    wxSemaError Wait();
+    wxSemaError TryWait();
+    wxSemaError WaitTimeout(unsigned long milliseconds);

 
 

-    void Post();
+    wxSemaError Post();

 
 private:
     wxMutex m_mutex;
     wxCondition m_cond;
 
 
 private:
     wxMutex m_mutex;
     wxCondition m_cond;
 

-    int count,
-        maxcount;
+    size_t m_count,
+           m_maxcount;
+
+    bool m_isOk;

 };
 
 };
 

-wxSemaphoreInternal::wxSemaphoreInternal( int initialcount, int maxcount )
-                   : m_cond(&m_mutex)
+wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
+                   : m_cond(m_mutex)

 {
 
 {
 

-    if ( (initialcount < 0) || ((maxcount > 0) && (initialcount > maxcount)) )
+    if ( (initialcount < 0 || maxcount < 0) ||
+            ((maxcount > 0) && (initialcount > maxcount)) )

     {
     {

-        wxFAIL_MSG( _T("wxSemaphore: invalid initial count") );
-    }
-
-    maxcount = maxcount;
-    count = initialcount;
-}
-
-void wxSemaphoreInternal::Wait()
-{
-    wxMutexLocker locker(m_mutex);
+        wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") );

 
 

-    while ( count <= 0 )
-    {
-        m_cond.Wait();
+        m_isOk = false;

     }
     }

-
-    count--;
-}
-
-bool wxSemaphoreInternal::TryWait()
-{
-    wxMutexLocker locker(m_mutex);
-
-    if ( count <= 0 )
-        return FALSE;
-
-    count--;
-
-    return TRUE;
-}
-
-bool wxSemaphoreInternal::Wait( unsigned long timeout_millis )
-{
-    wxMutexLocker locker(m_mutex);
-
-    wxLongLong startTime = wxGetLocalTimeMillis();
-
-    while ( count <= 0 )
+    else

     {
     {

-        wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
-        long remainingTime = (long)timeout_millis - (long)elapsed.GetLo();
-        if ( remainingTime <= 0 )
-            return FALSE;
-
-        bool result = m_cond.Wait( remainingTime );
-        if ( !result )
-            return FALSE;
+        m_maxcount = (size_t)maxcount;
+        m_count = (size_t)initialcount;

     }
 
     }
 

-    count--;
-
-    return TRUE;
+    m_isOk = m_mutex.IsOk() && m_cond.IsOk();

 }
 
 }
 

-void wxSemaphoreInternal::Post()
+wxSemaError wxSemaphoreInternal::Wait()

 {
     wxMutexLocker locker(m_mutex);
 
 {
     wxMutexLocker locker(m_mutex);
 

-    if ( maxcount > 0 && count == maxcount )
+    while ( m_count == 0 )

     {
     {

-        wxFAIL_MSG( _T("wxSemaphore::Post() overflow") );
-    }
-
-    count++;
+        wxLogTrace(TRACE_SEMA,
+                   wxT("Thread %p waiting for semaphore to become signalled"),
+                   THR_ID_CAST(wxThread::GetCurrentId()));

 
 

-    m_cond.Signal();
-}
+        if ( m_cond.Wait() != wxCOND_NO_ERROR )
+            return wxSEMA_MISC_ERROR;

 
 

-// --------------------------------------------------------------------------
-// wxSemaphore
-// --------------------------------------------------------------------------
+        wxLogTrace(TRACE_SEMA,
+                   wxT("Thread %p finished waiting for semaphore, count = %lu"),
+                   THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
+    }

 
 

-wxSemaphore::wxSemaphore( int initialcount, int maxcount )
-{
-    m_internal = new wxSemaphoreInternal( initialcount, maxcount );
-}
+    m_count--;

 
 

-wxSemaphore::~wxSemaphore()
-{
-    delete m_internal;
+    return wxSEMA_NO_ERROR;

 }
 
 }
 

-void wxSemaphore::Wait()
+wxSemaError wxSemaphoreInternal::TryWait()

 {
 {

-    m_internal->Wait();
-}
+    wxMutexLocker locker(m_mutex);

 
 

-bool wxSemaphore::TryWait()
-{
-    return m_internal->TryWait();
-}
+    if ( m_count == 0 )
+        return wxSEMA_BUSY;

 
 

-bool wxSemaphore::Wait( unsigned long timeout_millis )
-{
-    return m_internal->Wait( timeout_millis );
-}
+    m_count--;

 
 

-void wxSemaphore::Post()
-{
-    m_internal->Post();
+    return wxSEMA_NO_ERROR;

 }
 
 }
 

-// This class is used by wxThreadInternal to support Delete() on
-// a detached thread
-class wxRefCountedCondition
+wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)

 {
 {

-public:
-    // start with a initial reference count of 1
-    wxRefCountedCondition()
-    {
-        m_refCount = 1;
-        m_signaled = FALSE;
-
-        m_mutex = new wxMutex();
-        m_cond = new wxCondition( m_mutex );
-    }
-
-    // increment the reference count
-    void AddRef()
-    {
-        wxMutexLocker locker( *m_mutex );
+    wxMutexLocker locker(m_mutex);

 
 

-        m_refCount++;
-    }
+    wxLongLong startTime = wxGetLocalTimeMillis();

 
 

-    // decrement the reference count if reference count is zero then delete the
-    // object
-    void DeleteRef()
+    while ( m_count == 0 )

     {
     {

-        bool shouldDelete = FALSE;
-
-        m_mutex->Lock();
-
-        if ( --m_refCount == 0 )
+        wxLongLong elapsed = wxGetLocalTimeMillis() - startTime;
+        long remainingTime = (long)milliseconds - (long)elapsed.GetLo();
+        if ( remainingTime <= 0 )

         {
         {

-            shouldDelete = TRUE;
+            // timeout
+            return wxSEMA_TIMEOUT;

         }
 
         }
 

-        m_mutex->Unlock();
-
-        if ( shouldDelete )
+        switch ( m_cond.WaitTimeout(remainingTime) )

         {
         {

-            delete this;
-        }
-    }
-
-
-    // sets the object to signaled this signal will be a persistent signal all
-    // further Wait()s on the object will return without blocking
-    void SetSignaled()
-    {
-        wxMutexLocker locker( *m_mutex );
+            case wxCOND_TIMEOUT:
+                return wxSEMA_TIMEOUT;

 
 

-        m_signaled = TRUE;
+            default:
+                return wxSEMA_MISC_ERROR;

 
 

-        m_cond->Broadcast();
-    }
-
-    // wait till the object is signaled if the object was already signaled then
-    // return immediately
-    void Wait()
-    {
-        wxMutexLocker locker( *m_mutex );
-
-        if ( !m_signaled )
-        {
-            m_cond->Wait();
+            case wxCOND_NO_ERROR:
+                ;

         }
     }
 
         }
     }
 

-private:
-    int m_refCount;
+    m_count--;

 
 

-    wxMutex *m_mutex;
-    wxCondition *m_cond;
+    return wxSEMA_NO_ERROR;
+}

 
 

-    bool m_signaled;
+wxSemaError wxSemaphoreInternal::Post()
+{
+    wxMutexLocker locker(m_mutex);

 
 

-    // Cannot delete this object directly, call DeleteRef() instead
-    ~wxRefCountedCondition()
+    if ( m_maxcount > 0 && m_count == m_maxcount )

     {
     {

-        delete m_cond;
-        delete m_mutex;
+        return wxSEMA_OVERFLOW;

     }
 
     }
 

-    // suppress gcc warning about the class having private dtor and not having
-    // friend (so what??)
-    friend class wxDummyFriend;
-};
+    m_count++;
+
+    wxLogTrace(TRACE_SEMA,
+               wxT("Thread %p about to signal semaphore, count = %lu"),
+               THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
+
+    return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
+                                              : wxSEMA_MISC_ERROR;
+}

 
 // ===========================================================================
 // wxThread implementation
 
 // ===========================================================================
 // wxThread implementation


@@ -686,10 +680,10 @@ private:
 extern "C"
 {
 
 extern "C"
 {
 

-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP

     // thread exit function
     void wxPthreadCleanup(void *ptr);
     // thread exit function
     void wxPthreadCleanup(void *ptr);

-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP

 
 void *wxPthreadStart(void *ptr);
 
 
 void *wxPthreadStart(void *ptr);
 


@@ -711,12 +705,10 @@ public:
     // thread actions
         // start the thread
     wxThreadError Run();
     // thread actions
         // start the thread
     wxThreadError Run();

+        // unblock the thread allowing it to run
+    void SignalRun() { m_semRun.Post(); }

         // ask the thread to terminate
     void Wait();
         // ask the thread to terminate
     void Wait();

-        // wake up threads waiting for our termination
-    void SignalExit();
-        // wake up threads waiting for our start
-    void SignalRun() { m_semRun.Post(); }

         // go to sleep until Resume() is called
     void Pause();
         // resume the thread
         // go to sleep until Resume() is called
     void Pause();
         // resume the thread


@@ -728,12 +720,28 @@ public:
     void SetPriority(int prio) { m_prio = prio; }
         // state
     wxThreadState GetState() const { return m_state; }
     void SetPriority(int prio) { m_prio = prio; }
         // state
     wxThreadState GetState() const { return m_state; }

-    void SetState(wxThreadState state) { m_state = state; }
+    void SetState(wxThreadState state)
+    {
+#if wxUSE_LOG_TRACE
+        static const wxChar *const stateNames[] =
+        {
+            wxT("NEW"),
+            wxT("RUNNING"),
+            wxT("PAUSED"),
+            wxT("EXITED"),
+        };
+
+        wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."),
+                   THR_ID(this), stateNames[m_state], stateNames[state]);
+#endif // wxUSE_LOG_TRACE
+
+        m_state = state;
+    }

         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // "cancelled" flag
         // id
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // "cancelled" flag

-    void SetCancelFlag() { m_cancelled = TRUE; }
+    void SetCancelFlag() { m_cancelled = true; }

     bool WasCancelled() const { return m_cancelled; }
         // exit code
     void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
     bool WasCancelled() const { return m_cancelled; }
         // exit code
     void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }


@@ -746,22 +754,21 @@ public:
         // tell the thread that it is a detached one
     void Detach()
     {
         // tell the thread that it is a detached one
     void Detach()
     {

-        m_shouldBeJoined = m_shouldBroadcast = FALSE;
-        m_isDetached = TRUE;
+        wxCriticalSectionLocker lock(m_csJoinFlag);
+
+        m_shouldBeJoined = false;
+        m_isDetached = true;

     }
     }

-        // but even detached threads need to notifyus about their termination
-        // sometimes - tell the thread that it should do it
-    void Notify() { m_shouldBroadcast = TRUE; }

 
 

-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP

     // this is used by wxPthreadCleanup() only
     static void Cleanup(wxThread *thread);
     // this is used by wxPthreadCleanup() only
     static void Cleanup(wxThread *thread);

-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP

 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum
 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum

-    int           m_prio;       // in wxWindows units: from 0 to 100
+    int           m_prio;       // in wxWidgets units: from 0 to 100

 
     // this flag is set when the thread should terminate
     bool m_cancelled;
 
     // this flag is set when the thread should terminate
     bool m_cancelled;


@@ -777,7 +784,6 @@ private:
     // pthread_join(), so we have to keep track of this
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;
     // pthread_join(), so we have to keep track of this
     wxCriticalSection m_csJoinFlag;
     bool m_shouldBeJoined;

-    bool m_shouldBroadcast;

     bool m_isDetached;
 
     // this semaphore is posted by Run() and the threads Entry() is not
     bool m_isDetached;
 
     // this semaphore is posted by Run() and the threads Entry() is not


@@ -787,11 +793,6 @@ private:
     // this one is signaled when the thread should resume after having been
     // Pause()d
     wxSemaphore m_semSuspend;
     // this one is signaled when the thread should resume after having been
     // Pause()d
     wxSemaphore m_semSuspend;

-
-    // finally this one is signalled when the thread exits
-    // we are using a reference counted condition to support
-    // Delete() for a detached thread
-    wxRefCountedCondition *m_condEnd;

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -807,7 +808,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
     wxThreadInternal *pthread = thread->m_internal;
 
 {
     wxThreadInternal *pthread = thread->m_internal;
 

-    wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
+    wxLogTrace(TRACE_THREADS, wxT("Thread %p started."), THR_ID(pthread));

 
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
 
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work


@@ -823,11 +824,11 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     // block!
     bool dontRunAtAll;
 
     // block!
     bool dontRunAtAll;
 

-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP

     // install the cleanup handler which will be called if the thread is
     // cancelled
     pthread_cleanup_push(wxPthreadCleanup, thread);
     // install the cleanup handler which will be called if the thread is
     // cancelled
     pthread_cleanup_push(wxPthreadCleanup, thread);

-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP

 
     // wait for the semaphore to be posted from Run()
     pthread->m_semRun.Wait();
 
     // wait for the semaphore to be posted from Run()
     pthread->m_semRun.Wait();


@@ -844,17 +845,23 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     if ( !dontRunAtAll )
     {
         // call the main entry
     if ( !dontRunAtAll )
     {
         // call the main entry

-        pthread->m_exitcode = thread->Entry();
+        wxLogTrace(TRACE_THREADS,
+                   wxT("Thread %p about to enter its Entry()."),
+                   THR_ID(pthread));
+
+        wxTRY
+        {
+            pthread->m_exitcode = thread->Entry();

 
 

-        wxLogTrace(TRACE_THREADS, _T("Thread %ld left its Entry()."),
-                   pthread->GetId());
+            wxLogTrace(TRACE_THREADS,
+                       wxT("Thread %p Entry() returned %lu."),
+                       THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+        }
+        wxCATCH_ALL( wxTheApp->OnUnhandledException(); )

 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 
 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 

-            wxLogTrace(TRACE_THREADS, _T("Thread %ld changes state to EXITED."),
-                       pthread->GetId());
-

             // change the state of the thread to "exited" so that
             // wxPthreadCleanup handler won't do anything from now (if it's
             // called before we do pthread_cleanup_pop below)
             // change the state of the thread to "exited" so that
             // wxPthreadCleanup handler won't do anything from now (if it's
             // called before we do pthread_cleanup_pop below)


@@ -862,16 +869,26 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
         }
     }
 
         }
     }
 

-    // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop
-    //     contains the matching '}' for the '{' in push, so they must be used
-    //     in the same block!
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
+    //     '}' for the '{' in push, so they must be used in the same block!
+#ifdef wxHAVE_PTHREAD_CLEANUP
+    #ifdef __DECCXX
+        // under Tru64 we get a warning from macro expansion
+        #pragma message save
+        #pragma message disable(declbutnotref)
+    #endif
+

     // remove the cleanup handler without executing it
     pthread_cleanup_pop(FALSE);
     // remove the cleanup handler without executing it
     pthread_cleanup_pop(FALSE);

-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+
+    #ifdef __DECCXX
+        #pragma message restore
+    #endif
+#endif // wxHAVE_PTHREAD_CLEANUP

 
     if ( dontRunAtAll )
     {
 
     if ( dontRunAtAll )
     {

+        // FIXME: deleting a possibly joinable thread here???

         delete thread;
 
         return EXITCODE_CANCELLED;
         delete thread;
 
         return EXITCODE_CANCELLED;


@@ -887,7 +904,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     }
 }
 
     }
 }
 

-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP

 
 // this handler is called when the thread is cancelled
 extern "C" void wxPthreadCleanup(void *ptr)
 
 // this handler is called when the thread is cancelled
 extern "C" void wxPthreadCleanup(void *ptr)


@@ -897,6 +914,7 @@ extern "C" void wxPthreadCleanup(void *ptr)
 
 void wxThreadInternal::Cleanup(wxThread *thread)
 {
 
 void wxThreadInternal::Cleanup(wxThread *thread)
 {

+    if (pthread_getspecific(gs_keySelf) == 0) return;

     {
         wxCriticalSectionLocker lock(thread->m_critsect);
         if ( thread->m_internal->GetState() == STATE_EXITED )
     {
         wxCriticalSectionLocker lock(thread->m_critsect);
         if ( thread->m_internal->GetState() == STATE_EXITED )


@@ -910,7 +928,7 @@ void wxThreadInternal::Cleanup(wxThread *thread)
     thread->Exit(EXITCODE_CANCELLED);
 }
 
     thread->Exit(EXITCODE_CANCELLED);
 }
 

-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP

 
 // ----------------------------------------------------------------------------
 // wxThreadInternal
 
 // ----------------------------------------------------------------------------
 // wxThreadInternal


@@ -919,25 +937,21 @@ void wxThreadInternal::Cleanup(wxThread *thread)
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;

-    m_cancelled = FALSE;
+    m_cancelled = false;

     m_prio = WXTHREAD_DEFAULT_PRIORITY;
     m_threadId = 0;
     m_exitcode = 0;
 
     m_prio = WXTHREAD_DEFAULT_PRIORITY;
     m_threadId = 0;
     m_exitcode = 0;
 

-    // set to TRUE only when the thread starts waiting on m_semSuspend
-    m_isPaused = FALSE;
+    // set to true only when the thread starts waiting on m_semSuspend
+    m_isPaused = false;

 
     // defaults for joinable threads
 
     // defaults for joinable threads

-    m_shouldBeJoined = TRUE;
-    m_shouldBroadcast = TRUE;
-    m_isDetached = FALSE;
-
-    m_condEnd = new wxRefCountedCondition();
+    m_shouldBeJoined = true;
+    m_isDetached = false;

 }
 
 wxThreadInternal::~wxThreadInternal()
 {
 }
 
 wxThreadInternal::~wxThreadInternal()
 {

-    m_condEnd->DeleteRef();

 }
 
 wxThreadError wxThreadInternal::Run()
 }
 
 wxThreadError wxThreadInternal::Run()


@@ -945,46 +959,40 @@ wxThreadError wxThreadInternal::Run()
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
                  wxT("thread may only be started once after Create()") );
 
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
                  wxT("thread may only be started once after Create()") );
 

-    SignalRun();
-

     SetState(STATE_RUNNING);
 
     SetState(STATE_RUNNING);
 

+    // wake up threads waiting for our start
+    SignalRun();
+

     return wxTHREAD_NO_ERROR;
 }
 
 void wxThreadInternal::Wait()
 {
     return wxTHREAD_NO_ERROR;
 }
 
 void wxThreadInternal::Wait()
 {

+    wxCHECK_RET( !m_isDetached, wxT("can't wait for a detached thread") );
+

     // if the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily
     if ( wxThread::IsMain() )
     // if the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily
     if ( wxThread::IsMain() )

+    {
+#ifdef __WXOSX__
+        // give the thread we're waiting for chance to do the GUI call
+        // it might be in, we don't do this conditionally as the to be waited on
+        // thread might have to acquire the mutex later but before terminating
+        if ( wxGuiOwnedByMainThread() )
+            wxMutexGuiLeave();
+#else

         wxMutexGuiLeave();
         wxMutexGuiLeave();

-
-    bool isDetached = m_isDetached;
-    wxThreadIdType id = (wxThreadIdType) GetId();
+#endif
+    }

 
     wxLogTrace(TRACE_THREADS,
 
     wxLogTrace(TRACE_THREADS,

-               _T("Starting to wait for thread %ld to exit."), id);
-
-    // wait until the thread terminates (we're blocking in _another_ thread,
-    // of course)
+               wxT("Starting to wait for thread %p to exit."),
+               THR_ID(this));

 
 

-    // a reference counting condition is used to handle the
-    // case where a detached thread deletes itself
-    // before m_condEnd->Wait() returns
-    // in this case the deletion of the condition object is deferred until
-    // all Wait()ing threads have finished calling DeleteRef()
-    m_condEnd->AddRef();
-    m_condEnd->Wait();
-    m_condEnd->DeleteRef();
-
-    wxLogTrace(TRACE_THREADS, _T("Finished waiting for thread %ld."), id);
-
-    // we can't use any member variables any more if the thread is detached
-    // because it could be already deleted
-    if ( !isDetached )
+    // to avoid memory leaks we should call pthread_join(), but it must only be
+    // done once so use a critical section to serialize the code below

     {
     {

-        // to avoid memory leaks we should call pthread_join(), but it must
-        // only be done once

         wxCriticalSectionLocker lock(m_csJoinFlag);
 
         if ( m_shouldBeJoined )
         wxCriticalSectionLocker lock(m_csJoinFlag);
 
         if ( m_shouldBeJoined )


@@ -993,35 +1001,24 @@ void wxThreadInternal::Wait()
             //       we're cancelled inside pthread_join(), things will almost
             //       certainly break - but if we disable the cancellation, we
             //       might deadlock
             //       we're cancelled inside pthread_join(), things will almost
             //       certainly break - but if we disable the cancellation, we
             //       might deadlock

-            if ( pthread_join((pthread_t)id, &m_exitcode) != 0 )
+            if ( pthread_join(GetId(), &m_exitcode) != 0 )

             {
             {

-                wxLogError(_("Failed to join a thread, potential memory leak "
-                             "detected - please restart the program"));
+                // this is a serious problem, so use wxLogError and not
+                // wxLogDebug: it is possible to bring the system to its knees
+                // by creating too many threads and not joining them quite
+                // easily
+                wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));

             }
 
             }
 

-            m_shouldBeJoined = FALSE;
+            m_shouldBeJoined = false;

         }
     }
 
         }
     }
 

+#ifndef __WXOSX__

     // reacquire GUI mutex
     if ( wxThread::IsMain() )
         wxMutexGuiEnter();
     // reacquire GUI mutex
     if ( wxThread::IsMain() )
         wxMutexGuiEnter();

-}
-
-void wxThreadInternal::SignalExit()
-{
-    wxLogTrace(TRACE_THREADS, _T("Thread %ld about to exit."), GetId());
-
-    SetState(STATE_EXITED);
-
-    // wake up all the threads waiting for our termination - if there are any
-    if ( m_shouldBroadcast )
-    {
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
-                   GetId());
-
-        m_condEnd->SetSignaled();
-    }
+#endif

 }
 
 void wxThreadInternal::Pause()
 }
 
 void wxThreadInternal::Pause()


@@ -1031,7 +1028,8 @@ void wxThreadInternal::Pause()
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("thread must first be paused with wxThread::Pause().") );
 
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("thread must first be paused with wxThread::Pause().") );
 

-    wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
+   wxLogTrace(TRACE_THREADS,
+              wxT("Thread %p goes to sleep."), THR_ID(this));

 
     // wait until the semaphore is Post()ed from Resume()
     m_semSuspend.Wait();
 
     // wait until the semaphore is Post()ed from Resume()
     m_semSuspend.Wait();


@@ -1046,18 +1044,19 @@ void wxThreadInternal::Resume()
     // TestDestroy() since the last call to Pause() for example
     if ( IsReallyPaused() )
     {
     // TestDestroy() since the last call to Pause() for example
     if ( IsReallyPaused() )
     {

-        wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
+       wxLogTrace(TRACE_THREADS,
+                  wxT("Waking up thread %p"), THR_ID(this));

 
         // wake up Pause()
         m_semSuspend.Post();
 
         // reset the flag
 
         // wake up Pause()
         m_semSuspend.Post();
 
         // reset the flag

-        SetReallyPaused(FALSE);
+        SetReallyPaused(false);

     }
     else
     {
     }
     else
     {

-        wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
-                   GetId());
+        wxLogTrace(TRACE_THREADS,
+                   wxT("Thread %p is not yet really paused"), THR_ID(this));

     }
 
     SetState(STATE_RUNNING);
     }
 
     SetState(STATE_RUNNING);


@@ -1072,11 +1071,6 @@ wxThread *wxThread::This()
     return (wxThread *)pthread_getspecific(gs_keySelf);
 }
 
     return (wxThread *)pthread_getspecific(gs_keySelf);
 }
 

-bool wxThread::IsMain()
-{
-    return (bool)pthread_equal(pthread_self(), gs_tidMain);
-}
-

 void wxThread::Yield()
 {
 #ifdef HAVE_SCHED_YIELD
 void wxThread::Yield()
 {
 #ifdef HAVE_SCHED_YIELD


@@ -1084,72 +1078,60 @@ void wxThread::Yield()
 #endif
 }
 
 #endif
 }
 

-void wxThread::Sleep(unsigned long milliseconds)
-{
-    wxUsleep(milliseconds);
-}
-

 int wxThread::GetCPUCount()
 {
 int wxThread::GetCPUCount()
 {

-#if defined(__LINUX__) && wxUSE_FFILE
+#if defined(_SC_NPROCESSORS_ONLN)
+    // this works for Solaris and Linux 2.6
+    int rc = sysconf(_SC_NPROCESSORS_ONLN);
+    if ( rc != -1 )
+    {
+        return rc;
+    }
+#elif defined(__LINUX__) && wxUSE_FFILE

     // read from proc (can't use wxTextFile here because it's a special file:
     // it has 0 size but still can be read from)
     wxLogNull nolog;
 
     // read from proc (can't use wxTextFile here because it's a special file:
     // it has 0 size but still can be read from)
     wxLogNull nolog;
 

-    wxFFile file(_T("/proc/cpuinfo"));
+    wxFFile file(wxT("/proc/cpuinfo"));

     if ( file.IsOpened() )
     {
         // slurp the whole file
         wxString s;
         if ( file.ReadAll(&s) )
         {
     if ( file.IsOpened() )
     {
         // slurp the whole file
         wxString s;
         if ( file.ReadAll(&s) )
         {

-            // (ab)use Replace() to find the number of "processor" strings
-            size_t count = s.Replace(_T("processor"), _T(""));
+            // (ab)use Replace() to find the number of "processor: num" strings
+            size_t count = s.Replace(wxT("processor\t:"), wxT(""));

             if ( count > 0 )
             {
                 return count;
             }
 
             if ( count > 0 )
             {
                 return count;
             }
 

-            wxLogDebug(_T("failed to parse /proc/cpuinfo"));
+            wxLogDebug(wxT("failed to parse /proc/cpuinfo"));

         }
         else
         {
         }
         else
         {

-            wxLogDebug(_T("failed to read /proc/cpuinfo"));
+            wxLogDebug(wxT("failed to read /proc/cpuinfo"));

         }
     }
         }
     }

-#elif defined(_SC_NPROCESSORS_ONLN)
-    // this works for Solaris
-    int rc = sysconf(_SC_NPROCESSORS_ONLN);
-    if ( rc != -1 )
-    {
-        return rc;
-    }

 #endif // different ways to get number of CPUs
 
     // unknown
     return -1;
 }
 
 #endif // different ways to get number of CPUs
 
     // unknown
     return -1;
 }
 

-#ifdef __VMS
-  // VMS is a 64 bit system and threads have 64 bit pointers.
-  // ??? also needed for other systems????
-unsigned long long wxThread::GetCurrentId()
+wxThreadIdType wxThread::GetCurrentId()

 {
 {

-    return (unsigned long long)pthread_self();
-#else
-unsigned long wxThread::GetCurrentId()
-{
-    return (unsigned long)pthread_self();
-#endif
+    return (wxThreadIdType)pthread_self();

 }
 
 }
 

+

 bool wxThread::SetConcurrency(size_t level)
 {
 #ifdef HAVE_THR_SETCONCURRENCY
     int rc = thr_setconcurrency(level);
     if ( rc != 0 )
     {
 bool wxThread::SetConcurrency(size_t level)
 {
 #ifdef HAVE_THR_SETCONCURRENCY
     int rc = thr_setconcurrency(level);
     if ( rc != 0 )
     {

-        wxLogSysError(rc, _T("thr_setconcurrency() failed"));
+        wxLogSysError(rc, wxT("thr_setconcurrency() failed"));

     }
 
     return rc == 0;
     }
 
     return rc == 0;


@@ -1166,14 +1148,24 @@ bool wxThread::SetConcurrency(size_t level)
 wxThread::wxThread(wxThreadKind kind)
 {
     // add this thread to the global list of all threads
 wxThread::wxThread(wxThreadKind kind)
 {
     // add this thread to the global list of all threads

-    gs_allThreads.Add(this);
+    {
+        wxMutexLocker lock(*gs_mutexAllThreads);
+
+        gs_allThreads.Add(this);
+    }

 
     m_internal = new wxThreadInternal();
 
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 
 
     m_internal = new wxThreadInternal();
 
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 

-wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    #define WXUNUSED_STACKSIZE(identifier)  identifier
+#else
+    #define WXUNUSED_STACKSIZE(identifier)  WXUNUSED(identifier)
+#endif
+
+wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))

 {
     if ( m_internal->GetState() != STATE_NEW )
     {
 {
     if ( m_internal->GetState() != STATE_NEW )
     {


@@ -1185,6 +1177,11 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 

+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    if (stackSize)
+      pthread_attr_setstacksize(&attr, stackSize);
+#endif
+

 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
     int policy;
     if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
     int policy;
     if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )


@@ -1227,14 +1224,14 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
         struct sched_param sp;
         if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
         {
         struct sched_param sp;
         if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
         {

-            wxFAIL_MSG(_T("pthread_attr_getschedparam() failed"));
+            wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed"));

         }
 
         sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
 
         if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
         {
         }
 
         sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
 
         if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
         {

-            wxFAIL_MSG(_T("pthread_attr_setschedparam(priority) failed"));
+            wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));

         }
     }
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
         }
     }
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS


@@ -1243,7 +1240,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
     // this will make the threads created by this process really concurrent
     if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
     {
     // this will make the threads created by this process really concurrent
     if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
     {

-        wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
+        wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));

     }
 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
 
     }
 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
 


@@ -1254,7 +1251,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
     {
         if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
         {
     {
         if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
         {

-            wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed"));
+            wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));

         }
 
         // never try to join detached threads
         }
 
         // never try to join detached threads


@@ -1273,7 +1270,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
 
     if ( pthread_attr_destroy(&attr) != 0 )
     {
 
     if ( pthread_attr_destroy(&attr) != 0 )
     {

-        wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
+        wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));

     }
 
     if ( rc != 0 )
     }
 
     if ( rc != 0 )


@@ -1318,6 +1315,24 @@ void wxThread::SetPriority(unsigned int prio)
         case STATE_RUNNING:
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
         case STATE_RUNNING:
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS

+#if defined(__LINUX__)
+            // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
+            // a priority other than 0.  Instead, we use the BSD setpriority
+            // which alllows us to set a 'nice' value between 20 to -20.  Only
+            // super user can set a value less than zero (more negative yields
+            // higher priority).  setpriority set the static priority of a
+            // process, but this is OK since Linux is configured as a thread
+            // per process.
+            //
+            // FIXME this is not true for 2.6!!
+
+            // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
+            // to Unix priorities 20..-20
+            if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
+            {
+                wxLogError(_("Failed to set thread priority %d."), prio);
+            }
+#else // __LINUX__

             {
                 struct sched_param sparam;
                 sparam.sched_priority = prio;
             {
                 struct sched_param sparam;
                 sparam.sched_priority = prio;


@@ -1328,6 +1343,7 @@ void wxThread::SetPriority(unsigned int prio)
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }

+#endif // __LINUX__

 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
             break;
 
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
             break;
 


@@ -1356,7 +1372,7 @@ wxThreadIdType wxThread::GetId() const
 wxThreadError wxThread::Pause()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 wxThreadError wxThread::Pause()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,

-                 _T("a thread can't pause itself") );
+                 wxT("a thread can't pause itself") );

 
     wxCriticalSectionLocker lock(m_critsect);
 
 
     wxCriticalSectionLocker lock(m_critsect);
 


@@ -1367,9 +1383,6 @@ wxThreadError wxThread::Pause()
         return wxTHREAD_NOT_RUNNING;
     }
 
         return wxTHREAD_NOT_RUNNING;
     }
 

-    wxLogTrace(TRACE_THREADS, _T("Asking thread %ld to pause."),
-               GetId());
-

     // just set a flag, the thread will be really paused only during the next
     // call to TestDestroy()
     m_internal->SetState(STATE_PAUSED);
     // just set a flag, the thread will be really paused only during the next
     // call to TestDestroy()
     m_internal->SetState(STATE_PAUSED);


@@ -1380,7 +1393,7 @@ wxThreadError wxThread::Pause()
 wxThreadError wxThread::Resume()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 wxThreadError wxThread::Resume()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,

-                 _T("a thread can't resume itself") );
+                 wxT("a thread can't resume itself") );

 
     wxCriticalSectionLocker lock(m_critsect);
 
 
     wxCriticalSectionLocker lock(m_critsect);
 


@@ -1389,20 +1402,20 @@ wxThreadError wxThread::Resume()
     switch ( state )
     {
         case STATE_PAUSED:
     switch ( state )
     {
         case STATE_PAUSED:

-            wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
-                       GetId());
+            wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."),
+                       THR_ID(this));

 
             m_internal->Resume();
 
             return wxTHREAD_NO_ERROR;
 
         case STATE_EXITED:
 
             m_internal->Resume();
 
             return wxTHREAD_NO_ERROR;
 
         case STATE_EXITED:

-            wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."),
-                       GetId());
+            wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."),
+                       THR_ID(this));

             return wxTHREAD_NO_ERROR;
 
         default:
             return wxTHREAD_NO_ERROR;
 
         default:

-            wxLogDebug(_T("Attempt to resume a thread which is not paused."));
+            wxLogDebug(wxT("Attempt to resume a thread which is not paused."));

 
             return wxTHREAD_MISC_ERROR;
     }
 
             return wxTHREAD_MISC_ERROR;
     }


@@ -1412,23 +1425,25 @@ wxThreadError wxThread::Resume()
 // exiting thread
 // -----------------------------------------------------------------------------
 
 // exiting thread
 // -----------------------------------------------------------------------------
 

-wxThread::ExitCode wxThread::Wait()
+wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode))

 {
     wxCHECK_MSG( This() != this, (ExitCode)-1,
 {
     wxCHECK_MSG( This() != this, (ExitCode)-1,

-                 _T("a thread can't wait for itself") );
+                 wxT("a thread can't wait for itself") );

 
     wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
 
     wxCHECK_MSG( !m_isDetached, (ExitCode)-1,

-                 _T("can't wait for detached thread") );
+                 wxT("can't wait for detached thread") );

 
     m_internal->Wait();
 
     return m_internal->GetExitCode();
 }
 
 
     m_internal->Wait();
 
     return m_internal->GetExitCode();
 }
 

-wxThreadError wxThread::Delete(ExitCode *rc)
+wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode))

 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,

-                 _T("a thread can't delete itself") );
+                 wxT("a thread can't delete itself") );
+
+    bool isDetached = m_isDetached;

 
     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();
 
     m_critsect.Enter();
     wxThreadState state = m_internal->GetState();


@@ -1436,21 +1451,16 @@ wxThreadError wxThread::Delete(ExitCode *rc)
     // ask the thread to stop
     m_internal->SetCancelFlag();
 
     // ask the thread to stop
     m_internal->SetCancelFlag();
 

-    if ( m_isDetached )
-    {
-        // detached threads won't broadcast about their termination by default
-        // because usually nobody waits for them - but here we do, so ask the
-        // thread to notify us
-        m_internal->Notify();
-    }
-

     m_critsect.Leave();
 
     m_critsect.Leave();
 

+    OnDelete();
+

     switch ( state )
     {
         case STATE_NEW:
             // we need to wake up the thread so that PthreadStart() will
     switch ( state )
     {
         case STATE_NEW:
             // we need to wake up the thread so that PthreadStart() will

-            // terminate - right now it's blocking on m_semRun
+            // terminate - right now it's blocking on run semaphore in
+            // PthreadStart()

             m_internal->SignalRun();
 
             // fall through
             m_internal->SignalRun();
 
             // fall through


@@ -1460,33 +1470,40 @@ wxThreadError wxThread::Delete(ExitCode *rc)
             break;
 
         case STATE_PAUSED:
             break;
 
         case STATE_PAUSED:

-            // resume the thread first (don't call our Resume() because this
-            // would dead lock when it tries to enter m_critsect)
+            // resume the thread first

             m_internal->Resume();
 
             // fall through
 
         default:
             m_internal->Resume();
 
             // fall through
 
         default:

-            // wait until the thread stops
-            m_internal->Wait();
-
-            if ( rc )
+            if ( !isDetached )

             {
             {

-                wxASSERT_MSG( !m_isDetached,
-                              _T("no return code for detached threads") );
+                // wait until the thread stops
+                m_internal->Wait();

 
 

-                // if it's a joinable thread, it's not deleted yet
-                *rc = m_internal->GetExitCode();
+                if ( rc )
+                {
+                    // return the exit code of the thread
+                    *rc = m_internal->GetExitCode();
+                }

             }
             }

+            //else: can't wait for detached threads

     }
 
     }
 

+    if (state == STATE_NEW)
+        return wxTHREAD_MISC_ERROR;
+            // for coherency with the MSW implementation, signal the user that
+            // Delete() was called on a thread which didn't start to run yet.
+

     return wxTHREAD_NO_ERROR;
 }
 
 wxThreadError wxThread::Kill()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
     return wxTHREAD_NO_ERROR;
 }
 
 wxThreadError wxThread::Kill()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,

-                 _T("a thread can't kill itself") );
+                 wxT("a thread can't kill itself") );
+
+    OnKill();

 
     switch ( m_internal->GetState() )
     {
 
     switch ( m_internal->GetState() )
     {


@@ -1503,25 +1520,26 @@ wxThreadError wxThread::Kill()
         default:
 #ifdef HAVE_PTHREAD_CANCEL
             if ( pthread_cancel(m_internal->GetId()) != 0 )
         default:
 #ifdef HAVE_PTHREAD_CANCEL
             if ( pthread_cancel(m_internal->GetId()) != 0 )

-#endif
+#endif // HAVE_PTHREAD_CANCEL

             {
                 wxLogError(_("Failed to terminate a thread."));
 
                 return wxTHREAD_MISC_ERROR;
             }
 
             {
                 wxLogError(_("Failed to terminate a thread."));
 
                 return wxTHREAD_MISC_ERROR;
             }
 

+#ifdef HAVE_PTHREAD_CANCEL

             if ( m_isDetached )
             {
                 // if we use cleanup function, this will be done from
                 // wxPthreadCleanup()
             if ( m_isDetached )
             {
                 // if we use cleanup function, this will be done from
                 // wxPthreadCleanup()

-#if !HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifndef wxHAVE_PTHREAD_CLEANUP

                 ScheduleThreadForDeletion();
 
                 // don't call OnExit() here, it can only be called in the
                 // threads context and we're in the context of another thread
 
                 DeleteThread(this);
                 ScheduleThreadForDeletion();
 
                 // don't call OnExit() here, it can only be called in the
                 // threads context and we're in the context of another thread
 
                 DeleteThread(this);

-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP

             }
             else
             {
             }
             else
             {


@@ -1529,36 +1547,32 @@ wxThreadError wxThread::Kill()
             }
 
             return wxTHREAD_NO_ERROR;
             }
 
             return wxTHREAD_NO_ERROR;

+#endif // HAVE_PTHREAD_CANCEL

     }
 }
 
 void wxThread::Exit(ExitCode status)
 {
     wxASSERT_MSG( This() == this,
     }
 }
 
 void wxThread::Exit(ExitCode status)
 {
     wxASSERT_MSG( This() == this,

-                  _T("wxThread::Exit() can only be called in the "
-                     "context of the same thread") );
+                  wxT("wxThread::Exit() can only be called in the context of the same thread") );

 
 

-    // from the moment we call OnExit(), the main program may terminate at any
-    // moment, so mark this thread as being already in process of being
-    // deleted or wxThreadModule::OnExit() will try to delete it again
-    ScheduleThreadForDeletion();
+    if ( m_isDetached )
+    {
+        // from the moment we call OnExit(), the main program may terminate at
+        // any moment, so mark this thread as being already in process of being
+        // deleted or wxThreadModule::OnExit() will try to delete it again
+        ScheduleThreadForDeletion();
+    }

 
     // don't enter m_critsect before calling OnExit() because the user code
     // might deadlock if, for example, it signals a condition in OnExit() (a
     // common case) while the main thread calls any of functions entering
     // m_critsect on us (almost all of them do)
 
     // don't enter m_critsect before calling OnExit() because the user code
     // might deadlock if, for example, it signals a condition in OnExit() (a
     // common case) while the main thread calls any of functions entering
     // m_critsect on us (almost all of them do)

-    OnExit();
-
-    // now do enter it because SignalExit() will change our state
-    m_critsect.Enter();
-
-    // next wake up the threads waiting for us (OTOH, this function won't return
-    // until someone waited for us!)
-    m_internal->SignalExit();
-
-    // leave the critical section before entering the dtor which tries to
-    // enter it
-    m_critsect.Leave();
+    wxTRY
+    {
+        OnExit();
+    }
+    wxCATCH_ALL( wxTheApp->OnUnhandledException(); )

 
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
 
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones


@@ -1571,26 +1585,32 @@ void wxThread::Exit(ExitCode status)
         //       we make it a global object, but this would mean that we can
         //       only call one thread function at a time :-(
         DeleteThread(this);
         //       we make it a global object, but this would mean that we can
         //       only call one thread function at a time :-(
         DeleteThread(this);

+        pthread_setspecific(gs_keySelf, 0);
+    }
+    else
+    {
+        m_critsect.Enter();
+        m_internal->SetState(STATE_EXITED);
+        m_critsect.Leave();

     }
 
     // terminate the thread (pthread_exit() never returns)
     pthread_exit(status);
 
     }
 
     // terminate the thread (pthread_exit() never returns)
     pthread_exit(status);
 

-    wxFAIL_MSG(_T("pthread_exit() failed"));
+    wxFAIL_MSG(wxT("pthread_exit() failed"));

 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
     wxASSERT_MSG( This() == this,
 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
     wxASSERT_MSG( This() == this,

-                  _T("wxThread::TestDestroy() can only be called in the "
-                     "context of the same thread") );
+                  wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );

 
     m_critsect.Enter();
 
     if ( m_internal->GetState() == STATE_PAUSED )
     {
 
     m_critsect.Enter();
 
     if ( m_internal->GetState() == STATE_PAUSED )
     {

-        m_internal->SetReallyPaused(TRUE);
+        m_internal->SetReallyPaused(true);

 
         // leave the crit section or the other threads will stop too if they
         // try to call any of (seemingly harmless) IsXXX() functions while we
 
         // leave the crit section or the other threads will stop too if they
         // try to call any of (seemingly harmless) IsXXX() functions while we


@@ -1610,35 +1630,25 @@ bool wxThread::TestDestroy()
 
 wxThread::~wxThread()
 {
 
 wxThread::~wxThread()
 {

-#ifdef __WXDEBUG__

     m_critsect.Enter();
 
     // check that the thread either exited or couldn't be created
     if ( m_internal->GetState() != STATE_EXITED &&
          m_internal->GetState() != STATE_NEW )
     {
     m_critsect.Enter();
 
     // check that the thread either exited or couldn't be created
     if ( m_internal->GetState() != STATE_EXITED &&
          m_internal->GetState() != STATE_NEW )
     {

-        wxLogDebug(_T("The thread %ld is being destroyed although it is still "
-                      "running! The application may crash."), GetId());
+        wxLogDebug(wxT("The thread %p is being destroyed although it is still running! The application may crash."),
+                   THR_ID(this));

     }
 
     m_critsect.Leave();
     }
 
     m_critsect.Leave();

-#endif // __WXDEBUG__

 
     delete m_internal;
 
     // remove this thread from the global array
 
     delete m_internal;
 
     // remove this thread from the global array

-    gs_allThreads.Remove(this);
-
-    // detached thread will decrement this counter in DeleteThread(), but it
-    // is not called for the joinable threads, so do it here
-    if ( !m_isDetached )

     {
     {

-        wxMutexLocker lock( *gs_mutexDeleteThread );
-
-        gs_nThreadsBeingDeleted--;
+        wxMutexLocker lock(*gs_mutexAllThreads);

 
 

-        wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
-                   gs_nThreadsBeingDeleted - 1);
+        gs_allThreads.Remove(this);

     }
 }
 
     }
 }
 


@@ -1661,10 +1671,10 @@ bool wxThread::IsAlive() const
     {
         case STATE_RUNNING:
         case STATE_PAUSED:
     {
         case STATE_RUNNING:
         case STATE_PAUSED:

-            return TRUE;
+            return true;

 
         default:
 
         default:

-            return FALSE;
+            return false;

     }
 }
 
     }
 }
 


@@ -1679,6 +1689,11 @@ bool wxThread::IsPaused() const
 // wxThreadModule
 //--------------------------------------------------------------------
 
 // wxThreadModule
 //--------------------------------------------------------------------
 

+#ifdef __WXOSX__
+void wxOSXThreadModuleOnInit();
+void wxOSXThreadModuleOnExit();
+#endif
+

 class wxThreadModule : public wxModule
 {
 public:
 class wxThreadModule : public wxModule
 {
 public:


@@ -1696,24 +1711,26 @@ bool wxThreadModule::OnInit()
     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
     if ( rc != 0 )
     {
     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
     if ( rc != 0 )
     {

-        wxLogSysError(rc, _("Thread module initialization failed: "
-                            "failed to create thread key"));
+        wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));

 
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    gs_tidMain = pthread_self();
+    wxThread::ms_idMainThread = wxThread::GetCurrentId();

 
 

-#if wxUSE_GUI
-    gs_mutexGui = new wxMutex();
+    gs_mutexAllThreads = new wxMutex();

 
 

+#ifdef __WXOSX__
+    wxOSXThreadModuleOnInit();
+#else
+    gs_mutexGui = new wxMutex();

     gs_mutexGui->Lock();
     gs_mutexGui->Lock();

-#endif // wxUSE_GUI
+#endif

 
     gs_mutexDeleteThread = new wxMutex();
 
     gs_mutexDeleteThread = new wxMutex();

-    gs_condAllDeleted = new wxCondition( gs_mutexDeleteThread );
+    gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);

 
 

-    return TRUE;
+    return true;

 }
 
 void wxThreadModule::OnExit()
 }
 
 void wxThreadModule::OnExit()


@@ -1728,22 +1745,29 @@ void wxThreadModule::OnExit()
         nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
 
         if ( nThreadsBeingDeleted > 0 )
         nThreadsBeingDeleted = gs_nThreadsBeingDeleted;
 
         if ( nThreadsBeingDeleted > 0 )

-{
-            wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
-                           nThreadsBeingDeleted);
+        {
+            wxLogTrace(TRACE_THREADS,
+                       wxT("Waiting for %lu threads to disappear"),
+                       (unsigned long)nThreadsBeingDeleted);

 
             // have to wait until all of them disappear
             gs_condAllDeleted->Wait();
         }
     }
 
 
             // have to wait until all of them disappear
             gs_condAllDeleted->Wait();
         }
     }
 

-    // terminate any threads left
-    size_t count = gs_allThreads.GetCount();
-    if ( count != 0u )
+    size_t count;
+

     {
     {

-        wxLogDebug(wxT("%u threads were not terminated by the application."),
-                   count);
-    }
+        wxMutexLocker lock(*gs_mutexAllThreads);
+
+        // terminate any threads left
+        count = gs_allThreads.GetCount();
+        if ( count != 0u )
+        {
+            wxLogDebug(wxT("%lu threads were not terminated by the application."),
+                       (unsigned long)count);
+        }
+    } // unlock mutex before deleting the threads as they lock it in their dtor

 
     for ( size_t n = 0u; n < count; n++ )
     {
 
     for ( size_t n = 0u; n < count; n++ )
     {


@@ -1752,12 +1776,15 @@ void wxThreadModule::OnExit()
         gs_allThreads[0]->Delete();
     }
 
         gs_allThreads[0]->Delete();
     }
 

-#if wxUSE_GUI
+    delete gs_mutexAllThreads;
+
+#ifdef __WXOSX__
+    wxOSXThreadModuleOnExit();
+#else

     // destroy GUI mutex
     gs_mutexGui->Unlock();
     // destroy GUI mutex
     gs_mutexGui->Unlock();

-

     delete gs_mutexGui;
     delete gs_mutexGui;

-#endif // wxUSE_GUI
+#endif

 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);


@@ -1776,27 +1803,27 @@ static void ScheduleThreadForDeletion()
 
     gs_nThreadsBeingDeleted++;
 
 
     gs_nThreadsBeingDeleted++;
 

-    wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
-               gs_nThreadsBeingDeleted,
-               gs_nThreadsBeingDeleted == 1 ? "" : "s");
+    wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"),
+               (unsigned long)gs_nThreadsBeingDeleted,
+               gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s"));

 }
 
 static void DeleteThread(wxThread *This)
 {
 }
 
 static void DeleteThread(wxThread *This)
 {

-    // gs_mutexDeleteThread should be unlocked before signalling the condition
-    // or wxThreadModule::OnExit() would deadlock
-    wxMutexLocker locker( *gs_mutexDeleteThread );
-
-    wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
+    wxLogTrace(TRACE_THREADS, wxT("Thread %p auto deletes."), THR_ID(This));

 
     delete This;
 
 
     delete This;
 

+    // only lock gs_mutexDeleteThread after deleting the thread to avoid
+    // calling out into user code with it locked as this may result in
+    // deadlocks if the thread dtor deletes another thread (see #11501)
+    wxMutexLocker locker( *gs_mutexDeleteThread );
+

     wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
     wxCHECK_RET( gs_nThreadsBeingDeleted > 0,

-                     _T("no threads scheduled for deletion, yet we delete "
-                        "one?") );
+                 wxT("no threads scheduled for deletion, yet we delete one?") );

 
 

-    wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
-               gs_nThreadsBeingDeleted - 1);
+    wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."),
+               (unsigned long)gs_nThreadsBeingDeleted - 1);

 
     if ( !--gs_nThreadsBeingDeleted )
     {
 
     if ( !--gs_nThreadsBeingDeleted )
     {


@@ -1805,19 +1832,24 @@ static void DeleteThread(wxThread *This)
     }
 }
 
     }
 }
 

-void wxMutexGuiEnter()
+#ifndef __WXOSX__
+
+void wxMutexGuiEnterImpl()

 {
 {

-#if wxUSE_GUI

     gs_mutexGui->Lock();
     gs_mutexGui->Lock();

-#endif // wxUSE_GUI

 }
 
 }
 

-void wxMutexGuiLeave()
+void wxMutexGuiLeaveImpl()

 {
 {

-#if wxUSE_GUI

     gs_mutexGui->Unlock();
     gs_mutexGui->Unlock();

-#endif // wxUSE_GUI

 }
 
 #endif
 }
 
 #endif

-  // wxUSE_THREADS
+
+// ----------------------------------------------------------------------------
+// include common implementation code
+// ----------------------------------------------------------------------------
+
+#include "wx/thrimpl.cpp"
+
+#endif // wxUSE_THREADS