fixes for new lib dirs for wxMSW

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

diff --git a/src/msw/thread.cpp b/src/msw/thread.cpp
index d59a960162dfcd9362937eff88ed2bc1d6fd93e5..3f273a4600ff90a4ed115ea9a618ec6a6b3ed5da 100644 (file)
--- a/src/msw/thread.cpp
+++ b/src/msw/thread.cpp
@@ -10,7 +10,7 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "thread.h"
 #endif
 
     #pragma implementation "thread.h"
 #endif
 


@@ -64,10 +64,13 @@
     (defined(__GNUG__) && defined(__MSVCRT__)) || \
     defined(__WATCOMC__) || defined(__MWERKS__)
 
     (defined(__GNUG__) && defined(__MSVCRT__)) || \
     defined(__WATCOMC__) || defined(__MWERKS__)
 

+#ifndef __WXWINCE__

     #undef wxUSE_BEGIN_THREAD
     #define wxUSE_BEGIN_THREAD
 #endif
 
     #undef wxUSE_BEGIN_THREAD
     #define wxUSE_BEGIN_THREAD
 #endif
 

+#endif
+

 #ifdef wxUSE_BEGIN_THREAD
     // this is where _beginthreadex() is declared
     #include <process.h>
 #ifdef wxUSE_BEGIN_THREAD
     // this is where _beginthreadex() is declared
     #include <process.h>


