Changed SetToolBar() to behave a bit smarter. Untested.

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

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 3a7c4695b9e47af1ee38cd496262d9f06beca6c3..8fc3c664e1dde6b5a573205f46bcf5b64ae10845 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -24,12 +24,13 @@
     #pragma implementation "thread.h"
 #endif
 
     #pragma implementation "thread.h"
 #endif
 

-#include "wx/thread.h"
+// With simple makefiles, we must ignore the file body if not using
+// threads.
+#include "wx/setup.h"

 
 

-#if !wxUSE_THREADS
-    #error This file needs wxUSE_THREADS
-#endif
+#if wxUSE_THREADS

 
 

+#include "wx/thread.h"

 #include "wx/module.h"
 #include "wx/utils.h"
 #include "wx/log.h"
 #include "wx/module.h"
 #include "wx/utils.h"
 #include "wx/log.h"


@@ -42,7 +43,7 @@
 #include <errno.h>
 #include <time.h>
 
 #include <errno.h>
 #include <time.h>
 

-#ifdef HAVE_SCHED_H
+#if HAVE_SCHED_H

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


@@ -50,15 +51,19 @@
 // constants
 // ----------------------------------------------------------------------------
 
 // constants
 // ----------------------------------------------------------------------------
 

-enum thread_state
+// the possible states of the thread and transitions from them
+enum wxThreadState

 {
     STATE_NEW,          // didn't start execution yet (=> RUNNING)
 {
     STATE_NEW,          // didn't start execution yet (=> RUNNING)

-    STATE_RUNNING,
-    STATE_PAUSED,
-    STATE_CANCELED,
-    STATE_EXITED
+    STATE_RUNNING,      // running (=> PAUSED or EXITED)
+    STATE_PAUSED,       // suspended (=> RUNNING or EXITED)
+    STATE_EXITED        // thread doesn't exist any more

 };
 
 };
 

+// ----------------------------------------------------------------------------
+// types
+// ----------------------------------------------------------------------------
+

 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 
 // -----------------------------------------------------------------------------
 WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 
 // -----------------------------------------------------------------------------


@@ -96,6 +101,7 @@ public:
 wxMutex::wxMutex()
 {
     p_internal = new wxMutexInternal;
 wxMutex::wxMutex()
 {
     p_internal = new wxMutexInternal;

+    

     pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
     m_locked = 0;
 }
     pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
     m_locked = 0;
 }


@@ -103,7 +109,7 @@ wxMutex::wxMutex()
 wxMutex::~wxMutex()
 {
     if (m_locked > 0)
 wxMutex::~wxMutex()
 {
     if (m_locked > 0)

-        wxLogDebug("Freeing a locked mutex (%d locks)", m_locked);
+        wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);

 
     pthread_mutex_destroy( &(p_internal->p_mutex) );
     delete p_internal;
 
     pthread_mutex_destroy( &(p_internal->p_mutex) );
     delete p_internal;


@@ -114,7 +120,7 @@ wxMutexError wxMutex::Lock()
     int err = pthread_mutex_lock( &(p_internal->p_mutex) );
     if (err == EDEADLK)
     {
     int err = pthread_mutex_lock( &(p_internal->p_mutex) );
     if (err == EDEADLK)
     {

-        wxLogDebug("Locking this mutex would lead to deadlock!");
+        wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));

 
         return wxMUTEX_DEAD_LOCK;
     }
 
         return wxMUTEX_DEAD_LOCK;
     }


@@ -150,7 +156,7 @@ wxMutexError wxMutex::Unlock()
     }
     else
     {
     }
     else
     {

-        wxLogDebug("Unlocking not locked mutex.");
+        wxLogDebug(wxT("Unlocking not locked mutex."));

 
         return wxMUTEX_UNLOCKED;
     }
 
         return wxMUTEX_UNLOCKED;
     }


@@ -220,11 +226,16 @@ public:
     // thread entry function
     static void *PthreadStart(void *ptr);
 
     // thread entry function
     static void *PthreadStart(void *ptr);
 

+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // thread exit function
+    static void PthreadCleanup(void *ptr);
+#endif
+

     // thread actions
         // start the thread
     wxThreadError Run();
         // ask the thread to terminate
     // thread actions
         // start the thread
     wxThreadError Run();
         // ask the thread to terminate

