mac adaptions
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4458 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Stefan Csomor
@@ -1,71 +1,146 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: thread.cpp
|
||||
// Purpose: wxThread Implementation. For Unix ports, see e.g. src/gtk
|
||||
// Purpose: wxThread Implementation
|
||||
// Author: Original from Wolfram Gloger/Guilhem Lavaux
|
||||
// Modified by:
|
||||
// Modified by: Vadim Zeitlin to make it work :-)
|
||||
// Created: 04/22/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
|
||||
// Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998),
|
||||
// Vadim Zeitlin (1999)
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "thread.h"
|
||||
#pragma implementation "thread.h"
|
||||
#endif
|
||||
|
||||
#include "wx/module.h"
|
||||
#include "wx/thread.h"
|
||||
#include "wx/utils.h"
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
enum thread_state {
|
||||
STATE_IDLE = 0,
|
||||
STATE_RUNNING,
|
||||
STATE_CANCELED,
|
||||
STATE_EXITED
|
||||
};
|
||||
// For compilers that support precompilation, includes "wx.h".
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#if defined(__BORLANDC__)
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/wx.h"
|
||||
#endif
|
||||
|
||||
#if wxUSE_THREADS
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Static variables
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
#include <stdio.h>
|
||||
|
||||
wxMutex *wxMainMutex; // controls access to all GUI functions
|
||||
#include <windows.h>
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Windows implementation
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
#include "wx/module.h"
|
||||
#include "wx/thread.h"
|
||||
|
||||
class wxMutexInternal {
|
||||
// the possible states of the thread ("=>" shows all possible transitions from
|
||||
// this state)
|
||||
enum wxThreadState
|
||||
{
|
||||
STATE_NEW, // didn't start execution yet (=> RUNNING)
|
||||
STATE_RUNNING, // thread is running (=> PAUSED, CANCELED)
|
||||
STATE_PAUSED, // thread is temporarily suspended (=> RUNNING)
|
||||
STATE_CANCELED, // thread should terminate a.s.a.p. (=> EXITED)
|
||||
STATE_EXITED // thread is terminating
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// static variables
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// if it's FALSE, some secondary thread is holding the GUI lock
|
||||
static bool s_bGuiOwnedByMainThread = TRUE;
|
||||
|
||||
// critical section which controls access to all GUI functions: any secondary
|
||||
// thread (i.e. except the main one) must enter this crit section before doing
|
||||
// any GUI calls
|
||||
static wxCriticalSection *s_critsectGui = NULL;
|
||||
|
||||
// critical section which protects s_nWaitingForGui variable
|
||||
static wxCriticalSection *s_critsectWaitingForGui = NULL;
|
||||
|
||||
// number of threads waiting for GUI in wxMutexGuiEnter()
|
||||
static size_t s_nWaitingForGui = 0;
|
||||
|
||||
// are we waiting for a thread termination?
|
||||
static bool s_waitingForThread = FALSE;
|
||||
|
||||
// ============================================================================
|
||||
// Windows implementation of thread classes
|
||||
// ============================================================================
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxMutex implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
class wxMutexInternal
|
||||
{
|
||||
public:
|
||||
// TODO: internal mutex handle
|
||||
Handle p_mutex;
|
||||
};
|
||||
|
||||
wxMutex::wxMutex()
|
||||
{
|
||||
p_internal = new wxMutexInternal;
|
||||
// TODO: create internal mutext handle
|
||||
// p_internal->p_mutex = CreateMutex(NULL, FALSE, NULL);
|
||||
if ( !p_internal->p_mutex )
|
||||
{
|
||||
wxLogSysError(_("Can not create mutex."));
|
||||
}
|
||||
|
||||
m_locked = 0;
|
||||
}
|
||||
|
||||
wxMutex::~wxMutex()
|
||||
{
|
||||
if (m_locked > 0)
|
||||
wxDebugMsg("wxMutex warning: freeing a locked mutex (%d locks)\n", m_locked);
|
||||
// TODO: free internal mutext handle
|
||||
wxLogDebug(wxT("Warning: freeing a locked mutex (%d locks)."), m_locked);
|
||||
// CloseHandle(p_internal->p_mutex);
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::Lock()
|
||||
{
|
||||
// TODO
|
||||
/*
|
||||
DWORD ret;
|
||||
|
||||
ret = WaitForSingleObject(p_internal->p_mutex, INFINITE);
|
||||
switch ( ret )
|
||||
{
|
||||
case WAIT_ABANDONED:
|
||||
return wxMUTEX_BUSY;
|
||||
|
||||
case WAIT_OBJECT_0:
|
||||
// ok
|
||||
break;
|
||||
|
||||
case WAIT_FAILED:
|
||||
wxLogSysError(_("Couldn't acquire a mutex lock"));
|
||||
return wxMUTEX_MISC_ERROR;
|
||||
|
||||
case WAIT_TIMEOUT:
|
||||
default:
|
||||
wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
|
||||
}
|
||||
*/
|
||||
m_locked++;
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
wxMutexError wxMutex::TryLock()
|
||||
{
|
||||
// TODO
|
||||
/*
|
||||
DWORD ret;
|
||||
|
||||
ret = WaitForSingleObject(p_internal->p_mutex, 0);
|
||||
if (ret == WAIT_TIMEOUT || ret == WAIT_ABANDONED)
|
||||
return wxMUTEX_BUSY;
|
||||
|
||||
m_locked++;
|
||||
*/
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
@@ -73,192 +148,715 @@ wxMutexError wxMutex::Unlock()
|
||||
{
|
||||
if (m_locked > 0)
|
||||
m_locked--;
|
||||
|
||||
// TODO
|
||||
/*
|
||||
BOOL ret = ReleaseMutex(p_internal->p_mutex);
|
||||
if ( ret == 0 )
|
||||
{
|
||||
wxLogSysError(_("Couldn't release a mutex"));
|
||||
return wxMUTEX_MISC_ERROR;
|
||||
}
|
||||
*/
|
||||
return wxMUTEX_NO_ERROR;
|
||||
}
|
||||
|
||||
class wxConditionInternal {
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxCondition implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class wxConditionInternal
|
||||
{
|
||||
public:
|
||||
// TODO: internal handle
|
||||
int waiters;
|
||||
Handle event;
|
||||
int waiters;
|
||||
};
|
||||
|
||||
wxCondition::wxCondition()
|
||||
{
|
||||
p_internal = new wxConditionInternal;
|
||||
// TODO: create internal handle
|
||||
// p_internal->event = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||||
if ( !p_internal->event )
|
||||
{
|
||||
wxLogSysError(_("Can not create event object."));
|
||||
}
|
||||
|
||||
p_internal->waiters = 0;
|
||||
}
|
||||
|
||||
wxCondition::~wxCondition()
|
||||
{
|
||||
// TODO: destroy internal handle
|
||||
// CloseHandle(p_internal->event);
|
||||
}
|
||||
|
||||
void wxCondition::Wait(wxMutex& mutex)
|
||||
{
|
||||
mutex.Unlock();
|
||||
p_internal->waiters++;
|
||||
// TODO wait here
|
||||
// WaitForSingleObject(p_internal->event, INFINITE);
|
||||
p_internal->waiters--;
|
||||
mutex.Lock();
|
||||
}
|
||||
|
||||
bool wxCondition::Wait(wxMutex& mutex, unsigned long sec,
|
||||
bool wxCondition::Wait(wxMutex& mutex,
|
||||
unsigned long sec,
|
||||
unsigned long nsec)
|
||||
{
|
||||
// DWORD ret;
|
||||
|
||||
mutex.Unlock();
|
||||
p_internal->waiters++;
|
||||
|
||||
// TODO wait here
|
||||
// ret = WaitForSingleObject(p_internal->event, (sec*1000)+(nsec/1000000));
|
||||
p_internal->waiters--;
|
||||
mutex.Lock();
|
||||
|
||||
return FALSE;
|
||||
return TRUE; // false for timeout
|
||||
}
|
||||
|
||||
void wxCondition::Signal()
|
||||
{
|
||||
// TODO
|
||||
// SetEvent(p_internal->event);
|
||||
}
|
||||
|
||||
void wxCondition::Broadcast()
|
||||
{
|
||||
// TODO
|
||||
int i;
|
||||
|
||||
for (i=0;i<p_internal->waiters;i++)
|
||||
{
|
||||
// if ( SetEvent(p_internal->event) == 0 )
|
||||
{
|
||||
wxLogSysError(_("Couldn't change the state of event object."));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class wxThreadInternal {
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxCriticalSection implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class wxCriticalSectionInternal
|
||||
{
|
||||
public:
|
||||
// TODO
|
||||
// init the critical section object
|
||||
wxCriticalSectionInternal()
|
||||
{ /* ::InitializeCriticalSection(&m_data);*/ }
|
||||
|
||||
// implicit cast to the associated data
|
||||
operator Handle *() { return &m_data; }
|
||||
|
||||
// free the associated ressources
|
||||
~wxCriticalSectionInternal()
|
||||
{ /* ::DeleteCriticalSection(&m_data); */}
|
||||
|
||||
private:
|
||||
Handle m_data;
|
||||
};
|
||||
|
||||
wxCriticalSection::wxCriticalSection()
|
||||
{
|
||||
m_critsect = new wxCriticalSectionInternal;
|
||||
}
|
||||
|
||||
wxCriticalSection::~wxCriticalSection()
|
||||
{
|
||||
delete m_critsect;
|
||||
}
|
||||
|
||||
void wxCriticalSection::Enter()
|
||||
{
|
||||
// ::EnterCriticalSection(*m_critsect);
|
||||
}
|
||||
|
||||
void wxCriticalSection::Leave()
|
||||
{
|
||||
// ::LeaveCriticalSection(*m_critsect);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxThread implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// wxThreadInternal class
|
||||
// ----------------------
|
||||
|
||||
/*
|
||||
class wxThreadInternal
|
||||
{
|
||||
public:
|
||||
wxThreadInternal()
|
||||
{
|
||||
m_hThread = 0;
|
||||
m_state = STATE_NEW;
|
||||
m_priority = WXTHREAD_DEFAULT_PRIORITY;
|
||||
}
|
||||
|
||||
// create a new (suspended) thread (for the given thread object)
|
||||
bool Create(wxThread *thread);
|
||||
|
||||
// suspend/resume/terminate
|
||||
bool Suspend();
|
||||
bool Resume();
|
||||
void Cancel() { m_state = STATE_CANCELED; }
|
||||
|
||||
// thread state
|
||||
void SetState(wxThreadState state) { m_state = state; }
|
||||
wxThreadState GetState() const { return m_state; }
|
||||
|
||||
// thread priority
|
||||
void SetPriority(unsigned int priority) { m_priority = priority; }
|
||||
unsigned int GetPriority() const { return m_priority; }
|
||||
|
||||
// thread handle and id
|
||||
HANDLE GetHandle() const { return m_hThread; }
|
||||
DWORD GetId() const { return m_tid; }
|
||||
|
||||
// thread function
|
||||
static DWORD WinThreadStart(wxThread *thread);
|
||||
|
||||
private:
|
||||
Handle m_hThread; // handle of the thread
|
||||
wxThreadState m_state; // state, see wxThreadState enum
|
||||
unsigned int m_priority; // thread priority in "wx" units
|
||||
ThreadId m_tid; // thread id
|
||||
};
|
||||
|
||||
DWORD wxThreadInternal::WinThreadStart(wxThread *thread)
|
||||
{
|
||||
// store the thread object in the TLS
|
||||
if ( !::TlsSetValue(s_tlsThisThread, thread) )
|
||||
{
|
||||
wxLogSysError(_("Can not start thread: error writing TLS."));
|
||||
|
||||
return (DWORD)-1;
|
||||
}
|
||||
|
||||
DWORD ret = (DWORD)thread->Entry();
|
||||
thread->p_internal->SetState(STATE_EXITED);
|
||||
thread->OnExit();
|
||||
|
||||
delete thread;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool wxThreadInternal::Create(wxThread *thread)
|
||||
{
|
||||
m_hThread = ::CreateThread
|
||||
(
|
||||
NULL, // default security
|
||||
0, // default stack size
|
||||
(LPTHREAD_START_ROUTINE) // thread entry point
|
||||
wxThreadInternal::WinThreadStart, //
|
||||
(LPVOID)thread, // parameter
|
||||
CREATE_SUSPENDED, // flags
|
||||
&m_tid // [out] thread id
|
||||
);
|
||||
|
||||
if ( m_hThread == NULL )
|
||||
{
|
||||
wxLogSysError(_("Can't create thread"));
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// translate wxWindows priority to the Windows one
|
||||
int win_priority;
|
||||
if (m_priority <= 20)
|
||||
win_priority = THREAD_PRIORITY_LOWEST;
|
||||
else if (m_priority <= 40)
|
||||
win_priority = THREAD_PRIORITY_BELOW_NORMAL;
|
||||
else if (m_priority <= 60)
|
||||
win_priority = THREAD_PRIORITY_NORMAL;
|
||||
else if (m_priority <= 80)
|
||||
win_priority = THREAD_PRIORITY_ABOVE_NORMAL;
|
||||
else if (m_priority <= 100)
|
||||
win_priority = THREAD_PRIORITY_HIGHEST;
|
||||
else
|
||||
{
|
||||
wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
|
||||
win_priority = THREAD_PRIORITY_NORMAL;
|
||||
}
|
||||
|
||||
if ( ::SetThreadPriority(m_hThread, win_priority) == 0 )
|
||||
{
|
||||
wxLogSysError(_("Can't set thread priority"));
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
bool wxThreadInternal::Suspend()
|
||||
{
|
||||
DWORD nSuspendCount = ::SuspendThread(m_hThread);
|
||||
if ( nSuspendCount == (DWORD)-1 )
|
||||
{
|
||||
wxLogSysError(_("Can not suspend thread %x"), m_hThread);
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
m_state = STATE_PAUSED;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
bool wxThreadInternal::Resume()
|
||||
{
|
||||
DWORD nSuspendCount = ::ResumeThread(m_hThread);
|
||||
if ( nSuspendCount == (DWORD)-1 )
|
||||
{
|
||||
wxLogSysError(_("Can not resume thread %x"), m_hThread);
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
m_state = STATE_RUNNING;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
// static functions
|
||||
// ----------------
|
||||
|
||||
wxThread *wxThread::This()
|
||||
{
|
||||
wxThread *thread = (wxThread *)::TlsGetValue(s_tlsThisThread);
|
||||
|
||||
// be careful, 0 may be a valid return value as well
|
||||
if ( !thread && (::GetLastError() != NO_ERROR) )
|
||||
{
|
||||
wxLogSysError(_("Couldn't get the current thread pointer"));
|
||||
|
||||
// return NULL...
|
||||
}
|
||||
|
||||
return thread;
|
||||
}
|
||||
|
||||
bool wxThread::IsMain()
|
||||
{
|
||||
return ::GetCurrentThreadId() == s_idMainThread;
|
||||
}
|
||||
|
||||
#ifdef Yield
|
||||
#undef Yield
|
||||
#endif
|
||||
|
||||
void wxThread::Yield()
|
||||
{
|
||||
// 0 argument to Sleep() is special
|
||||
::Sleep(0);
|
||||
}
|
||||
|
||||
void wxThread::Sleep(unsigned long milliseconds)
|
||||
{
|
||||
::Sleep(milliseconds);
|
||||
}
|
||||
|
||||
// create/start thread
|
||||
// -------------------
|
||||
|
||||
wxThreadError wxThread::Create()
|
||||
{
|
||||
// TODO
|
||||
if ( !p_internal->Create(this) )
|
||||
return wxTHREAD_NO_RESOURCE;
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Destroy()
|
||||
wxThreadError wxThread::Run()
|
||||
{
|
||||
// TODO
|
||||
return wxTHREAD_NO_ERROR;
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
if ( p_internal->GetState() != STATE_NEW )
|
||||
{
|
||||
// actually, it may be almost any state at all, not only STATE_RUNNING
|
||||
return wxTHREAD_RUNNING;
|
||||
}
|
||||
|
||||
return Resume();
|
||||
}
|
||||
|
||||
// suspend/resume thread
|
||||
// ---------------------
|
||||
|
||||
wxThreadError wxThread::Pause()
|
||||
{
|
||||
// TODO
|
||||
return wxTHREAD_NO_ERROR;
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
return p_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Resume()
|
||||
{
|
||||
// TODO
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
return p_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
|
||||
}
|
||||
|
||||
// stopping thread
|
||||
// ---------------
|
||||
|
||||
wxThread::ExitCode wxThread::Delete()
|
||||
{
|
||||
ExitCode rc = 0;
|
||||
|
||||
// Delete() is always safe to call, so consider all possible states
|
||||
if ( IsPaused() )
|
||||
Resume();
|
||||
|
||||
if ( IsRunning() )
|
||||
{
|
||||
if ( IsMain() )
|
||||
{
|
||||
// set flag for wxIsWaitingForThread()
|
||||
s_waitingForThread = TRUE;
|
||||
|
||||
wxBeginBusyCursor();
|
||||
}
|
||||
|
||||
HANDLE hThread;
|
||||
{
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
p_internal->Cancel();
|
||||
hThread = p_internal->GetHandle();
|
||||
}
|
||||
|
||||
// we can't just wait for the thread to terminate because it might be
|
||||
// calling some GUI functions and so it will never terminate before we
|
||||
// process the Windows messages that result from these functions
|
||||
DWORD result;
|
||||
do
|
||||
{
|
||||
result = ::MsgWaitForMultipleObjects
|
||||
(
|
||||
1, // number of objects to wait for
|
||||
&hThread, // the objects
|
||||
FALSE, // don't wait for all objects
|
||||
INFINITE, // no timeout
|
||||
QS_ALLEVENTS // return as soon as there are any events
|
||||
);
|
||||
|
||||
switch ( result )
|
||||
{
|
||||
case 0xFFFFFFFF:
|
||||
// error
|
||||
wxLogSysError(_("Can not wait for thread termination"));
|
||||
Kill();
|
||||
return (ExitCode)-1;
|
||||
|
||||
case WAIT_OBJECT_0:
|
||||
// thread we're waiting for terminated
|
||||
break;
|
||||
|
||||
case WAIT_OBJECT_0 + 1:
|
||||
// new message arrived, process it
|
||||
if ( !wxTheApp->DoMessage() )
|
||||
{
|
||||
// WM_QUIT received: kill the thread
|
||||
Kill();
|
||||
|
||||
return (ExitCode)-1;
|
||||
}
|
||||
|
||||
if ( IsMain() )
|
||||
{
|
||||
// give the thread we're waiting for chance to exit
|
||||
// from the GUI call it might have been in
|
||||
if ( (s_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
|
||||
{
|
||||
wxMutexGuiLeave();
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject"));
|
||||
}
|
||||
} while ( result != WAIT_OBJECT_0 );
|
||||
|
||||
if ( IsMain() )
|
||||
{
|
||||
s_waitingForThread = FALSE;
|
||||
|
||||
wxEndBusyCursor();
|
||||
}
|
||||
|
||||
if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
|
||||
{
|
||||
wxLogLastError("GetExitCodeThread");
|
||||
|
||||
rc = (ExitCode)-1;
|
||||
}
|
||||
|
||||
wxASSERT_MSG( (LPVOID)rc != (LPVOID)STILL_ACTIVE,
|
||||
wxT("thread must be already terminated.") );
|
||||
|
||||
::CloseHandle(hThread);
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
wxThreadError wxThread::Kill()
|
||||
{
|
||||
if ( !IsRunning() )
|
||||
return wxTHREAD_NOT_RUNNING;
|
||||
|
||||
if ( !::TerminateThread(p_internal->GetHandle(), (DWORD)-1) )
|
||||
{
|
||||
wxLogSysError(_("Couldn't terminate thread"));
|
||||
|
||||
return wxTHREAD_MISC_ERROR;
|
||||
}
|
||||
|
||||
delete this;
|
||||
|
||||
return wxTHREAD_NO_ERROR;
|
||||
}
|
||||
|
||||
void wxThread::Exit(void *status)
|
||||
{
|
||||
// TODO
|
||||
delete this;
|
||||
|
||||
::ExitThread((DWORD)status);
|
||||
|
||||
wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
|
||||
}
|
||||
|
||||
void wxThread::SetPriority(int prio)
|
||||
void wxThread::SetPriority(unsigned int prio)
|
||||
{
|
||||
// TODO
|
||||
wxCriticalSectionLocker lock(m_critsect);
|
||||
|
||||
p_internal->SetPriority(prio);
|
||||
}
|
||||
|
||||
int wxThread::GetPriority() const
|
||||
unsigned int wxThread::GetPriority() const
|
||||
{
|
||||
// TODO
|
||||
return 0;
|
||||
}
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
void wxThread::DeferDestroy(bool on)
|
||||
{
|
||||
// TODO
|
||||
}
|
||||
|
||||
void wxThread::TestDestroy()
|
||||
{
|
||||
// TODO
|
||||
}
|
||||
|
||||
void *wxThread::Join()
|
||||
{
|
||||
// TODO
|
||||
return (void*) NULL;
|
||||
return p_internal->GetPriority();
|
||||
}
|
||||
|
||||
unsigned long wxThread::GetID() const
|
||||
{
|
||||
// TODO
|
||||
return 0;
|
||||
}
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
/* is this needed somewhere ?
|
||||
wxThread *wxThread::GetThreadFromID(unsigned long id)
|
||||
{
|
||||
// TODO
|
||||
return NULL;
|
||||
}
|
||||
*/
|
||||
|
||||
bool wxThread::IsAlive() const
|
||||
{
|
||||
// TODO
|
||||
return FALSE;
|
||||
return (unsigned long)p_internal->GetId();
|
||||
}
|
||||
|
||||
bool wxThread::IsRunning() const
|
||||
{
|
||||
// TODO
|
||||
return FALSE;
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return p_internal->GetState() == STATE_RUNNING;
|
||||
}
|
||||
|
||||
bool wxThread::IsMain()
|
||||
bool wxThread::IsAlive() const
|
||||
{
|
||||
// TODO
|
||||
return FALSE;
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return (p_internal->GetState() == STATE_RUNNING) ||
|
||||
(p_internal->GetState() == STATE_PAUSED);
|
||||
}
|
||||
|
||||
bool wxThread::IsPaused() const
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return (p_internal->GetState() == STATE_PAUSED);
|
||||
}
|
||||
|
||||
bool wxThread::TestDestroy()
|
||||
{
|
||||
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
|
||||
|
||||
return p_internal->GetState() == STATE_CANCELED;
|
||||
}
|
||||
|
||||
wxThread::wxThread()
|
||||
{
|
||||
p_internal = new wxThreadInternal();
|
||||
|
||||
// TODO
|
||||
}
|
||||
|
||||
wxThread::~wxThread()
|
||||
{
|
||||
Destroy();
|
||||
Join();
|
||||
delete p_internal;
|
||||
}
|
||||
|
||||
// The default callback just joins the thread and throws away the result.
|
||||
void wxThread::OnExit()
|
||||
// ----------------------------------------------------------------------------
|
||||
// Automatic initialization for thread module
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class wxThreadModule : public wxModule
|
||||
{
|
||||
Join();
|
||||
}
|
||||
|
||||
// Automatic initialization
|
||||
class wxThreadModule : public wxModule {
|
||||
DECLARE_DYNAMIC_CLASS(wxThreadModule)
|
||||
public:
|
||||
virtual bool OnInit() {
|
||||
/* TODO p_mainid = GetCurrentThread(); */
|
||||
wxMainMutex = new wxMutex();
|
||||
wxMainMutex->Lock();
|
||||
return TRUE;
|
||||
}
|
||||
virtual bool OnInit();
|
||||
virtual void OnExit();
|
||||
|
||||
// Global cleanup
|
||||
virtual void OnExit() {
|
||||
wxMainMutex->Unlock();
|
||||
delete wxMainMutex;
|
||||
}
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxThreadModule)
|
||||
};
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
|
||||
|
||||
#endif
|
||||
bool wxThreadModule::OnInit()
|
||||
{
|
||||
// allocate TLS index for storing the pointer to the current thread
|
||||
s_tlsThisThread = ::TlsAlloc();
|
||||
if ( s_tlsThisThread == 0xFFFFFFFF )
|
||||
{
|
||||
// in normal circumstances it will only happen if all other
|
||||
// TLS_MINIMUM_AVAILABLE (>= 64) indices are already taken - in other
|
||||
// words, this should never happen
|
||||
wxLogSysError(_("Thread module initialization failed: "
|
||||
"impossible to allocate index in thread "
|
||||
"local storage"));
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// main thread doesn't have associated wxThread object, so store 0 in the
|
||||
// TLS instead
|
||||
if ( !::TlsSetValue(s_tlsThisThread, (LPVOID)0) )
|
||||
{
|
||||
::TlsFree(s_tlsThisThread);
|
||||
s_tlsThisThread = 0xFFFFFFFF;
|
||||
|
||||
wxLogSysError(_("Thread module initialization failed: "
|
||||
"can not store value in thread local storage"));
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
s_critsectWaitingForGui = new wxCriticalSection();
|
||||
|
||||
s_critsectGui = new wxCriticalSection();
|
||||
s_critsectGui->Enter();
|
||||
|
||||
// no error return for GetCurrentThreadId()
|
||||
s_idMainThread = ::GetCurrentThreadId();
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void wxThreadModule::OnExit()
|
||||
{
|
||||
if ( !::TlsFree(s_tlsThisThread) )
|
||||
{
|
||||
wxLogLastError("TlsFree failed.");
|
||||
}
|
||||
|
||||
if ( s_critsectGui )
|
||||
{
|
||||
s_critsectGui->Leave();
|
||||
delete s_critsectGui;
|
||||
s_critsectGui = NULL;
|
||||
}
|
||||
|
||||
wxDELETE(s_critsectWaitingForGui);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// under Windows, these functions are implemented usign a critical section and
|
||||
// not a mutex, so the names are a bit confusing
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
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(*s_critsectWaitingForGui);
|
||||
|
||||
s_nWaitingForGui++;
|
||||
}
|
||||
|
||||
wxWakeUpMainThread();
|
||||
|
||||
// now we may block here because the main thread will soon let us in
|
||||
// (during the next iteration of OnIdle())
|
||||
s_critsectGui->Enter();
|
||||
}
|
||||
|
||||
void WXDLLEXPORT wxMutexGuiLeave()
|
||||
{
|
||||
wxCriticalSectionLocker enter(*s_critsectWaitingForGui);
|
||||
|
||||
if ( wxThread::IsMain() )
|
||||
{
|
||||
s_bGuiOwnedByMainThread = FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
// decrement the number of waiters now
|
||||
wxASSERT_MSG( s_nWaitingForGui > 0,
|
||||
wxT("calling wxMutexGuiLeave() without entering it first?") );
|
||||
|
||||
s_nWaitingForGui--;
|
||||
|
||||
wxWakeUpMainThread();
|
||||
}
|
||||
|
||||
s_critsectGui->Leave();
|
||||
}
|
||||
|
||||
void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
|
||||
{
|
||||
wxASSERT_MSG( wxThread::IsMain(),
|
||||
wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
|
||||
|
||||
wxCriticalSectionLocker enter(*s_critsectWaitingForGui);
|
||||
|
||||
if ( s_nWaitingForGui == 0 )
|
||||
{
|
||||
// no threads are waiting for GUI - so we may acquire the lock without
|
||||
// any danger (but only if we don't already have it)
|
||||
if ( !wxGuiOwnedByMainThread() )
|
||||
{
|
||||
s_critsectGui->Enter();
|
||||
|
||||
s_bGuiOwnedByMainThread = TRUE;
|
||||
}
|
||||
//else: already have it, nothing to do
|
||||
}
|
||||
else
|
||||
{
|
||||
// some threads are waiting, release the GUI lock if we have it
|
||||
if ( wxGuiOwnedByMainThread() )
|
||||
{
|
||||
wxMutexGuiLeave();
|
||||
}
|
||||
//else: some other worker thread is doing GUI
|
||||
}
|
||||
}
|
||||
|
||||
bool WXDLLEXPORT wxGuiOwnedByMainThread()
|
||||
{
|
||||
return s_bGuiOwnedByMainThread;
|
||||
}
|
||||
|
||||
// wake up the main thread if it's in ::GetMessage()
|
||||
void WXDLLEXPORT wxWakeUpMainThread()
|
||||
{
|
||||
// sending any message would do - hopefully WM_NULL is harmless enough
|
||||
if ( !::PostThreadMessage(s_idMainThread, WM_NULL, 0, 0) )
|
||||
{
|
||||
// should never happen
|
||||
wxLogLastError("PostThreadMessage(WM_NULL)");
|
||||
}
|
||||
}
|
||||
|
||||
bool WXDLLEXPORT wxIsWaitingForThread()
|
||||
{
|
||||
return s_waitingForThread;
|
||||
}
|
||||
*/
|
||||
|
||||
#endif // wxUSE_THREADS
|
||||
|
||||
Reference in New Issue
Block a user