@@ -292,6 +295,7 @@ private:
 
 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
 {
 
 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
 {

+#ifndef __WXWINCE__

     if ( maxcount == 0 )
     {
         // make it practically infinite
     if ( maxcount == 0 )
     {
         // make it practically infinite


@@ -305,7 +309,7 @@ wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
                         maxcount,
                         NULL            // no name
                     );
                         maxcount,
                         NULL            // no name
                     );

-
+#endif

     if ( !m_semaphore )
     {
         wxLogLastError(_T("CreateSemaphore()"));
     if ( !m_semaphore )
     {
         wxLogLastError(_T("CreateSemaphore()"));


@@ -344,7 +348,9 @@ wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
 
 wxSemaError wxSemaphoreInternal::Post()
 {
 
 wxSemaError wxSemaphoreInternal::Post()
 {

+#ifndef __WXWINCE__

     if ( !::ReleaseSemaphore(m_semaphore, 1, NULL /* ptr to previous count */) )
     if ( !::ReleaseSemaphore(m_semaphore, 1, NULL /* ptr to previous count */) )

+#endif

     {
         wxLogLastError(_T("ReleaseSemaphore"));
 
     {
         wxLogLastError(_T("ReleaseSemaphore"));
 


@@ -354,141 +360,6 @@ wxSemaError wxSemaphoreInternal::Post()
     return wxSEMA_NO_ERROR;
 }
 
     return wxSEMA_NO_ERROR;
 }
 

-// --------------------------------------------------------------------------
-// wxCondition
-// --------------------------------------------------------------------------
-
-// Win32 doesn't have explicit support for the POSIX condition variables and
-// the Win32 events have quite different semantics, so we reimplement the
-// conditions from scratch using the mutexes and semaphores
-class wxConditionInternal
-{
-public:
-    wxConditionInternal(wxMutex& mutex);
-
-    bool IsOk() const { return m_mutex.IsOk() && m_semaphore.IsOk(); }
-
-    wxCondError Wait();
-    wxCondError WaitTimeout(unsigned long milliseconds);
-
-    wxCondError Signal();
-    wxCondError Broadcast();
-
-private:
-    // the number of threads currently waiting for this condition
-    LONG m_numWaiters;
-
-    // the critical section protecting m_numWaiters
-    wxCriticalSection m_csWaiters;
-
-    wxMutex& m_mutex;
-    wxSemaphore m_semaphore;
-};
-
-wxConditionInternal::wxConditionInternal(wxMutex& mutex)
-                   : m_mutex(mutex)
-{
-    // another thread can't access it until we return from ctor, so no need to
-    // protect access to m_numWaiters here
-    m_numWaiters = 0;
-}
-
-wxCondError wxConditionInternal::Wait()
-{
-    // increment the number of waiters
-    ::InterlockedIncrement(&m_numWaiters);
-
-    m_mutex.Unlock();
-
-    // a potential race condition can occur here
-    //
-    // after a thread increments nwaiters, and unlocks the mutex and before the
-    // semaphore.Wait() is called, if another thread can cause a signal to be
-    // generated
-    //
-    // this race condition is handled by using a semaphore and incrementing the
-    // semaphore only if 'nwaiters' is greater that zero since the semaphore,
-    // can 'remember' signals the race condition will not occur
-
-    // wait ( if necessary ) and decrement semaphore
-    wxSemaError err = m_semaphore.Wait();
-    m_mutex.Lock();
-
-    return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
-}
-
-wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
-{
-    ::InterlockedIncrement(&m_numWaiters);
-
-    m_mutex.Unlock();
-
-    // a race condition can occur at this point in the code
-    //
-    // please see the comments in Wait(), for details
-
-    wxSemaError err = m_semaphore.WaitTimeout(milliseconds);
-
-    if ( err == wxSEMA_BUSY )
-    {
-        // another potential race condition exists here it is caused when a
-        // 'waiting' thread timesout, and returns from WaitForSingleObject, but
-        // has not yet decremented 'nwaiters'.
-        //
-        // at this point if another thread calls signal() then the semaphore
-        // will be incremented, but the waiting thread will miss it.
-        //
-        // to handle this particular case, the waiting thread calls
-        // WaitForSingleObject again with a timeout of 0, after locking
-        // 'nwaiters_mutex'. this call does not block because of the zero
-        // timeout, but will allow the waiting thread to catch the missed
-        // signals.
-        wxCriticalSectionLocker lock(m_csWaiters);
-
-        err = m_semaphore.WaitTimeout(0);
-
-        if ( err != wxSEMA_NO_ERROR )
-        {
-            m_numWaiters--;
-        }
-    }
-
-    m_mutex.Lock();
-
-    return err == wxSEMA_NO_ERROR ? wxCOND_NO_ERROR : wxCOND_MISC_ERROR;
-}
-
-wxCondError wxConditionInternal::Signal()
-{
-    wxCriticalSectionLocker lock(m_csWaiters);
-
-    if ( m_numWaiters > 0 )
-    {
-        // increment the semaphore by 1
-        if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
-            return wxCOND_MISC_ERROR;
-
-        m_numWaiters--;
-    }
-
-    return wxCOND_NO_ERROR;
-}
-
-wxCondError wxConditionInternal::Broadcast()
-{
-    wxCriticalSectionLocker lock(m_csWaiters);
-
-    while ( m_numWaiters > 0 )
-    {
-        if ( m_semaphore.Post() != wxSEMA_NO_ERROR )
-            return wxCOND_MISC_ERROR;
-
-        m_numWaiters--;
-    }
-
-    return wxCOND_NO_ERROR;
-}
-

 // ----------------------------------------------------------------------------
 // wxThread implementation
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxThread implementation
 // ----------------------------------------------------------------------------


@@ -752,7 +623,7 @@ wxThreadInternal::WaitForTerminate(bool shouldCancel,
     if ( shouldResume )
         Resume();
 
     if ( shouldResume )
         Resume();
 

-    // does is still run?
+    // is it still running?

     if ( isRunning || m_state == STATE_RUNNING )
     {
         if ( wxThread::IsMain() )
     if ( isRunning || m_state == STATE_RUNNING )
     {
         if ( wxThread::IsMain() )


@@ -810,7 +681,15 @@ wxThreadInternal::WaitForTerminate(bool shouldCancel,
                     break;
 
                 case WAIT_OBJECT_0 + 1:
                     break;
 
                 case WAIT_OBJECT_0 + 1:

-                    // new message arrived, process it
+                    // new message arrived, process it -- but only if we're the
+                    // main thread as we don't support processing messages in
+                    // the other ones
+                    //
+                    // NB: we still must include QS_ALLINPUT even when waiting
+                    //     in a secondary thread because if it had created some
+                    //     window somehow (possible not even using wxWindows)
+                    //     the system might dead lock then
+                    if ( wxThread::IsMain() )

                     {
                         // it looks that sometimes WAIT_OBJECT_0 + 1 is
                         // returned but there are no messages in the thread
                     {
                         // it looks that sometimes WAIT_OBJECT_0 + 1 is
                         // returned but there are no messages in the thread


@@ -858,6 +737,12 @@ wxThreadInternal::WaitForTerminate(bool shouldCancel,
     if ( pRc )
         *pRc = rc;
 
     if ( pRc )
         *pRc = rc;
 

+    // we don't need the thread handle any more
+    Free();
+
+    wxCriticalSectionLocker lock(cs);
+    SetState(STATE_EXITED);
+

     return rc == (wxThread::ExitCode)-1 ? wxTHREAD_MISC_ERROR
                                         : wxTHREAD_NO_ERROR;
 }
     return rc == (wxThread::ExitCode)-1 ? wxTHREAD_MISC_ERROR
                                         : wxTHREAD_NO_ERROR;
 }


@@ -921,10 +806,6 @@ bool wxThread::IsMain()
     return ::GetCurrentThreadId() == gs_idMainThread;
 }
 
     return ::GetCurrentThreadId() == gs_idMainThread;
 }
 

-#ifdef Yield
-#undef Yield
-#endif
-

 void wxThread::Yield()
 {
     // 0 argument to Sleep() is special and means to just give away the rest of
 void wxThread::Yield()
 {
     // 0 argument to Sleep() is special and means to just give away the rest of


@@ -952,6 +833,7 @@ unsigned long wxThread::GetCurrentId()
 
 bool wxThread::SetConcurrency(size_t level)
 {
 
 bool wxThread::SetConcurrency(size_t level)
 {

+#ifndef __WXWINCE__

     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
 
     // ok only for the default one
     wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
 
     // ok only for the default one


@@ -1041,7 +923,7 @@ bool wxThread::SetConcurrency(size_t level)
 
         return FALSE;
     }
 
         return FALSE;
     }

-
+#endif

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -1118,30 +1000,12 @@ wxThread::ExitCode wxThread::Wait()
 
     (void)m_internal->WaitForTerminate(false, m_critsect, &rc);
 
 
     (void)m_internal->WaitForTerminate(false, m_critsect, &rc);
 

-    m_internal->Free();
-
-    wxCriticalSectionLocker lock(m_critsect);
-    m_internal->SetState(STATE_EXITED);
-

     return rc;
 }
 
 wxThreadError wxThread::Delete(ExitCode *pRc)
 {
     return rc;
 }
 
 wxThreadError wxThread::Delete(ExitCode *pRc)
 {

-    wxThreadError rc = m_internal->WaitForTerminate(true, m_critsect, pRc);
-
-    if ( IsDetached() )
-    {
-        delete this;
-    }
-    else // joinable
-    {
-        // update the status of the joinable thread
-        wxCriticalSectionLocker lock(m_critsect);
-        m_internal->SetState(STATE_EXITED);
-    }
-
-    return rc;
+    return m_internal->WaitForTerminate(true, m_critsect, pRc);

 }
 
 wxThreadError wxThread::Kill()
 }
 
 wxThreadError wxThread::Kill()