added an error message if a bitmap can't be addedto the image list

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

diff --git a/src/gtk1/threadpsx.cpp b/src/gtk1/threadpsx.cpp
index 224a3a15b8f8fd797db79b9c19a1673f641bdc05..f4fd5908db566e78ab7ed3acd809f9f4e6fc465b 100644 (file)
--- a/src/gtk1/threadpsx.cpp
+++ b/src/gtk1/threadpsx.cpp
@@ -24,6 +24,9 @@
 #include "wx/utils.h"
 #include "wx/log.h"
 
 #include "wx/utils.h"
 #include "wx/log.h"
 

+#include "gdk/gdk.h"
+#include "gtk/gtk.h"
+

 enum thread_state 
 {
   STATE_IDLE = 0,
 enum thread_state 
 {
   STATE_IDLE = 0,


@@ -40,7 +43,7 @@ enum thread_state
 
 static pthread_t p_mainid;
 
 
 static pthread_t p_mainid;
 

-wxMutex *wxMainMutex; // controls access to all GUI functions
+wxMutex *wxMainMutex; /* controls access to all GUI functions */

 
 //--------------------------------------------------------------------
 // common GUI thread code
 
 //--------------------------------------------------------------------
 // common GUI thread code


@@ -61,7 +64,7 @@ public:
 wxMutex::wxMutex()
 {
     p_internal = new wxMutexInternal;
 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;
 }
 
     m_locked = 0;
 }
 


@@ -70,46 +73,54 @@ wxMutex::~wxMutex()
     if (m_locked > 0)
         wxLogDebug( "wxMutex warning: freeing a locked mutex (%d locks)\n", m_locked );
 
     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()
 {
     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)
     if (err == EDEADLK)

+    {

         return wxMUTEX_DEAD_LOCK;
         return wxMUTEX_DEAD_LOCK;

+    }

        
     m_locked++;
        
     m_locked++;

+    

     return wxMUTEX_NO_ERROR;
 }
 
 wxMutexError wxMutex::TryLock()
 {
     return wxMUTEX_NO_ERROR;
 }
 
 wxMutexError wxMutex::TryLock()
 {

-    int err;
-

     if (m_locked)
     if (m_locked)

+    {

         return wxMUTEX_BUSY;
         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;
     }
     switch (err) 
     {
         case EBUSY: return wxMUTEX_BUSY;
     }

+    

     m_locked++;
     m_locked++;

+    

     return wxMUTEX_NO_ERROR;
 }
 
 wxMutexError wxMutex::Unlock()
 {
     if (m_locked > 0)
     return wxMUTEX_NO_ERROR;
 }
 
 wxMutexError wxMutex::Unlock()
 {
     if (m_locked > 0)

+    {

         m_locked--;
         m_locked--;

+    }

     else
     else

+    {

         return wxMUTEX_UNLOCKED;
         return wxMUTEX_UNLOCKED;

+    }

        
        

-    pthread_mutex_unlock(&(p_internal->p_mutex));
+    pthread_mutex_unlock( &(p_internal->p_mutex) );
+    

     return wxMUTEX_NO_ERROR;
 }
 
     return wxMUTEX_NO_ERROR;
 }
 


