src/mac/carbon/thread.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        thread.cpp
// Purpose:     wxThread Implementation
// Author:      Original from Wolfram Gloger/Guilhem Lavaux/Vadim Zeitlin
// Modified by: Stefan Csomor
// Created:     04/22/98
// RCS-ID:      $Id$
// Copyright:   (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998),
//                  Vadim Zeitlin (1999) , Stefan Csomor (2000)
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

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

// 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

#include "wx/module.h"
#include "wx/thread.h"

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// 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
};

// ----------------------------------------------------------------------------
// this module globals
// ----------------------------------------------------------------------------

static ThreadID gs_idMainThread = kNoThreadID ;
static bool gs_waitingForThread = FALSE ;

// ============================================================================
// MacOS implementation of thread classes
// ============================================================================

class wxMacStCritical
{
public :
	wxMacStCritical()
	{
		ThreadBeginCritical() ;
	}
	~wxMacStCritical()
	{
		ThreadEndCritical() ;
	}
} ;

// ----------------------------------------------------------------------------
// wxMutex implementation
// ----------------------------------------------------------------------------

class wxMutexInternal
{
public:
    wxMutexInternal()
    {
    	m_owner = kNoThreadID ;
    }

    ~wxMutexInternal()
    {
    }

public:
    ThreadID m_owner ;
    wxArrayLong m_waiters ;
};

wxMutex::wxMutex()
{
    m_internal = new wxMutexInternal;

    m_locked = 0;
}

wxMutex::~wxMutex()
{
    if ( m_locked > 0 )
    {
        wxLogDebug(_T("Warning: freeing a locked mutex (%d locks)."), m_locked);
    }

    delete m_internal;
}

wxMutexError wxMutex::Lock()
{
	wxMacStCritical critical ;

	OSErr err ;
	ThreadID current = kNoThreadID;
	err = ::MacGetCurrentThread(&current);
	// if we are not the owner, add this thread to the list of waiting threads, stop this thread
	// and invoke the scheduler to continue executing the owner's thread
	while ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current)
	{
		m_internal->m_waiters.Add(current);
		err = ::SetThreadStateEndCritical(kCurrentThreadID, kStoppedThreadState, m_internal->m_owner);
		err = ::ThreadBeginCritical();
	}
	m_internal->m_owner = current;
    m_locked++;

    return wxMUTEX_NO_ERROR;
}

wxMutexError wxMutex::TryLock()
{
	wxMacStCritical critical ;

	OSErr err ;
	ThreadID current = kNoThreadID;
	::MacGetCurrentThread(&current);
	// if we are not the owner, give an error back
	if ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current )
        return wxMUTEX_BUSY;

	m_internal->m_owner = current;
    m_locked++;

   return wxMUTEX_NO_ERROR;
}

wxMutexError wxMutex::Unlock()
{
	OSErr err;
	err = ::ThreadBeginCritical();

    if (m_locked > 0)
        m_locked--;

	// this mutex is not owned by anybody anmore
	m_internal->m_owner = kNoThreadID;

	// now pass on to the first waiting thread
	ThreadID firstWaiting = kNoThreadID;
	bool found = false;
	while (!m_internal->m_waiters.IsEmpty() && !found)
	{
		firstWaiting = m_internal->m_waiters[0];
		err = ::SetThreadState(firstWaiting, kReadyThreadState, kNoThreadID);
		// in case this was not successful (dead thread), we just loop on and reset the id
		found = (err != threadNotFoundErr);
		if ( !found )
			firstWaiting = kNoThreadID ;
		m_internal->m_waiters.RemoveAt(0) ;
	}
	// now we have a valid firstWaiting thread, which has been scheduled to run next, just end the
	// critical section and invoke the scheduler
	err = ::SetThreadStateEndCritical(kCurrentThreadID, kReadyThreadState, firstWaiting);

    return wxMUTEX_NO_ERROR;
}

// ----------------------------------------------------------------------------
// wxCondition implementation
// ----------------------------------------------------------------------------

class wxConditionInternal
{
public:
    wxConditionInternal()
    {
    	m_excessSignals = 0 ;
    }
    ~wxConditionInternal()
    {
    }

    bool Wait(unsigned long msectimeout)
    {
		wxMacStCritical critical ;
    	if ( m_excessSignals > 0 )
    	{
    		--m_excessSignals ;
    		return TRUE ;
    	}
    	else if ( msectimeout == 0 )
    	{
    		return FALSE ;
    	}
    	else
    	{
		}
		/*
        waiters++;

        // FIXME this should be MsgWaitForMultipleObjects() as well probably
        DWORD rc = ::WaitForSingleObject(event, timeout);

        waiters--;

        return rc != WAIT_TIMEOUT;
        */
        return TRUE ;
    }
	void Signal()
	{
		wxMacStCritical critical ;
	}

    wxArrayLong m_waiters ;
    wxInt32		m_excessSignals ;
};

wxCondition::wxCondition()
{
    m_internal = new wxConditionInternal;
}

wxCondition::~wxCondition()
{
    delete m_internal;
}

void wxCondition::Wait()
{
    (void)m_internal->Wait(0xFFFFFFFFL );
}

bool wxCondition::Wait(unsigned long sec,
                       unsigned long nsec)
{
    return m_internal->Wait(sec*1000 + nsec/1000000);
}

void wxCondition::Signal()
{
    // set the event to signaled: if a thread is already waiting on it, it will
    // be woken up, otherwise the event will remain in the signaled state until
    // someone waits on it. In any case, the system will return it to a non
    // signalled state afterwards. If multiple threads are waiting, only one
    // will be woken up.
	m_internal->Signal() ;
}