-    void Cancel();
+    void Wait();

         // wake up threads waiting for our termination
     void SignalExit();
         // go to sleep until Resume() is called
         // wake up threads waiting for our termination
     void SignalExit();
         // go to sleep until Resume() is called


@@ -237,19 +248,19 @@ public:
     int GetPriority() const { return m_prio; }
     void SetPriority(int prio) { m_prio = prio; }
         // state
     int GetPriority() const { return m_prio; }
     void SetPriority(int prio) { m_prio = prio; }
         // state

-    thread_state GetState() const { return m_state; }
-    void SetState(thread_state state) { m_state = state; }
+    wxThreadState GetState() const { return m_state; }
+    void SetState(wxThreadState state) { m_state = state; }

         // id
         // id

-    pthread_t GetId() const { return thread_id; }
+    pthread_t GetId() const { return m_threadId; }
+    pthread_t *GetIdPtr() { return &m_threadId; }

         // "cancelled" flag
         // "cancelled" flag

+    void SetCancelFlag() { m_cancelled = TRUE; }

     bool WasCancelled() const { return m_cancelled; }
 
     bool WasCancelled() const { return m_cancelled; }
 

-//private: -- should be!
-    pthread_t thread_id;
-

 private:
 private:

-    thread_state m_state;    // see thread_state enum
-    int          m_prio;     // in wxWindows units: from 0 to 100
+    pthread_t     m_threadId;   // id of the thread
+    wxThreadState m_state;      // see wxThreadState enum
+    int           m_prio;       // in wxWindows units: from 0 to 100

 
     // set when the thread should terminate
     bool m_cancelled;
 
     // set when the thread should terminate
     bool m_cancelled;


@@ -257,11 +268,13 @@ private:
     // this (mutex, cond) pair is used to synchronize the main thread and this
     // thread in several situations:
     //  1. The thread function blocks until condition is signaled by Run() when
     // this (mutex, cond) pair is used to synchronize the main thread and this
     // thread in several situations:
     //  1. The thread function blocks until condition is signaled by Run() when

-    //     it's initially created - this allows create thread in "suspended"
+    //     it's initially created - this allows thread creation in "suspended"

     //     state
     //  2. The Delete() function blocks until the condition is signaled when the
     //     thread exits.
     //     state
     //  2. The Delete() function blocks until the condition is signaled when the
     //     thread exits.

-    wxMutex     m_mutex;
+    // GL: On Linux, this may fail because we can have a deadlock in either
+    //     SignalExit() or Wait(): so we add m_end_mutex for the finalization.
+    wxMutex     m_mutex, m_end_mutex;

     wxCondition m_cond;
 
     // another (mutex, cond) pair for Pause()/Resume() usage
     wxCondition m_cond;
 
     // another (mutex, cond) pair for Pause()/Resume() usage


@@ -278,39 +291,77 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 {
     wxThread *thread = (wxThread *)ptr;
     wxThreadInternal *pthread = thread->p_internal;
 {
     wxThread *thread = (wxThread *)ptr;
     wxThreadInternal *pthread = thread->p_internal;

+    void *status;

 
 

-    if ( pthread_setspecific(gs_keySelf, thread) != 0 )
+    int rc = pthread_setspecific(gs_keySelf, thread);
+    if ( rc != 0 )

     {
     {

-        wxLogError(_("Can not start thread: error writing TLS."));
+        wxLogSysError(rc, _("Cannot start thread: error writing TLS"));

 
         return (void *)-1;
     }
 
         return (void *)-1;
     }

+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // Install the cleanup handler.
+    pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+#endif

 
     // wait for the condition to be signaled from Run()
     // mutex state: currently locked by the thread which created us
     pthread->m_cond.Wait(pthread->m_mutex);
 
     // wait for the condition to be signaled from Run()
     // mutex state: currently locked by the thread which created us
     pthread->m_cond.Wait(pthread->m_mutex);

-

     // mutex state: locked again on exit of Wait()
 
     // call the main entry
     // mutex state: locked again on exit of Wait()
 
     // call the main entry

-    void* status = thread->Entry();
+    status = thread->Entry();
+
+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    pthread_cleanup_pop(FALSE);
+#endif

 
     // terminate the thread
     thread->Exit(status);
 
 
     // terminate the thread
     thread->Exit(status);
 

-    wxFAIL_MSG("wxThread::Exit() can't return.");
+    wxFAIL_MSG(wxT("wxThread::Exit() can't return."));

 
     return NULL;
 }
 
 
     return NULL;
 }
 

