VC++ project files dependencies

[wxWidgets.git] / src / os2 / thread.cpp

diff --git a/src/os2/thread.cpp b/src/os2/thread.cpp
index af2e0f7304c9a4911b38d0e7ad7a46a69f4b2501..04ee638e57bf42b272ee7360aa6804c74b128d2c 100644 (file)
--- a/src/os2/thread.cpp
+++ b/src/os2/thread.cpp
@@ -9,6 +9,10 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

+#ifdef __GNUG__
+    #pragma implementation "thread.h"
+#endif
+

 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------


@@ -30,8 +34,9 @@
 #define INCL_DOSPROCESS
 #define INCL_ERRORS
 #include <os2.h>
 #define INCL_DOSPROCESS
 #define INCL_ERRORS
 #include <os2.h>

+#ifndef __EMX__

 #include <bseerr.h>
 #include <bseerr.h>

-
+#endif

 // the possible states of the thread ("=>" shows all possible transitions from
 // this state)
 enum wxThreadState
 // the possible states of the thread ("=>" shows all possible transitions from
 // this state)
 enum wxThreadState


@@ -85,7 +90,9 @@ public:
     HMTX                            m_vMutex;
 };
 
     HMTX                            m_vMutex;
 };
 

-wxMutex::wxMutex()
+wxMutex::wxMutex(
+  wxMutexType                       eMutexType
+)

 {
     APIRET                          ulrc;
 
 {
     APIRET                          ulrc;
 


@@ -95,13 +102,10 @@ wxMutex::wxMutex()
     {
         wxLogSysError(_("Can not create mutex."));
     }
     {
         wxLogSysError(_("Can not create mutex."));
     }

-    m_locked = 0;

 }
 
 wxMutex::~wxMutex()
 {
 }
 
 wxMutex::~wxMutex()
 {

-    if (m_locked > 0)
-        wxLogDebug(wxT("Warning: freeing a locked mutex (%d locks)."), m_locked);

     ::DosCloseMutexSem(m_internal->m_vMutex);
     m_internal->m_vMutex = NULL;
 }
     ::DosCloseMutexSem(m_internal->m_vMutex);
     m_internal->m_vMutex = NULL;
 }


@@ -131,7 +135,6 @@ wxMutexError wxMutex::Lock()
         default:
             wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
     }
         default:
             wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
     }

-    m_locked++;

     return wxMUTEX_NO_ERROR;
 }
 
     return wxMUTEX_NO_ERROR;
 }
 


@@ -143,7 +146,6 @@ wxMutexError wxMutex::TryLock()
     if (ulrc == ERROR_TIMEOUT || ulrc == ERROR_TOO_MANY_SEM_REQUESTS)
         return wxMUTEX_BUSY;
 
     if (ulrc == ERROR_TIMEOUT || ulrc == ERROR_TOO_MANY_SEM_REQUESTS)
         return wxMUTEX_BUSY;
 

-    m_locked++;

     return wxMUTEX_NO_ERROR;
 }
 
     return wxMUTEX_NO_ERROR;
 }
 


@@ -151,9 +153,6 @@ wxMutexError wxMutex::Unlock()
 {
     APIRET                          ulrc;
 
 {
     APIRET                          ulrc;
 

-    if (m_locked > 0)
-        m_locked--;
-

     ulrc = ::DosReleaseMutexSem(m_internal->m_vMutex);
     if (ulrc != 0)
     {
     ulrc = ::DosReleaseMutexSem(m_internal->m_vMutex);
     if (ulrc != 0)
     {


@@ -180,7 +179,7 @@ public:
         m_nWaiters = 0;
     }
 
         m_nWaiters = 0;
     }
 

-    inline bool Wait(
+    inline APIRET Wait(

       unsigned long                 ulTimeout
     )
     {
       unsigned long                 ulTimeout
     )
     {


@@ -189,7 +188,7 @@ public:
         m_nWaiters++;
         ulrc = ::DosWaitEventSem(m_vEvent, ulTimeout);
         m_nWaiters--;
         m_nWaiters++;
         ulrc = ::DosWaitEventSem(m_vEvent, ulTimeout);
         m_nWaiters--;

-        return (ulrc != ERROR_TIMEOUT);
+        return (ulrc);

     }
 
     inline ~wxConditionInternal ()
     }
 
     inline ~wxConditionInternal ()


@@ -234,34 +233,80 @@ wxCondition::~wxCondition()
     m_internal = NULL;
 }
 
     m_internal = NULL;
 }
 

