image update

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

diff --git a/src/gtk1/threadpsx.cpp b/src/gtk1/threadpsx.cpp
index dd769527e5acea4ca67597ac049a011019cc339f..f4fd5908db566e78ab7ed3acd809f9f4e6fc465b 100644 (file)
--- a/src/gtk1/threadpsx.cpp
+++ b/src/gtk1/threadpsx.cpp
@@ -64,7 +64,7 @@ public:
 wxMutex::wxMutex()
 {
     p_internal = new wxMutexInternal;
-    pthread_mutex_init(&(p_internal->p_mutex), NULL);
+    pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
     m_locked = 0;
 }
 
@@ -73,46 +73,54 @@ wxMutex::~wxMutex()
     if (m_locked > 0)
         wxLogDebug( "wxMutex warning: freeing a locked mutex (%d locks)\n", m_locked );
 
-    pthread_mutex_destroy(&(p_internal->p_mutex));
+    pthread_mutex_destroy( &(p_internal->p_mutex) );
     delete p_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {
-    int err;
-
-    err = pthread_mutex_lock(&(p_internal->p_mutex));
+    int err = pthread_mutex_lock( &(p_internal->p_mutex) );
     if (err == EDEADLK)
+    {
         return wxMUTEX_DEAD_LOCK;
+    }
        
     m_locked++;
+    
     return wxMUTEX_NO_ERROR;
 }
 
 wxMutexError wxMutex::TryLock()
 {
-    int err;
-
     if (m_locked)
+    {
         return wxMUTEX_BUSY;
+    }
        
-    err = pthread_mutex_trylock(&(p_internal->p_mutex));
+    int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
     switch (err) 
     {
         case EBUSY: return wxMUTEX_BUSY;
     }
+    
     m_locked++;
+    
     return wxMUTEX_NO_ERROR;
 }
 
 wxMutexError wxMutex::Unlock()
 {
     if (m_locked > 0)
+    {
         m_locked--;
+    }
     else
+    {
         return wxMUTEX_UNLOCKED;
+    }
        
-    pthread_mutex_unlock(&(p_internal->p_mutex));
+    pthread_mutex_unlock( &(p_internal->p_mutex) );
+    
     return wxMUTEX_NO_ERROR;
 }
 
@@ -129,37 +137,38 @@ public:
 wxCondition::wxCondition()
 {
     p_internal = new wxConditionInternal;
-    pthread_cond_init(&(p_internal->p_condition), NULL);
+    pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
 }
 
 wxCondition::~wxCondition()
 {
-    pthread_cond_destroy(&(p_internal->p_condition));
+    pthread_cond_destroy( &(p_internal->p_condition) );
+    
     delete p_internal;
 }
 
 void wxCondition::Wait(wxMutex& mutex)
 {
-    pthread_cond_wait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex));
+    pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
 }
 
 bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
 {
     struct timespec tspec;
 
-    tspec.tv_sec = time(NULL)+sec;
+    tspec.tv_sec = time(0L)+sec;
     tspec.tv_nsec = nsec;
     return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
 }
 
 void wxCondition::Signal()
 {
-    pthread_cond_signal(&(p_internal->p_condition));
+    pthread_cond_signal( &(p_internal->p_condition) );
 }
 
 void wxCondition::Broadcast()
 {
-    pthread_cond_broadcast(&(p_internal->p_condition));
+    pthread_cond_broadcast( &(p_internal->p_condition) );
 }
 
 //--------------------------------------------------------------------
@@ -183,7 +192,7 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     wxThread *thread = (wxThread *)ptr;
 
     /* Call the main entry */
-    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+    pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, (int*) NULL );
     void* status = thread->Entry();
 
     thread->Exit(status);
@@ -246,9 +255,9 @@ int wxThread::GetPriority() const
 void wxThread::DeferDestroy(bool on)
 {
     if (on)
-        pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
+        pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, (int*) NULL);
     else
-        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, (int*) NULL);
 }
 
 wxThreadError wxThread::Destroy()
@@ -322,7 +331,7 @@ void wxThread::Exit(void *status)
     pthread_exit(status);
 }
 
-void wxThread::TestDestroy()
+bool wxThread::TestDestroy()
 {
     if (p_internal->state == STATE_PAUSING) 
     {
@@ -333,7 +342,12 @@ void wxThread::TestDestroy()
             usleep(1);
         }
     }
+
+    // VZ: do I understand it correctly that it will terminate the thread all by
+    //     itself if it was cancelled?
     pthread_testcancel();
+    
+    return FALSE;
 }
 
 bool wxThread::IsMain()
@@ -375,6 +389,16 @@ void wxThread::OnExit()
 // wxThreadModule 
 //--------------------------------------------------------------------
 
+class wxThreadModule : public wxModule
+{
+public:
+    virtual bool OnInit();
+    virtual void OnExit();
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxThreadModule)
+};
+
 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 
 bool wxThreadModule::OnInit()