+#if HAVE_THREAD_CLEANUP_FUNCTIONS
+// Only called when the thread is explicitely killed.
+
+void wxThreadInternal::PthreadCleanup(void *ptr)
+{
+    wxThread *thread = (wxThread *) ptr;
+
+    // The thread is already considered as finished.
+    if (thread->p_internal->GetState() == STATE_EXITED)
+      return;
+
+    // first call user-level clean up code
+    thread->OnExit();
+
+    // next wake up the threads waiting for us (OTOH, this function won't retur
+    // until someone waited for us!)
+    thread->p_internal->SetState(STATE_EXITED);
+
+    thread->p_internal->SignalExit();
+}
+#endif
+

 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
     m_cancelled = FALSE;
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
     m_cancelled = FALSE;

+    m_prio = WXTHREAD_DEFAULT_PRIORITY;
+    m_threadId = 0;

 
     // this mutex is locked during almost all thread lifetime - it will only be
     // unlocked in the very end
     m_mutex.Lock();
 
     // this mutex is locked during almost all thread lifetime - it will only be
     // unlocked in the very end
     m_mutex.Lock();

+ 
+    // this mutex is used by wxThreadInternal::Wait() and by
+    // wxThreadInternal::SignalExit(). We don't use m_mutex because of a
+    // possible deadlock in either Wait() or SignalExit().
+    m_end_mutex.Lock();

 
     // this mutex is used in Pause()/Resume() and is also locked all the time
     // unless the thread is paused
 
     // this mutex is used in Pause()/Resume() and is also locked all the time
     // unless the thread is paused


@@ -319,16 +370,28 @@ wxThreadInternal::wxThreadInternal()
 
 wxThreadInternal::~wxThreadInternal()
 {
 
 wxThreadInternal::~wxThreadInternal()
 {

-    m_mutexSuspend.Unlock();
+    // GL: moved to SignalExit
+    // m_mutexSuspend.Unlock();

 
     // note that m_mutex will be unlocked by the thread which waits for our
     // termination
 
     // note that m_mutex will be unlocked by the thread which waits for our
     // termination

+
+    // In the case, we didn't start the thread, all these mutex are locked:
+    // we must unlock them.
+    if (m_mutex.IsLocked())
+      m_mutex.Unlock();
+
+    if (m_end_mutex.IsLocked())
+      m_end_mutex.Unlock();
+
+    if (m_mutexSuspend.IsLocked())
+      m_mutexSuspend.Unlock();

 }
 
 wxThreadError wxThreadInternal::Run()
 {
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
 }
 
 wxThreadError wxThreadInternal::Run()
 {
     wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,

-                 "thread may only be started once after successful Create()" );
+                 wxT("thread may only be started once after successful Create()") );

 
     // the mutex was locked on Create(), so we will be able to lock it again
     // only when the thread really starts executing and enters the wait -
 
     // the mutex was locked on Create(), so we will be able to lock it again
     // only when the thread really starts executing and enters the wait -


@@ -345,24 +408,25 @@ wxThreadError wxThreadInternal::Run()
     // starts executing and the mutex is still locked
 }
 
     // starts executing and the mutex is still locked
 }
 

