X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/d207efe172bd6780b0dabc95a56dc46e7cad27e3..4e4ea166d76da40eaa5fdcf9e958d93521f72fba:/src/unix/threadpsx.cpp

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 2c8fb6851d..707eb0928f 100644
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -47,6 +47,10 @@
     #include <sched.h>
 #endif
 
+#ifdef __WXGTK12__
+#include "gtk/gtk.h"
+#endif
+
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
@@ -81,8 +85,10 @@ static pthread_t gs_tidMain;
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
 
+#ifndef __WXGTK12__
 // this mutex must be acquired before any call to a GUI function
 static wxMutex *gs_mutexGui;
+#endif
 
 // ============================================================================
 // implementation
@@ -225,6 +231,11 @@ public:
     // 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();
@@ -283,6 +294,7 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 {
     wxThread *thread = (wxThread *)ptr;
     wxThreadInternal *pthread = thread->p_internal;
+    void *status;
 
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
@@ -291,6 +303,10 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 
         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
@@ -299,7 +315,11 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     // 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);
@@ -309,6 +329,28 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     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;
@@ -325,7 +367,8 @@ 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
@@ -360,9 +403,11 @@ void wxThreadInternal::Wait()
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 
+    printf("Entering wait ...\n");
     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination
     m_cond.Wait(m_mutex);
+    printf("Exiting wait ...\n");
 
     // 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
@@ -375,15 +420,21 @@ void wxThreadInternal::Wait()
 
 void wxThreadInternal::SignalExit()
 {
+    printf("SignalExit\n");
+    // 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()
     m_mutex.Lock();
+    printf("Mutex acquired\n");
 
     // wake up all the threads waiting for our termination
     m_cond.Broadcast();
 
     // after this call mutex will be finally unlocked
     m_mutex.Unlock();
+    printf("Mutex unacquired\n");
 }
 
 void wxThreadInternal::Pause()
@@ -453,9 +504,7 @@ wxThread::wxThread()
 
 wxThreadError wxThread::Create()
 {
-    // Maybe we could think about recreate the thread once it has exited.
-    if (p_internal->GetState() != STATE_NEW &&
-        p_internal->GetState() != STATE_EXITED)
+    if (p_internal->GetState() != STATE_NEW)
         return wxTHREAD_RUNNING;
 
     // set up the thread attribute: right now, we only set thread priority
@@ -590,7 +639,9 @@ wxThreadError wxThread::Resume()
 
     if ( p_internal->GetState() == STATE_PAUSED )
     {
+        m_critsect.Leave();
         p_internal->Resume();
+        m_critsect.Enter();
 
         return wxTHREAD_NO_ERROR;
     }
@@ -662,16 +713,20 @@ void wxThread::Exit(void *status)
 {
     // first call user-level clean up code
     OnExit();
+    printf(" ... OnExit()\n");
 
     // next wake up the threads waiting for us (OTOH, this function won't return
     // until someone waited for us!)
     p_internal->SignalExit();
+    printf(" ... SignalExit()\n");
 
     p_internal->SetState(STATE_EXITED);
+    printf(" ... SetState()\n");
 
     // delete both C++ thread object and terminate the OS thread object
     // GL: This is very ugly and buggy ...
 //    delete this;
+    printf(" ... Exit\n");
     pthread_exit(status);
 }
 
@@ -727,6 +782,13 @@ bool wxThread::IsAlive() const
     }
 }
 
+bool wxThread::IsPaused() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+    return (p_internal->GetState() == STATE_PAUSED);
+}
+
 //--------------------------------------------------------------------
 // wxThreadModule
 //--------------------------------------------------------------------
@@ -754,12 +816,15 @@ bool wxThreadModule::OnInit()
         return FALSE;
     }
 
+#ifndef __WXGTK12__
     gs_mutexGui = new wxMutex();
-
-    //wxThreadGuiInit();
+#endif
 
     gs_tidMain = pthread_self();
+
+#ifndef __WXGTK12__
     gs_mutexGui->Lock();
+#endif
 
     return TRUE;
 }
@@ -778,12 +843,12 @@ void wxThreadModule::OnExit()
         gs_allThreads[n]->Delete();
     }
 
+#ifndef __WXGTK12__
     // destroy GUI mutex
     gs_mutexGui->Unlock();
 
-    //wxThreadGuiExit();
-
     delete gs_mutexGui;
+#endif
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
@@ -795,12 +860,20 @@ void wxThreadModule::OnExit()
 
 void wxMutexGuiEnter()
 {
+#ifdef __WXGTK12__
+  gdk_threads_enter();
+#else
   gs_mutexGui->Lock();
+#endif
 }
 
 void wxMutexGuiLeave()
 {
+#ifdef __WXGTK12__
+  gdk_threads_leave();
+#else
   gs_mutexGui->Unlock();
+#endif
 }
 
 #endif