void wxCondition::Broadcast()
{
    // this works because all these threads are already waiting and so each
    // SetEvent() inside Signal() is really a PulseEvent() because the event
    // state is immediately returned to non-signaled
    for ( int i = 0; i < m_internal->m_waiters.Count(); i++ )
    {
        Signal();
    }
}

// ----------------------------------------------------------------------------
// wxCriticalSection implementation
// ----------------------------------------------------------------------------

// it's implemented as a mutex on mac os, so it is defined in the headers

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

// wxThreadInternal class
// ----------------------

class wxThreadInternal
{
public:
    wxThreadInternal()
    {
        m_tid = kNoThreadID ;
        m_state = STATE_NEW;
        m_priority = WXTHREAD_DEFAULT_PRIORITY;
    }

    ~wxThreadInternal()
    {
    }

    void Free()
    {
    }

    // 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);
    unsigned int GetPriority() const { return m_priority; }

    void SetResult( void *res ) { m_result = res ; }
    void *GetResult() { return m_result ; }

    // thread handle and id
    ThreadID  GetId() const { return m_tid; }

    // thread function
	static pascal void*	MacThreadStart(wxThread* arg);

private:
    wxThreadState 	m_state;      // state, see wxThreadState enum
    unsigned int  	m_priority;   // thread priority in "wx" units
    ThreadID        m_tid;        // thread id
    void *			m_result ;
    static ThreadEntryUPP s_threadEntry ;
public :
};

static wxArrayPtrVoid s_threads ;

ThreadEntryUPP wxThreadInternal::s_threadEntry = NULL ;
pascal void* wxThreadInternal::MacThreadStart(wxThread *thread)
{
    // first of all, check whether we hadn't been cancelled already
    if ( thread->m_internal->GetState() == STATE_EXITED )
    {
        return (void*)-1;
    }

    void* rc = thread->Entry();

    // enter m_critsect before changing the thread state
    thread->m_critsect.Enter();
    bool wasCancelled = thread->m_internal->GetState() == STATE_CANCELED;
    thread->m_internal->SetState(STATE_EXITED);
    thread->m_critsect.Leave();

    thread->OnExit();

    // if the thread was cancelled (from Delete()), then it the handle is still
    // needed there
    if ( thread->IsDetached() && !wasCancelled )
    {
        // auto delete
        delete thread;
    }
    //else: the joinable threads handle will be closed when Wait() is done

    return rc;
}
void wxThreadInternal::SetPriority(unsigned int priority)
{
	// Priorities don't exist on Mac
}

bool wxThreadInternal::Create(wxThread *thread)
{
	if ( s_threadEntry == NULL )
	{
		s_threadEntry = NewThreadEntryUPP( (ThreadEntryProcPtr) MacThreadStart ) ;
	}
	OSErr err = NewThread(kCooperativeThread,
		s_threadEntry,
		(void*) thread ,
		0 ,
		kNewSuspend ,
		&m_result ,
		&m_tid ) ;

    if ( err != noErr )
    {
        wxLogSysError(_("Can't create thread"));
        return FALSE;
    }

    if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
    {
        SetPriority(m_priority);
    }

    return TRUE;
}

bool wxThreadInternal::Suspend()
{
	OSErr err ;

	::ThreadBeginCritical();

	if ( m_state != STATE_RUNNING )
    {
    	::ThreadEndCritical() ;
        wxLogSysError(_("Can not suspend thread %x"), m_tid);
        return FALSE;
    }

    m_state = STATE_PAUSED;

	err = ::SetThreadStateEndCritical(m_tid, kStoppedThreadState, kNoThreadID);

    return TRUE;
}

bool wxThreadInternal::Resume()
{
	ThreadID current ;
	OSErr err ;
	err = MacGetCurrentThread( &current ) ;

	wxASSERT( err == noErr ) ;
	wxASSERT( current != m_tid ) ;

	::ThreadBeginCritical();
	if ( m_state != STATE_PAUSED && m_state != STATE_NEW )
	{
    	::ThreadEndCritical() ;
        wxLogSysError(_("Can not resume thread %x"), m_tid);
        return FALSE;

	}
	err = ::SetThreadStateEndCritical(m_tid, kReadyThreadState, kNoThreadID);
	wxASSERT( err == noErr ) ;

    m_state = STATE_RUNNING;
	::ThreadEndCritical() ;
	::YieldToAnyThread() ;
    return TRUE;
}

// static functions
// ----------------
wxThread *wxThread::This()
{
	wxMacStCritical critical ;

	ThreadID current ;
	OSErr err ;

	err = MacGetCurrentThread( &current ) ;

	for ( int i = 0 ; i < s_threads.Count() ; ++i )
	{
		if ( ( (wxThread*) s_threads[i] )->GetId() == current )
			return (wxThread*) s_threads[i] ;
	}

    wxLogSysError(_("Couldn't get the current thread pointer"));
    return NULL;
}

bool wxThread::IsMain()
{
	ThreadID current ;
	OSErr err ;

	err = MacGetCurrentThread( &current ) ;
    return current == gs_idMainThread;
}

#ifdef Yield
#undef Yield
#endif

void wxThread::Yield()
{
	::YieldToAnyThread() ;
}

void wxThread::Sleep(unsigned long milliseconds)
{
		clock_t start = clock() ;
		do
		{
			YieldToAnyThread() ;
		} while( clock() - start < milliseconds / CLOCKS_PER_SEC ) ;
}