-void wxThreadInternal::Cancel()
+void wxThreadInternal::Wait()

 {
 {

+    wxCHECK_RET( WasCancelled(), wxT("thread should have been cancelled first") );
+

     // 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() )
         wxMutexGuiLeave();
 
     // 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() )
         wxMutexGuiLeave();
 

-    // nobody ever writes this variable so it's safe to not use any
-    // synchronization here
-    m_cancelled = TRUE;
-

     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination
     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination

-    m_cond.Wait(m_mutex);
+    m_cond.Wait(m_end_mutex);

 
     // mutex is still in the locked state - relocked on exit from Wait(), so
     // unlock it - we don't need it any more, the thread has already terminated
 
     // mutex is still in the locked state - relocked on exit from Wait(), so
     // unlock it - we don't need it any more, the thread has already terminated

-    m_mutex.Unlock();
+    m_end_mutex.Unlock();
+
+    // After that, we wait for the real end of the other thread.
+    pthread_join(GetId(), NULL);

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


@@ -371,21 +435,32 @@ void wxThreadInternal::Cancel()
 
 void wxThreadInternal::SignalExit()
 {
 
 void wxThreadInternal::SignalExit()
 {

+    // GL: Unlock mutexSuspend here.
+    m_mutexSuspend.Unlock();
+

     // as mutex is currently locked, this will block until some other thread
     // (normally the same which created this one) unlocks it by entering Wait()
     // as mutex is currently locked, this will block until some other thread
     // (normally the same which created this one) unlocks it by entering Wait()

-    m_mutex.Lock();
+    m_end_mutex.Lock();

 
     // wake up all the threads waiting for our termination
     m_cond.Broadcast();
 
     // after this call mutex will be finally unlocked
 
     // wake up all the threads waiting for our termination
     m_cond.Broadcast();
 
     // after this call mutex will be finally unlocked

-    m_mutex.Unlock();
+    m_end_mutex.Unlock();

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

+    // the state is set from the thread which pauses us first, this function
+    // is called later so the state should have been already set

     wxCHECK_RET( m_state == STATE_PAUSED,
     wxCHECK_RET( m_state == STATE_PAUSED,

-                 "thread must first be paused with wxThread::Pause()." );
+                 wxT("thread must first be paused with wxThread::Pause().") );
+
+    // don't pause the thread which is being terminated - this would lead to
+    // deadlock if the thread is paused after Delete() had called Resume() but
+    // before it had time to call Wait()
+    if ( WasCancelled() )
+        return;

 
     // wait until the condition is signaled from Resume()
     m_condSuspend.Wait(m_mutexSuspend);
 
     // wait until the condition is signaled from Resume()
     m_condSuspend.Wait(m_mutexSuspend);


@@ -394,7 +469,7 @@ void wxThreadInternal::Pause()
 void wxThreadInternal::Resume()
 {
     wxCHECK_RET( m_state == STATE_PAUSED,
 void wxThreadInternal::Resume()
 {
     wxCHECK_RET( m_state == STATE_PAUSED,

-                 "can't resume thread which is not suspended." );
+                 wxT("can't resume thread which is not suspended.") );

 
     // we will be able to lock this mutex only when Pause() starts waiting
     wxMutexLocker lock(m_mutexSuspend);
 
     // we will be able to lock this mutex only when Pause() starts waiting
     wxMutexLocker lock(m_mutexSuspend);


@@ -448,10 +523,11 @@ wxThreadError wxThread::Create()
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 

+#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS

     int prio;
     if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
     {
     int prio;
     if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
     {

-        wxLogError(_("Can not retrieve thread scheduling policy."));
+        wxLogError(_("Cannot retrieve thread scheduling policy."));

     }
 
     int min_prio = sched_get_priority_min(prio),
     }
 
     int min_prio = sched_get_priority_min(prio),


@@ -459,9 +535,20 @@ wxThreadError wxThread::Create()
 
     if ( min_prio == -1 || max_prio == -1 )
     {
 
     if ( min_prio == -1 || max_prio == -1 )
     {

-        wxLogError(_("Can not get priority range for scheduling policy %d."),
+        wxLogError(_("Cannot get priority range for scheduling policy %d."),

                    prio);
     }
                    prio);
     }

+    else if ( max_prio == min_prio )
+    {
+        if ( p_internal->GetPriority() != WXTHREAD_DEFAULT_PRIORITY )
+        {
+            // notify the programmer that this doesn't work here
+            wxLogWarning(_("Thread priority setting is ignored."));
+        }
+        //else: we have default priority, so don't complain
+
+        // anyhow, don't do anything because priority is just ignored
+    }

     else
     {
         struct sched_param sp;
     else
     {
         struct sched_param sp;


@@ -470,9 +557,15 @@ wxThreadError wxThread::Create()
                            (p_internal->GetPriority()*(max_prio-min_prio))/100;
         pthread_attr_setschedparam(&attr, &sp);
     }
                            (p_internal->GetPriority()*(max_prio-min_prio))/100;
         pthread_attr_setschedparam(&attr, &sp);
     }

+#endif // HAVE_THREAD_PRIORITY_FUNCTIONS
+
+#ifdef HAVE_PTHREAD_ATTR_SETSCOPE
+    // this will make the threads created by this process really concurrent
+    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
+#endif // HAVE_PTHREAD_ATTR_SETSCOPE

 
     // create the new OS thread object
 
     // create the new OS thread object

-    int rc = pthread_create(&p_internal->thread_id, &attr,
+    int rc = pthread_create(p_internal->GetIdPtr(), &attr,

                             wxThreadInternal::PthreadStart, (void *)this);
     pthread_attr_destroy(&attr);
 
                             wxThreadInternal::PthreadStart, (void *)this);
     pthread_attr_destroy(&attr);
 


@@ -487,6 +580,9 @@ wxThreadError wxThread::Create()
 
 wxThreadError wxThread::Run()
 {
 
 wxThreadError wxThread::Run()
 {

+    wxCHECK_MSG( p_internal->GetId(), wxTHREAD_MISC_ERROR,
+                 wxT("must call wxThread::Create() first") );
+

     return p_internal->Run();
 }
 
     return p_internal->Run();
 }
 


@@ -496,8 +592,9 @@ wxThreadError wxThread::Run()
 
 void wxThread::SetPriority(unsigned int prio)
 {
 
 void wxThread::SetPriority(unsigned int prio)
 {

-    wxCHECK_RET( (WXTHREAD_MIN_PRIORITY <= prio) &&
-                 (prio <= WXTHREAD_MAX_PRIORITY), "invalid thread priority" );
+    wxCHECK_RET( ((int)WXTHREAD_MIN_PRIORITY <= (int)prio) &&
+                 ((int)prio <= (int)WXTHREAD_MAX_PRIORITY),
+                 wxT("invalid thread priority") );

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


@@ -510,6 +607,7 @@ void wxThread::SetPriority(unsigned int prio)
 
         case STATE_RUNNING:
         case STATE_PAUSED:
 
         case STATE_RUNNING:
         case STATE_PAUSED:

+#ifdef HAVE_THREAD_PRIORITY_FUNCTIONS

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


@@ -520,11 +618,12 @@ void wxThread::SetPriority(unsigned int prio)
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }
                     wxLogError(_("Failed to set thread priority %d."), prio);
                 }
             }

+#endif // HAVE_THREAD_PRIORITY_FUNCTIONS

             break;
 
         case STATE_EXITED:
         default:
             break;
 
         case STATE_EXITED:
         default:

-            wxFAIL_MSG("impossible to set thread priority in this state");
+            wxFAIL_MSG(wxT("impossible to set thread priority in this state"));

     }
 }
 
     }
 }
 


@@ -537,7 +636,7 @@ unsigned int wxThread::GetPriority() const
 
 unsigned long wxThread::GetID() const
 {
 
 unsigned long wxThread::GetID() const
 {

-    return (unsigned long)p_internal->thread_id;
+    return (unsigned long)p_internal->GetId();

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -550,7 +649,7 @@ wxThreadError wxThread::Pause()
 
     if ( p_internal->GetState() != STATE_RUNNING )
     {
 
     if ( p_internal->GetState() != STATE_RUNNING )
     {

-        wxLogDebug("Can't pause thread which is not running.");
+        wxLogDebug(wxT("Can't pause thread which is not running."));

 
         return wxTHREAD_NOT_RUNNING;
     }
 
         return wxTHREAD_NOT_RUNNING;
     }


@@ -566,13 +665,15 @@ wxThreadError wxThread::Resume()
 
     if ( p_internal->GetState() == STATE_PAUSED )
     {
 
     if ( p_internal->GetState() == STATE_PAUSED )
     {

+        m_critsect.Leave();

         p_internal->Resume();
         p_internal->Resume();

+        m_critsect.Enter();

 
         return wxTHREAD_NO_ERROR;
     }
     else
     {
 
         return wxTHREAD_NO_ERROR;
     }
     else
     {

-        wxLogDebug("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;
     }


@@ -584,8 +685,15 @@ wxThreadError wxThread::Resume()
 
 wxThread::ExitCode wxThread::Delete()
 {
 
 wxThread::ExitCode wxThread::Delete()
 {

+    if (IsPaused())
+      Resume();
+

     m_critsect.Enter();
     m_critsect.Enter();

-    thread_state state = p_internal->GetState();
+    wxThreadState state = p_internal->GetState();
+
+    // ask the thread to stop
+    p_internal->SetCancelFlag();
+

     m_critsect.Leave();
 
     switch ( state )
     m_critsect.Leave();
 
     switch ( state )


@@ -602,9 +710,11 @@ wxThread::ExitCode wxThread::Delete()
             // fall through
 
         default:
             // fall through
 
         default:

-            // set the flag telling to the thread to stop and wait
-            p_internal->Cancel();
+            // wait until the thread stops
+            p_internal->Wait();

     }
     }

+    //GL: As we must auto-destroy, the destruction must happen here.
+    delete this;

 
     return NULL;
 }
 
     return NULL;
 }


@@ -618,12 +728,16 @@ wxThreadError wxThread::Kill()
             return wxTHREAD_NOT_RUNNING;
 
         default:
             return wxTHREAD_NOT_RUNNING;
 
         default:

+#ifdef HAVE_PTHREAD_CANCEL 

             if ( pthread_cancel(p_internal->GetId()) != 0 )
             if ( pthread_cancel(p_internal->GetId()) != 0 )

+#endif

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

+            //GL: As we must auto-destroy, the destruction must happen here (2).
+            delete this;

 
             return wxTHREAD_NO_ERROR;
     }
 
             return wxTHREAD_NO_ERROR;
     }


@@ -641,14 +755,15 @@ void wxThread::Exit(void *status)
     p_internal->SetState(STATE_EXITED);
 
     // delete both C++ thread object and terminate the OS thread object
     p_internal->SetState(STATE_EXITED);
 
     // delete both C++ thread object and terminate the OS thread object

-    delete this;
+    // GL: This is very ugly and buggy ...
+//    delete this;

     pthread_exit(status);
 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
     pthread_exit(status);
 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {

-    wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+    wxCriticalSectionLocker lock(m_critsect);

 
     if ( p_internal->GetState() == STATE_PAUSED )
     {
 
     if ( p_internal->GetState() == STATE_PAUSED )
     {


@@ -667,6 +782,18 @@ bool wxThread::TestDestroy()
 
 wxThread::~wxThread()
 {
 
 wxThread::~wxThread()
 {

+    m_critsect.Enter();
+    if ( p_internal->GetState() != STATE_EXITED &&
+         p_internal->GetState() != STATE_NEW )
+    {
+        wxLogDebug(wxT("The thread is being destroyed although it is still "
+                     "running! The application may crash."));
+    }
+
+    m_critsect.Leave();
+
+    delete p_internal;
+

     // remove this thread from the global array
     gs_allThreads.Remove(this);
 }
     // remove this thread from the global array
     gs_allThreads.Remove(this);
 }


@@ -697,6 +824,13 @@ bool wxThread::IsAlive() const
     }
 }
 
     }
 }
 

