#include "wx/except.h"
+#include "wx/dynlib.h"
+
// must have this symbol defined to get _beginthread/_endthread declarations
#ifndef _MT
#define _MT
#if defined(__VISUALC__) || \
(defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \
(defined(__GNUG__) && defined(__MSVCRT__)) || \
- defined(__WATCOMC__) || defined(__MWERKS__)
+ defined(__WATCOMC__)
#ifndef __WXWINCE__
#undef wxUSE_BEGIN_THREAD
::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
}
+bool wxCriticalSection::TryEnter()
+{
+#if wxUSE_DYNLIB_CLASS
+ typedef BOOL
+ (WINAPI *TryEnterCriticalSection_t)(LPCRITICAL_SECTION lpCriticalSection);
+
+ static TryEnterCriticalSection_t
+ pfnTryEnterCriticalSection = (TryEnterCriticalSection_t)
+ wxDynamicLibrary(wxT("kernel32.dll")).
+ GetSymbol(wxT("TryEnterCriticalSection"));
+
+ return pfnTryEnterCriticalSection
+ ? (*pfnTryEnterCriticalSection)((CRITICAL_SECTION *)m_buffer) != 0
+ : false;
+#else
+ return false;
+#endif
+}
+
void wxCriticalSection::Leave()
{
::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
m_thread = thread;
m_hThread = 0;
m_state = STATE_NEW;
- m_priority = WXTHREAD_DEFAULT_PRIORITY;
+ m_priority = wxPRIORITY_DEFAULT;
m_nRef = 1;
}
// (politely, this is not Kill()!) to do it
wxThreadError WaitForTerminate(wxCriticalSection& cs,
wxThread::ExitCode *pRc,
+ wxThreadWait waitMode,
wxThread *threadToDelete = NULL);
// kill the thread unconditionally
// store the thread object in the TLS
if ( !::TlsSetValue(gs_tlsThisThread, thread) )
{
- wxLogSysError(_("Can not start thread: error writing TLS."));
+ wxLogSysError(_("Cannot start thread: error writing TLS."));
return THREAD_ERROR_EXIT;
}
// each thread has its own SEH translator so install our own a.s.a.p.
DisableAutomaticSETranslator();
+ // NB: Notice that we can't use wxCriticalSectionLocker in this function as
+ // we use SEH and it's incompatible with C++ object dtors.
+
// first of all, check whether we hadn't been cancelled already and don't
// start the user code at all then
+ thread->m_critsect.Enter();
const bool hasExited = thread->m_internal->GetState() == STATE_EXITED;
+ thread->m_critsect.Leave();
// run the thread function itself inside a SEH try/except block
wxSEH_TRY
const bool isDetached = thread->IsDetached();
if ( !hasExited )
{
- // enter m_critsect before changing the thread state
- //
- // NB: can't use wxCriticalSectionLocker here as we use SEH and it's
- // incompatible with C++ object dtors
thread->m_critsect.Enter();
thread->m_internal->SetState(STATE_EXITED);
thread->m_critsect.Leave();
return false;
}
- if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
+ if ( m_priority != wxPRIORITY_DEFAULT )
{
SetPriority(m_priority);
}
wxThreadError wxThreadInternal::Kill()
{
+ m_thread->OnKill();
+
if ( !::TerminateThread(m_hThread, THREAD_ERROR_EXIT) )
{
wxLogSysError(_("Couldn't terminate thread"));
wxThreadError
wxThreadInternal::WaitForTerminate(wxCriticalSection& cs,
wxThread::ExitCode *pRc,
+ wxThreadWait waitMode,
wxThread *threadToDelete)
{
// prevent the thread C++ object from disappearing as long as we are using
Cancel();
}
+ if ( threadToDelete )
+ threadToDelete->OnDelete();
// now wait for thread to finish
if ( wxThread::IsMain() )
wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
if ( traits )
{
- result = traits->WaitForThread(m_hThread);
+ result = traits->WaitForThread(m_hThread, waitMode);
}
else // can't wait for the thread
{
{
case 0xFFFFFFFF:
// error
- wxLogSysError(_("Can not wait for thread termination"));
+ wxLogSysError(_("Cannot wait for thread termination"));
Kill();
return wxTHREAD_KILLED;
DWORD nSuspendCount = ::SuspendThread(m_hThread);
if ( nSuspendCount == (DWORD)-1 )
{
- wxLogSysError(_("Can not suspend thread %x"), m_hThread);
+ wxLogSysError(_("Cannot suspend thread %lx"),
+ static_cast<unsigned long>(wxPtrToUInt(m_hThread)));
return false;
}
DWORD nSuspendCount = ::ResumeThread(m_hThread);
if ( nSuspendCount == (DWORD)-1 )
{
- wxLogSysError(_("Can not resume thread %x"), m_hThread);
+ wxLogSysError(_("Cannot resume thread %lx"),
+ static_cast<unsigned long>(wxPtrToUInt(m_hThread)));
return false;
}
{
wxCriticalSectionLocker lock(m_critsect);
- if ( m_internal->GetState() != STATE_NEW )
- {
- // actually, it may be almost any state at all, not only STATE_RUNNING
- return wxTHREAD_RUNNING;
- }
+ wxCHECK_MSG( m_internal->GetState() == STATE_NEW, wxTHREAD_RUNNING,
+ wxT("thread may only be started once after Create()") );
// the thread has just been created and is still suspended - let it run
return Resume();
// stopping thread
// ---------------
-wxThread::ExitCode wxThread::Wait()
+wxThread::ExitCode wxThread::Wait(wxThreadWait waitMode)
{
ExitCode rc = wxUIntToPtr(THREAD_ERROR_EXIT);
wxCHECK_MSG( !IsDetached(), rc,
wxT("wxThread::Wait(): can't wait for detached thread") );
- (void)m_internal->WaitForTerminate(m_critsect, &rc);
+ (void)m_internal->WaitForTerminate(m_critsect, &rc, waitMode);
return rc;
}
-wxThreadError wxThread::Delete(ExitCode *pRc)
+wxThreadError wxThread::Delete(ExitCode *pRc, wxThreadWait waitMode)
{
- return m_internal->WaitForTerminate(m_critsect, pRc, this);
+ return m_internal->WaitForTerminate(m_critsect, pRc, waitMode, this);
}
wxThreadError wxThread::Kill()
void wxThread::Exit(ExitCode status)
{
+ wxThreadInternal::DoThreadOnExit(this);
+
m_internal->Free();
if ( IsDetached() )
unsigned int wxThread::GetPriority() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetPriority();
}
unsigned long wxThread::GetId() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return (unsigned long)m_internal->GetId();
}
bool wxThread::IsRunning() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetState() == STATE_RUNNING;
}
bool wxThread::IsAlive() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return (m_internal->GetState() == STATE_RUNNING) ||
(m_internal->GetState() == STATE_PAUSED);
bool wxThread::IsPaused() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetState() == STATE_PAUSED;
}
bool wxThread::TestDestroy()
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetState() == STATE_CANCELED;
}
::TlsFree(gs_tlsThisThread);
gs_tlsThisThread = 0xFFFFFFFF;
- wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage"));
+ wxLogSysError(_("Thread module initialization failed: cannot store value in thread local storage"));
return false;
}
projects / wxWidgets.git / blobdiff