int wxThread::GetCPUCount()
{
	// we will use whatever MP API will be used for the new MP Macs
    return 1;
}

bool wxThread::SetConcurrency(size_t level)
{
    wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );

    // ok only for the default one
    if ( level == 0 )
        return 0;

    // how many CPUs have we got?
    if ( GetCPUCount() == 1 )
    {
        // don't bother with all this complicated stuff - on a single
        // processor system it doesn't make much sense anyhow
        return level == 1;
    }

    return TRUE ;
}

// ctor and dtor
// -------------

wxThread::wxThread(wxThreadKind kind)
{
    m_internal = new wxThreadInternal();

    m_isDetached = kind == wxTHREAD_DETACHED;
    s_threads.Add( (void*) this ) ;
}

wxThread::~wxThread()
{
	s_threads.Remove( (void*) this ) ;
    delete m_internal;
}

// create/start thread
// -------------------

wxThreadError wxThread::Create()
{
    wxCriticalSectionLocker lock(m_critsect);

    if ( !m_internal->Create(this) )
        return wxTHREAD_NO_RESOURCE;

    return wxTHREAD_NO_ERROR;
}

wxThreadError wxThread::Run()
{
    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;
    }

    // the thread has just been created and is still suspended - let it run
    return Resume();
}

// suspend/resume thread
// ---------------------

wxThreadError wxThread::Pause()
{
    wxCriticalSectionLocker lock(m_critsect);

    return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
}

wxThreadError wxThread::Resume()
{
    wxCriticalSectionLocker lock(m_critsect);

    return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
}

// stopping thread
// ---------------

wxThread::ExitCode wxThread::Wait()
{
    // although under MacOS we can wait for any thread, it's an error to
    // wait for a detached one in wxWin API
    wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
                 _T("can't wait for detached thread") );

    ExitCode rc = (ExitCode)-1;

    (void)Delete(&rc);

    m_internal->Free();

    return rc;
}

wxThreadError wxThread::Delete(ExitCode *pRc)
{
    ExitCode rc = 0;

    // Delete() is always safe to call, so consider all possible states

    // has the thread started to run?
    bool shouldResume = FALSE;

    {
        wxCriticalSectionLocker lock(m_critsect);

        if ( m_internal->GetState() == STATE_NEW )
        {
            // WinThreadStart() will see it and terminate immediately
            m_internal->SetState(STATE_EXITED);

            shouldResume = TRUE;
        }
    }

    // is the thread paused?
    if ( shouldResume || IsPaused() )
        Resume();

    // does is still run?
    if ( IsRunning() )
    {
        if ( IsMain() )
        {
            // set flag for wxIsWaitingForThread()
            gs_waitingForThread = TRUE;

#if wxUSE_GUI
            wxBeginBusyCursor();
#endif // wxUSE_GUI
        }

        // ask the thread to terminate
        {
            wxCriticalSectionLocker lock(m_critsect);

            m_internal->Cancel();
        }

#if wxUSE_GUI
        // simply wait for the thread to terminate
		while( TestDestroy() )
		{
			::YieldToAnyThread() ;
		}
#else // !wxUSE_GUI
        // simply wait for the thread to terminate
		while( TestDestroy() )
		{
			::YieldToAnyThread() ;
		}
#endif // wxUSE_GUI/!wxUSE_GUI

        if ( IsMain() )
        {
            gs_waitingForThread = FALSE;

#if wxUSE_GUI
            wxEndBusyCursor();
#endif // wxUSE_GUI
        }
    }

 //   if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
    {
        wxLogLastError("GetExitCodeThread");

        rc = (ExitCode)-1;
    }

    if ( IsDetached() )
    {
        // if the thread exits normally, this is done in WinThreadStart, but in
        // this case it would have been too early because
        // MsgWaitForMultipleObject() would fail if the therad handle was
        // closed while we were waiting on it, so we must do it here
        delete this;
    }

 //   wxASSERT_MSG( (DWORD)rc != STILL_ACTIVE,
 //                 wxT("thread must be already terminated.") );

    if ( pRc )
        *pRc = rc;

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

wxThreadError wxThread::Kill()
{
    if ( !IsRunning() )
        return wxTHREAD_NOT_RUNNING;

//    if ( !::TerminateThread(m_internal->GetHandle(), (DWORD)-1) )
    {
        wxLogSysError(_("Couldn't terminate thread"));

        return wxTHREAD_MISC_ERROR;
    }

    m_internal->Free();

    if ( IsDetached() )
    {
        delete this;
    }

    return wxTHREAD_NO_ERROR;
}

void wxThread::Exit(ExitCode status)
{
    m_internal->Free();

    if ( IsDetached() )
    {
        delete this;
    }

	m_internal->SetResult( status ) ;

/*
#if defined(__VISUALC__) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500))
    _endthreadex((unsigned)status);
#else // !VC++
    ::ExitThread((DWORD)status);
#endif // VC++/!VC++
*/
    wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
}

// priority setting
// ----------------

// since all these calls are execute cooperatively we don't have to use the critical section

void wxThread::SetPriority(unsigned int prio)
{
    m_internal->SetPriority(prio);
}

unsigned int wxThread::GetPriority() const
{
    return m_internal->GetPriority();
}

unsigned long wxThread::GetId() const
{
    return (unsigned long)m_internal->GetId();
}

bool wxThread::IsRunning() const
{
    return m_internal->GetState() == STATE_RUNNING;
}

bool wxThread::IsAlive() const
{
    return (m_internal->GetState() == STATE_RUNNING) ||
           (m_internal->GetState() == STATE_PAUSED);
}

bool wxThread::IsPaused() const
{
    return m_internal->GetState() == STATE_PAUSED;
}

bool wxThread::TestDestroy()
{
    return m_internal->GetState() == STATE_CANCELED;
}

// ----------------------------------------------------------------------------
// Automatic initialization for thread module
// ----------------------------------------------------------------------------

class wxThreadModule : public wxModule
{
public:
    virtual bool OnInit();
    virtual void OnExit();

private:
    DECLARE_DYNAMIC_CLASS(wxThreadModule)
};

IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)