+bool wxThread::IsPaused() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+    return (p_internal->GetState() == STATE_PAUSED);
+}
+

 //--------------------------------------------------------------------
 // wxThreadModule
 //--------------------------------------------------------------------
 //--------------------------------------------------------------------
 // wxThreadModule
 //--------------------------------------------------------------------


@@ -715,19 +849,19 @@ IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 
 bool wxThreadModule::OnInit()
 {
 
 bool wxThreadModule::OnInit()
 {

-    if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
+    int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
+    if ( rc != 0 )

     {
     {

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

 
         return FALSE;
     }
 
     gs_mutexGui = new wxMutex();
 
 
         return FALSE;
     }
 
     gs_mutexGui = new wxMutex();
 

-    //wxThreadGuiInit();
-

     gs_tidMain = pthread_self();
     gs_tidMain = pthread_self();

+

     gs_mutexGui->Lock();
 
     return TRUE;
     gs_mutexGui->Lock();
 
     return TRUE;


@@ -735,23 +869,23 @@ bool wxThreadModule::OnInit()
 
 void wxThreadModule::OnExit()
 {
 
 void wxThreadModule::OnExit()
 {

-    wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" );
+    wxASSERT_MSG( wxThread::IsMain(), wxT("only main thread can be here") );

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

-        wxLogDebug("Some threads were not terminated by the application.");
+        wxLogDebug(wxT("Some threads were not terminated by the application."));

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

-        gs_allThreads[n]->Delete();
+        // Delete calls the destructor which removes the current entry. We
+        // should only delete the first one each time.
+        gs_allThreads[0]->Delete();

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

-    //wxThreadGuiExit();
-

     delete gs_mutexGui;
 
     // and free TLD slot
     delete gs_mutexGui;
 
     // and free TLD slot


@@ -771,3 +905,6 @@ void wxMutexGuiLeave()
 {
   gs_mutexGui->Unlock();
 }
 {
   gs_mutexGui->Unlock();
 }

+
+#endif
+  // wxUSE_THREADS