@@ -126,37 +137,38 @@ public:
 wxCondition::wxCondition()
 {
     p_internal = new wxConditionInternal;
 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()
 {
 }
 
 wxCondition::~wxCondition()
 {

-    pthread_cond_destroy(&(p_internal->p_condition));
+    pthread_cond_destroy( &(p_internal->p_condition) );
+    

     delete p_internal;
 }
 
 void wxCondition::Wait(wxMutex& mutex)
 {
     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;
 
 }
 
 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()
 {
     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()
 {
 }
 
 void wxCondition::Broadcast()
 {

-    pthread_cond_broadcast(&(p_internal->p_condition));
+    pthread_cond_broadcast( &(p_internal->p_condition) );

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


@@ -179,8 +191,8 @@ void *wxThreadInternal::PthreadStart(void *ptr)
 {
     wxThread *thread = (wxThread *)ptr;
 
 {
     wxThread *thread = (wxThread *)ptr;
 

-    // Call the main entry
-    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+    /* Call the main entry */
+    pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, (int*) NULL );

     void* status = thread->Entry();
 
     thread->Exit(status);
     void* status = thread->Entry();
 
     thread->Exit(status);


@@ -197,7 +209,7 @@ wxThreadError wxThread::Create()
     if (p_internal->state != STATE_IDLE)
         return wxTHREAD_RUNNING;
 
     if (p_internal->state != STATE_IDLE)
         return wxTHREAD_RUNNING;
 

-    // Change thread priority
+    /* Change thread priority */

     pthread_attr_init(&a);
     pthread_attr_getschedpolicy(&a, &p);
 
     pthread_attr_init(&a);
     pthread_attr_getschedpolicy(&a, &p);
 


@@ -243,9 +255,9 @@ int wxThread::GetPriority() const
 void wxThread::DeferDestroy(bool on)
 {
     if (on)
 void wxThread::DeferDestroy(bool on)
 {
     if (on)

-        pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
+        pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, (int*) NULL);

     else
     else

-        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, (int*) NULL);

 }
 
 wxThreadError wxThread::Destroy()
 }
 
 wxThreadError wxThread::Destroy()


@@ -319,7 +331,7 @@ void wxThread::Exit(void *status)
     pthread_exit(status);
 }
 
     pthread_exit(status);
 }
 

-void wxThread::TestDestroy()
+bool wxThread::TestDestroy()

 {
     if (p_internal->state == STATE_PAUSING) 
     {
 {
     if (p_internal->state == STATE_PAUSING) 
     {


@@ -330,7 +342,12 @@ void wxThread::TestDestroy()
             usleep(1);
         }
     }
             usleep(1);
         }
     }

+
+    // VZ: do I understand it correctly that it will terminate the thread all by
+    //     itself if it was cancelled?

     pthread_testcancel();
     pthread_testcancel();

+    
+    return FALSE;

 }
 
 bool wxThread::IsMain()
 }
 
 bool wxThread::IsMain()


@@ -362,7 +379,7 @@ wxThread::~wxThread()
     delete p_internal;
 }
 
     delete p_internal;
 }
 

-// The default callback just joins the thread and throws away the result.
+/* The default callback just joins the thread and throws away the result. */

 void wxThread::OnExit()
 {
     Join();
 void wxThread::OnExit()
 {
     Join();


@@ -372,28 +389,32 @@ void wxThread::OnExit()
 // wxThreadModule 
 //--------------------------------------------------------------------
 
 // wxThreadModule 
 //--------------------------------------------------------------------
 

-class wxThreadModule : public wxModule 
+class wxThreadModule : public wxModule

 {
 {

-  DECLARE_DYNAMIC_CLASS(wxThreadModule)
-  

 public:
 public:

-  virtual bool OnInit() 
-    {
-        wxMainMutex = new wxMutex();
-        wxThreadGuiInit();
-        p_mainid = pthread_self();
-       wxMainMutex->Lock();
-
-       return TRUE;
-    }
+    virtual bool OnInit();
+    virtual void OnExit();

 
 

-  virtual void OnExit() 
-  {
-      wxMainMutex->Unlock();
-      wxThreadGuiExit();
-      delete wxMainMutex;
-  }
+private:
+    DECLARE_DYNAMIC_CLASS(wxThreadModule)

 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 
 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 

+bool wxThreadModule::OnInit() 
+{
+    wxMainMutex = new wxMutex();
+    wxThreadGuiInit();
+    p_mainid = (int)getpid();
+    wxMainMutex->Lock();
+    return TRUE;
+}
+
+void wxThreadModule::OnExit()
+{
+    wxMainMutex->Unlock();
+    wxThreadGuiExit();
+    delete wxMainMutex;
+}
+
+