-void wxCondition::Wait()
+wxCondError wxCondition::Wait()

 {
 {

-    (void)m_internal->Wait(SEM_INDEFINITE_WAIT);
+    APIRET                          rc = m_internal->Wait(SEM_INDEFINITE_WAIT);
+
+    switch(rc)
+    {
+        case NO_ERROR:
+            return wxCOND_NO_ERROR;
+        case ERROR_INVALID_HANDLE:
+            return wxCOND_INVALID;
+        case ERROR_TIMEOUT:
+            return wxCOND_TIMEOUT;
+        default:
+            return wxCOND_MISC_ERROR;
+    }

 }
 
 }
 

-bool wxCondition::Wait(
+wxCondError wxCondition::WaitTimeout(

   unsigned long                     lMilliSec
 )
 {
   unsigned long                     lMilliSec
 )
 {

-    return m_internal->Wait(lMilliSec);
+    APIRET                          rc = m_internal->Wait(lMilliSec);
+
+    switch(rc)
+    {
+        case NO_ERROR:
+            return wxCOND_NO_ERROR;
+        case ERROR_INVALID_HANDLE:
+            return wxCOND_INVALID;
+        case ERROR_TIMEOUT:
+            return wxCOND_TIMEOUT;
+        default:
+            return wxCOND_MISC_ERROR;
+    }

 }
 
 }
 

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

 {
 {

-    ::DosPostEventSem(m_internal->m_vEvent);
+    APIRET                          rc = ::DosPostEventSem(m_internal->m_vEvent);
+
+    switch(rc)
+    {
+        case NO_ERROR:
+            return wxCOND_NO_ERROR;
+        case ERROR_INVALID_HANDLE:
+            return wxCOND_INVALID;
+        default:
+            return wxCOND_MISC_ERROR;
+    }

 }
 
 }
 

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

 {
     int                             i;
 {
     int                             i;

+    APIRET                          rc = NO_ERROR;

 
     for (i = 0; i < m_internal->m_nWaiters; i++)
     {
 
     for (i = 0; i < m_internal->m_nWaiters; i++)
     {

-        if (::DosPostEventSem(m_internal->m_vEvent) != 0)
+        if ((rc = ::DosPostEventSem(m_internal->m_vEvent)) != NO_ERROR)

         {
             wxLogSysError(_("Couldn't change the state of event object."));
         {
             wxLogSysError(_("Couldn't change the state of event object."));

+            break;

         }
     }
         }
     }

+
+    switch(rc)
+    {
+        case NO_ERROR:
+            return wxCOND_NO_ERROR;
+        case ERROR_INVALID_HANDLE:
+            return wxCOND_INVALID;
+        default:
+            return wxCOND_MISC_ERROR;
+    }

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


@@ -439,6 +484,9 @@ bool wxThreadInternal::Create(
     {
         SetPriority(m_nPriority);
     }
     {
         SetPriority(m_nPriority);
     }

+
+    m_eState = STATE_NEW;
+

     return(TRUE);
 }
 
     return(TRUE);
 }
 


@@ -775,6 +823,28 @@ void WXDLLEXPORT wxWakeUpMainThread()
 {
 }
 
 {
 }
 

+void WXDLLEXPORT wxMutexGuiEnter()
+{
+    // this would dead lock everything...
+    wxASSERT_MSG( !wxThread::IsMain(),
+                  wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
+
+    // the order in which we enter the critical sections here is crucial!!
+
+    // set the flag telling to the main thread that we want to do some GUI
+    {
+        wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
+
+        gs_nWaitingForGui++;
+    }
+
+    wxWakeUpMainThread();
+
+    // now we may block here because the main thread will soon let us in
+    // (during the next iteration of OnIdle())
+    gs_pCritsectGui->Enter();
+}
+

 void WXDLLEXPORT wxMutexGuiLeave()
 {
     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 void WXDLLEXPORT wxMutexGuiLeave()
 {
     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);