bool wxThreadModule::OnInit()
{
	long response;
	bool hasThreadManager ;
	hasThreadManager = Gestalt( gestaltThreadMgrAttr, &response) == noErr && response & 1;
#if GENERATINGPOWERPC || GENERATINGCFM
	// verify presence of shared library
	hasThreadManager = hasThreadManager && ((Ptr)NewThread != (Ptr)kUnresolvedCFragSymbolAddress);
#endif
	if ( !hasThreadManager )
	{
		wxMessageBox( "Error" , "Thread Support is not available on this System" , wxOK ) ;
		return FALSE ;
	}

    // no error return for GetCurrentThreadId()
    MacGetCurrentThread( &gs_idMainThread ) ;

    return TRUE;
}

void wxThreadModule::OnExit()
{
}

// ----------------------------------------------------------------------------
// under MacOS we don't have currently preemptive threads, so any thread may access
// the GUI at any time
// ----------------------------------------------------------------------------

void WXDLLEXPORT wxMutexGuiEnter()
{
}

void WXDLLEXPORT wxMutexGuiLeave()
{
}

void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
{
}

bool WXDLLEXPORT wxGuiOwnedByMainThread()
{
    return false ;
}

// wake up the main thread
void WXDLLEXPORT wxWakeUpMainThread()
{
	wxMacWakeUp() ;
}

bool WXDLLEXPORT wxIsWaitingForThread()
{
    return false ;
}

#endif // wxUSE_THREADS
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: thread.cpp
	3	// Purpose: wxThread Implementation
	4	// Author: Original from Wolfram Gloger/Guilhem Lavaux/Vadim Zeitlin
	5	// Modified by: Stefan Csomor
	6	// Created: 04/22/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998),
	9	// Vadim Zeitlin (1999) , Stefan Csomor (2000)
	10	// Licence: wxWindows licence
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	#ifdef __GNUG__
	14	#pragma implementation "thread.h"
	15	#endif
	16
	17	// ----------------------------------------------------------------------------
	18	// headers
	19	// ----------------------------------------------------------------------------
	20
	21	// For compilers that support precompilation, includes "wx.h".
	22	#include "wx/wxprec.h"
	23
	24	#if defined(__BORLANDC__)
	25	#pragma hdrstop
	26	#endif
	27
	28	#ifndef WX_PRECOMP
	29	#include "wx/wx.h"
	30	#endif
	31
	32	#if wxUSE_THREADS
	33
	34	#include "wx/module.h"
	35	#include "wx/thread.h"
	36
	37	// ----------------------------------------------------------------------------
	38	// constants
	39	// ----------------------------------------------------------------------------
	40
	41	// the possible states of the thread ("=>" shows all possible transitions from
	42	// this state)
	43	enum wxThreadState
	44	{
	45	STATE_NEW, // didn't start execution yet (=> RUNNING)
	46	STATE_RUNNING, // thread is running (=> PAUSED, CANCELED)
	47	STATE_PAUSED, // thread is temporarily suspended (=> RUNNING)
	48	STATE_CANCELED, // thread should terminate a.s.a.p. (=> EXITED)
	49	STATE_EXITED // thread is terminating
	50	};
	51
	52	// ----------------------------------------------------------------------------
	53	// this module globals
	54	// ----------------------------------------------------------------------------
	55
	56	static ThreadID gs_idMainThread = kNoThreadID ;
	57	static bool gs_waitingForThread = FALSE ;
	58
	59	// ============================================================================
	60	// MacOS implementation of thread classes
	61	// ============================================================================
	62
	63	class wxMacStCritical
	64	{
	65	public :
	66	wxMacStCritical()
	67	{
	68	ThreadBeginCritical() ;
	69	}
	70	~wxMacStCritical()
	71	{
	72	ThreadEndCritical() ;
	73	}
	74	} ;
	75
	76	// ----------------------------------------------------------------------------
	77	// wxMutex implementation
	78	// ----------------------------------------------------------------------------
	79
	80	class wxMutexInternal
	81	{
	82	public:
	83	wxMutexInternal()
	84	{
	85	m_owner = kNoThreadID ;
	86	}
	87
	88	~wxMutexInternal()
	89	{
	90	}
	91
	92	public:
	93	ThreadID m_owner ;
	94	wxArrayLong m_waiters ;
	95	};
	96
	97	wxMutex::wxMutex()
	98	{
	99	m_internal = new wxMutexInternal;
	100
	101	m_locked = 0;
	102	}
	103
	104	wxMutex::~wxMutex()
	105	{
	106	if ( m_locked > 0 )
	107	{
	108	wxLogDebug(_T("Warning: freeing a locked mutex (%d locks)."), m_locked);
	109	}
	110
	111	delete m_internal;
	112	}
	113
	114	wxMutexError wxMutex::Lock()
	115	{
	116	wxMacStCritical critical ;
	117
	118	OSErr err ;
	119	ThreadID current = kNoThreadID;
	120	err = ::MacGetCurrentThread(&current);
	121	// if we are not the owner, add this thread to the list of waiting threads, stop this thread
	122	// and invoke the scheduler to continue executing the owner's thread
	123	while ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current)
	124	{
	125	m_internal->m_waiters.Add(current);
	126	err = ::SetThreadStateEndCritical(kCurrentThreadID, kStoppedThreadState, m_internal->m_owner);
	127	err = ::ThreadBeginCritical();
	128	}
	129	m_internal->m_owner = current;
	130	m_locked++;
	131
	132	return wxMUTEX_NO_ERROR;
	133	}
	134
	135	wxMutexError wxMutex::TryLock()
	136	{
	137	wxMacStCritical critical ;
	138
	139	OSErr err ;
	140	ThreadID current = kNoThreadID;
	141	::MacGetCurrentThread(&current);
	142	// if we are not the owner, give an error back
	143	if ( m_internal->m_owner != kNoThreadID && m_internal->m_owner != current )
	144	return wxMUTEX_BUSY;
	145
	146	m_internal->m_owner = current;
	147	m_locked++;
	148
	149	return wxMUTEX_NO_ERROR;
	150	}
	151
	152	wxMutexError wxMutex::Unlock()
	153	{
	154	OSErr err;
	155	err = ::ThreadBeginCritical();
	156
	157	if (m_locked > 0)
	158	m_locked--;
	159
	160	// this mutex is not owned by anybody anmore
	161	m_internal->m_owner = kNoThreadID;
	162
	163	// now pass on to the first waiting thread
	164	ThreadID firstWaiting = kNoThreadID;
	165	bool found = false;
	166	while (!m_internal->m_waiters.IsEmpty() && !found)
	167	{
	168	firstWaiting = m_internal->m_waiters[0];
	169	err = ::SetThreadState(firstWaiting, kReadyThreadState, kNoThreadID);
	170	// in case this was not successful (dead thread), we just loop on and reset the id
	171	found = (err != threadNotFoundErr);
	172	if ( !found )
	173	firstWaiting = kNoThreadID ;
	174	m_internal->m_waiters.RemoveAt(0) ;
	175	}
	176	// now we have a valid firstWaiting thread, which has been scheduled to run next, just end the
	177	// critical section and invoke the scheduler
	178	err = ::SetThreadStateEndCritical(kCurrentThreadID, kReadyThreadState, firstWaiting);
	179
	180	return wxMUTEX_NO_ERROR;
	181	}
	182
	183	// ----------------------------------------------------------------------------
	184	// wxCondition implementation
	185	// ----------------------------------------------------------------------------
	186
	187	class wxConditionInternal
	188	{
	189	public:
	190	wxConditionInternal()
	191	{
	192	m_excessSignals = 0 ;
	193	}
	194	~wxConditionInternal()
	195	{
	196	}
	197
	198	bool Wait(unsigned long msectimeout)
	199	{
	200	wxMacStCritical critical ;
	201	if ( m_excessSignals > 0 )
	202	{
	203	--m_excessSignals ;
	204	return TRUE ;
	205	}
	206	else if ( msectimeout == 0 )
	207	{
	208	return FALSE ;
	209	}
	210	else
	211	{
	212	}
	213	/*
	214	waiters++;
	215
	216	// FIXME this should be MsgWaitForMultipleObjects() as well probably
	217	DWORD rc = ::WaitForSingleObject(event, timeout);
	218
	219	waiters--;
	220
	221	return rc != WAIT_TIMEOUT;
	222	*/
	223	return TRUE ;
	224	}
	225	void Signal()
	226	{
	227	wxMacStCritical critical ;
	228	}
	229
	230	wxArrayLong m_waiters ;
	231	wxInt32 m_excessSignals ;
	232	};
	233
	234	wxCondition::wxCondition()
	235	{
	236	m_internal = new wxConditionInternal;
	237	}
	238
	239	wxCondition::~wxCondition()
	240	{
	241	delete m_internal;
	242	}
	243
	244	void wxCondition::Wait()
	245	{
	246	(void)m_internal->Wait(0xFFFFFFFFL );
	247	}
	248
	249	bool wxCondition::Wait(unsigned long sec,
	250	unsigned long nsec)
	251	{
	252	return m_internal->Wait(sec*1000 + nsec/1000000);
	253	}
	254
	255	void wxCondition::Signal()
	256	{
	257	// set the event to signaled: if a thread is already waiting on it, it will
	258	// be woken up, otherwise the event will remain in the signaled state until
	259	// someone waits on it. In any case, the system will return it to a non
	260	// signalled state afterwards. If multiple threads are waiting, only one
	261	// will be woken up.
	262	m_internal->Signal() ;
	263	}
	264
	265	void wxCondition::Broadcast()
	266	{
	267	// this works because all these threads are already waiting and so each
	268	// SetEvent() inside Signal() is really a PulseEvent() because the event
	269	// state is immediately returned to non-signaled
	270	for ( int i = 0; i < m_internal->m_waiters.Count(); i++ )
	271	{
	272	Signal();
	273	}
	274	}
	275
	276	// ----------------------------------------------------------------------------
	277	// wxCriticalSection implementation
	278	// ----------------------------------------------------------------------------
	279
	280	// it's implemented as a mutex on mac os, so it is defined in the headers
	281
	282	// ----------------------------------------------------------------------------
	283	// wxThread implementation
	284	// ----------------------------------------------------------------------------
	285
	286	// wxThreadInternal class
	287	// ----------------------
	288
	289	class wxThreadInternal
	290	{
	291	public:
	292	wxThreadInternal()
	293	{
	294	m_tid = kNoThreadID ;
	295	m_state = STATE_NEW;
	296	m_priority = WXTHREAD_DEFAULT_PRIORITY;
	297	}
	298
	299	~wxThreadInternal()
	300	{
	301	}
	302
	303	void Free()
	304	{
	305	}
	306
	307	// create a new (suspended) thread (for the given thread object)
	308	bool Create(wxThread *thread);
	309
	310	// suspend/resume/terminate
	311	bool Suspend();
	312	bool Resume();
	313	void Cancel() { m_state = STATE_CANCELED; }
	314
	315	// thread state
	316	void SetState(wxThreadState state) { m_state = state; }
	317	wxThreadState GetState() const { return m_state; }
	318
	319	// thread priority
	320	void SetPriority(unsigned int priority);
	321	unsigned int GetPriority() const { return m_priority; }
	322
	323	void SetResult( void *res ) { m_result = res ; }
	324	void *GetResult() { return m_result ; }
	325
	326	// thread handle and id
	327	ThreadID GetId() const { return m_tid; }
	328
	329	// thread function
	330	static pascal void* MacThreadStart(wxThread* arg);
	331
	332	private:
	333	wxThreadState m_state; // state, see wxThreadState enum
	334	unsigned int m_priority; // thread priority in "wx" units
	335	ThreadID m_tid; // thread id
	336	void * m_result ;
	337	static ThreadEntryUPP s_threadEntry ;
	338	public :
	339	};
	340
	341	static wxArrayPtrVoid s_threads ;
	342
	343	ThreadEntryUPP wxThreadInternal::s_threadEntry = NULL ;
	344	pascal void* wxThreadInternal::MacThreadStart(wxThread *thread)
	345	{
	346	// first of all, check whether we hadn't been cancelled already
	347	if ( thread->m_internal->GetState() == STATE_EXITED )
	348	{
	349	return (void*)-1;
	350	}
	351
	352	void* rc = thread->Entry();
	353
	354	// enter m_critsect before changing the thread state
	355	thread->m_critsect.Enter();
	356	bool wasCancelled = thread->m_internal->GetState() == STATE_CANCELED;
	357	thread->m_internal->SetState(STATE_EXITED);
	358	thread->m_critsect.Leave();
	359
	360	thread->OnExit();
	361
	362	// if the thread was cancelled (from Delete()), then it the handle is still
	363	// needed there
	364	if ( thread->IsDetached() && !wasCancelled )
	365	{
	366	// auto delete
	367	delete thread;
	368	}
	369	//else: the joinable threads handle will be closed when Wait() is done
	370
	371	return rc;
	372	}
	373	void wxThreadInternal::SetPriority(unsigned int priority)
	374	{
	375	// Priorities don't exist on Mac
	376	}
	377
	378	bool wxThreadInternal::Create(wxThread *thread)
	379	{
	380	if ( s_threadEntry == NULL )
	381	{
	382	s_threadEntry = NewThreadEntryUPP( (ThreadEntryProcPtr) MacThreadStart ) ;
	383	}
	384	OSErr err = NewThread(kCooperativeThread,
	385	s_threadEntry,
	386	(void*) thread ,
	387	0 ,
	388	kNewSuspend ,
	389	&m_result ,
	390	&m_tid ) ;
	391
	392	if ( err != noErr )
	393	{
	394	wxLogSysError(_("Can't create thread"));
	395	return FALSE;
	396	}
	397
	398	if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
	399	{
	400	SetPriority(m_priority);
	401	}
	402
	403	return TRUE;
	404	}
	405
	406	bool wxThreadInternal::Suspend()
	407	{
	408	OSErr err ;
	409
	410	::ThreadBeginCritical();
	411
	412	if ( m_state != STATE_RUNNING )
	413	{
	414	::ThreadEndCritical() ;
	415	wxLogSysError(_("Can not suspend thread %x"), m_tid);
	416	return FALSE;
	417	}
	418
	419	m_state = STATE_PAUSED;
	420
	421	err = ::SetThreadStateEndCritical(m_tid, kStoppedThreadState, kNoThreadID);
	422
	423	return TRUE;
	424	}
	425
	426	bool wxThreadInternal::Resume()
	427	{
	428	ThreadID current ;
	429	OSErr err ;
	430	err = MacGetCurrentThread( &current ) ;
	431
	432	wxASSERT( err == noErr ) ;
	433	wxASSERT( current != m_tid ) ;
	434
	435	::ThreadBeginCritical();
	436	if ( m_state != STATE_PAUSED && m_state != STATE_NEW )
	437	{
	438	::ThreadEndCritical() ;
	439	wxLogSysError(_("Can not resume thread %x"), m_tid);
	440	return FALSE;
	441
	442	}
	443	err = ::SetThreadStateEndCritical(m_tid, kReadyThreadState, kNoThreadID);
	444	wxASSERT( err == noErr ) ;
	445
	446	m_state = STATE_RUNNING;
	447	::ThreadEndCritical() ;
	448	::YieldToAnyThread() ;
	449	return TRUE;
	450	}
	451
	452	// static functions
	453	// ----------------
	454	wxThread *wxThread::This()
	455	{
	456	wxMacStCritical critical ;
	457
	458	ThreadID current ;
	459	OSErr err ;
	460
	461	err = MacGetCurrentThread( &current ) ;
	462
	463	for ( int i = 0 ; i < s_threads.Count() ; ++i )
	464	{
	465	if ( ( (wxThread*) s_threads[i] )->GetId() == current )
	466	return (wxThread*) s_threads[i] ;
	467	}
	468
	469	wxLogSysError(_("Couldn't get the current thread pointer"));
	470	return NULL;
	471	}
	472
	473	bool wxThread::IsMain()
	474	{
	475	ThreadID current ;
	476	OSErr err ;
	477
	478	err = MacGetCurrentThread( &current ) ;
	479	return current == gs_idMainThread;
	480	}
	481
	482	#ifdef Yield
	483	#undef Yield
	484	#endif
	485
	486	void wxThread::Yield()
	487	{
	488	::YieldToAnyThread() ;
	489	}
	490
	491	void wxThread::Sleep(unsigned long milliseconds)
	492	{
	493	clock_t start = clock() ;
	494	do
	495	{
	496	YieldToAnyThread() ;
	497	} while( clock() - start < milliseconds / CLOCKS_PER_SEC ) ;
	498	}
	499
	500	int wxThread::GetCPUCount()
	501	{
	502	// we will use whatever MP API will be used for the new MP Macs
	503	return 1;
	504	}
	505
	506	bool wxThread::SetConcurrency(size_t level)
	507	{
	508	wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
	509
	510	// ok only for the default one
	511	if ( level == 0 )
	512	return 0;
	513
	514	// how many CPUs have we got?
	515	if ( GetCPUCount() == 1 )
	516	{
	517	// don't bother with all this complicated stuff - on a single
	518	// processor system it doesn't make much sense anyhow
	519	return level == 1;
	520	}
	521
	522	return TRUE ;
	523	}
	524
	525	// ctor and dtor
	526	// -------------
	527
	528	wxThread::wxThread(wxThreadKind kind)
	529	{
	530	m_internal = new wxThreadInternal();
	531
	532	m_isDetached = kind == wxTHREAD_DETACHED;
	533	s_threads.Add( (void*) this ) ;
	534	}
	535
	536	wxThread::~wxThread()
	537	{
	538	s_threads.Remove( (void*) this ) ;
	539	delete m_internal;
	540	}
	541
	542	// create/start thread
	543	// -------------------
	544
	545	wxThreadError wxThread::Create()
	546	{
	547	wxCriticalSectionLocker lock(m_critsect);
	548
	549	if ( !m_internal->Create(this) )
	550	return wxTHREAD_NO_RESOURCE;
	551
	552	return wxTHREAD_NO_ERROR;
	553	}
	554
	555	wxThreadError wxThread::Run()
	556	{
	557	wxCriticalSectionLocker lock(m_critsect);
	558
	559	if ( m_internal->GetState() != STATE_NEW )
	560	{
	561	// actually, it may be almost any state at all, not only STATE_RUNNING
	562	return wxTHREAD_RUNNING;
	563	}
	564
	565	// the thread has just been created and is still suspended - let it run
	566	return Resume();
	567	}
	568
	569	// suspend/resume thread
	570	// ---------------------
	571
	572	wxThreadError wxThread::Pause()
	573	{
	574	wxCriticalSectionLocker lock(m_critsect);
	575
	576	return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
	577	}
	578
	579	wxThreadError wxThread::Resume()
	580	{
	581	wxCriticalSectionLocker lock(m_critsect);
	582
	583	return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
	584	}
	585
	586	// stopping thread
	587	// ---------------
	588
	589	wxThread::ExitCode wxThread::Wait()
	590	{
	591	// although under MacOS we can wait for any thread, it's an error to
	592	// wait for a detached one in wxWin API
	593	wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
	594	_T("can't wait for detached thread") );
	595
	596	ExitCode rc = (ExitCode)-1;
	597
	598	(void)Delete(&rc);
	599
	600	m_internal->Free();
	601
	602	return rc;
	603	}
	604
	605	wxThreadError wxThread::Delete(ExitCode *pRc)
	606	{
	607	ExitCode rc = 0;
	608
	609	// Delete() is always safe to call, so consider all possible states
	610
	611	// has the thread started to run?
	612	bool shouldResume = FALSE;
	613
	614	{
	615	wxCriticalSectionLocker lock(m_critsect);
	616
	617	if ( m_internal->GetState() == STATE_NEW )
	618	{
	619	// WinThreadStart() will see it and terminate immediately
	620	m_internal->SetState(STATE_EXITED);
	621
	622	shouldResume = TRUE;
	623	}
	624	}
	625
	626	// is the thread paused?
	627	if ( shouldResume \|\| IsPaused() )
	628	Resume();
	629
	630	// does is still run?
	631	if ( IsRunning() )
	632	{
	633	if ( IsMain() )
	634	{
	635	// set flag for wxIsWaitingForThread()
	636	gs_waitingForThread = TRUE;
	637
	638	#if wxUSE_GUI
	639	wxBeginBusyCursor();
	640	#endif // wxUSE_GUI
	641	}
	642
	643	// ask the thread to terminate
	644	{
	645	wxCriticalSectionLocker lock(m_critsect);
	646
	647	m_internal->Cancel();
	648	}
	649
	650	#if wxUSE_GUI
	651	// simply wait for the thread to terminate
	652	while( TestDestroy() )
	653	{
	654	::YieldToAnyThread() ;
	655	}
	656	#else // !wxUSE_GUI
	657	// simply wait for the thread to terminate
	658	while( TestDestroy() )
	659	{
	660	::YieldToAnyThread() ;
	661	}
	662	#endif // wxUSE_GUI/!wxUSE_GUI
	663
	664	if ( IsMain() )
	665	{
	666	gs_waitingForThread = FALSE;
	667
	668	#if wxUSE_GUI
	669	wxEndBusyCursor();
	670	#endif // wxUSE_GUI
	671	}
	672	}
	673
	674	// if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
	675	{
	676	wxLogLastError("GetExitCodeThread");
	677
	678	rc = (ExitCode)-1;
	679	}
	680
	681	if ( IsDetached() )
	682	{
	683	// if the thread exits normally, this is done in WinThreadStart, but in
	684	// this case it would have been too early because
	685	// MsgWaitForMultipleObject() would fail if the therad handle was
	686	// closed while we were waiting on it, so we must do it here
	687	delete this;
	688	}
	689
	690	// wxASSERT_MSG( (DWORD)rc != STILL_ACTIVE,
	691	// wxT("thread must be already terminated.") );
	692
	693	if ( pRc )
	694	*pRc = rc;
	695
	696	return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
	697	}
	698
	699	wxThreadError wxThread::Kill()
	700	{
	701	if ( !IsRunning() )
	702	return wxTHREAD_NOT_RUNNING;
	703
	704	// if ( !::TerminateThread(m_internal->GetHandle(), (DWORD)-1) )
	705	{
	706	wxLogSysError(_("Couldn't terminate thread"));
	707
	708	return wxTHREAD_MISC_ERROR;
	709	}
	710
	711	m_internal->Free();
	712
	713	if ( IsDetached() )
	714	{
	715	delete this;
	716	}
	717
	718	return wxTHREAD_NO_ERROR;
	719	}
	720
	721	void wxThread::Exit(ExitCode status)
	722	{
	723	m_internal->Free();
	724
	725	if ( IsDetached() )
	726	{
	727	delete this;
	728	}
	729
	730	m_internal->SetResult( status ) ;
	731
	732	/*
	733	#if defined(__VISUALC__) \|\| (defined(__BORLANDC__) && (__BORLANDC__ >= 0x500))
	734	_endthreadex((unsigned)status);
	735	#else // !VC++
	736	::ExitThread((DWORD)status);
	737	#endif // VC++/!VC++
	738	*/
	739	wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
	740	}
	741
	742	// priority setting
	743	// ----------------
	744
	745	// since all these calls are execute cooperatively we don't have to use the critical section
	746
	747	void wxThread::SetPriority(unsigned int prio)
	748	{
	749	m_internal->SetPriority(prio);
	750	}
	751
	752	unsigned int wxThread::GetPriority() const
	753	{
	754	return m_internal->GetPriority();
	755	}
	756
	757	unsigned long wxThread::GetId() const
	758	{
	759	return (unsigned long)m_internal->GetId();
	760	}
	761
	762	bool wxThread::IsRunning() const
	763	{
	764	return m_internal->GetState() == STATE_RUNNING;
	765	}
	766
	767	bool wxThread::IsAlive() const
	768	{
	769	return (m_internal->GetState() == STATE_RUNNING) \|\|
	770	(m_internal->GetState() == STATE_PAUSED);
	771	}
	772
	773	bool wxThread::IsPaused() const
	774	{
	775	return m_internal->GetState() == STATE_PAUSED;
	776	}
	777
	778	bool wxThread::TestDestroy()
	779	{
	780	return m_internal->GetState() == STATE_CANCELED;
	781	}
	782
	783	// ----------------------------------------------------------------------------
	784	// Automatic initialization for thread module
	785	// ----------------------------------------------------------------------------
	786
	787	class wxThreadModule : public wxModule
	788	{
	789	public:
	790	virtual bool OnInit();
	791	virtual void OnExit();
	792
	793	private:
	794	DECLARE_DYNAMIC_CLASS(wxThreadModule)
	795	};
	796
	797	IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
	798
	799	bool wxThreadModule::OnInit()
	800	{
	801	long response;
	802	bool hasThreadManager ;
	803	hasThreadManager = Gestalt( gestaltThreadMgrAttr, &response) == noErr && response & 1;
	804	#if GENERATINGPOWERPC \|\| GENERATINGCFM
	805	// verify presence of shared library
	806	hasThreadManager = hasThreadManager && ((Ptr)NewThread != (Ptr)kUnresolvedCFragSymbolAddress);
	807	#endif
	808	if ( !hasThreadManager )
	809	{
	810	wxMessageBox( "Error" , "Thread Support is not available on this System" , wxOK ) ;
	811	return FALSE ;
	812	}
	813
	814	// no error return for GetCurrentThreadId()
	815	MacGetCurrentThread( &gs_idMainThread ) ;
	816
	817	return TRUE;
	818	}
	819
	820	void wxThreadModule::OnExit()
	821	{
	822	}
	823
	824	// ----------------------------------------------------------------------------
	825	// under MacOS we don't have currently preemptive threads, so any thread may access
	826	// the GUI at any time
	827	// ----------------------------------------------------------------------------
	828
	829	void WXDLLEXPORT wxMutexGuiEnter()
	830	{
	831	}
	832
	833	void WXDLLEXPORT wxMutexGuiLeave()
	834	{
	835	}
	836
	837	void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
	838	{
	839	}
	840
	841	bool WXDLLEXPORT wxGuiOwnedByMainThread()
	842	{
	843	return false ;
	844	}
	845
	846	// wake up the main thread
	847	void WXDLLEXPORT wxWakeUpMainThread()
	848	{
	849	wxMacWakeUp() ;
	850	}
	851
	852	bool WXDLLEXPORT wxIsWaitingForThread()
	853	{
	854	return false ;
	855	}
	856
	857	#endif // wxUSE_THREADS
	858