// Created: 04/22/98
// RCS-ID: $Id$
// Copyright: (c) Stefan Neis (2003)
-//
+//
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include "wx/app.h"
+#include "wx/apptrait.h"
#include "wx/module.h"
#include "wx/intl.h"
#include "wx/utils.h"
wxMutex* p_wxMainMutex;
// OS2 substitute for Tls pointer the current parent thread object
-wxThread* m_pThread; // pointer to the wxWindows thread object
+wxThread* m_pThread; // pointer to the wxWidgets thread object
// if it's FALSE, some secondary thread is holding the GUI lock
static bool gs_bGuiOwnedByMainThread = TRUE;
TID GetId() const { return m_hThread; }
// thread function
- static DWORD OS2ThreadStart(ULONG ulParam);
+ static void OS2ThreadStart(void* pParam);
private:
// Threads in OS/2 have only an ID, so m_hThread is both it's handle and ID
// PM also has no real Tls mechanism to index pointers by so we'll just
- // keep track of the wxWindows parent object here.
+ // keep track of the wxWidgets parent object here.
TID m_hThread; // handle and ID of the thread
wxThreadState m_eState; // state, see wxThreadState enum
unsigned int m_nPriority; // thread priority in "wx" units
};
-ULONG wxThreadInternal::OS2ThreadStart(
- ULONG ulParam
+void wxThreadInternal::OS2ThreadStart(
+ void * pParam
)
{
DWORD dwRet;
bool bWasCancelled;
- // first of all, check whether we hadn't been cancelled already and don't
- // start the user code at all then
- wxThread *pThread = (wxThread *)ulParam;
+ wxThread *pThread = (wxThread *)pParam;
+
+ // first of all, wait for the thread to be started.
+ pThread->m_critsect.Enter();
+ pThread->m_critsect.Leave();
+ // Now check whether we hadn't been cancelled already and don't
+ // start the user code at all in this case.
if ( pThread->m_internal->GetState() == STATE_EXITED )
{
dwRet = (DWORD)-1;
}
else // do run thread
{
+ wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
+ unsigned long ulHab;
+ if (traits)
+ traits->InitializeGui(ulHab);
dwRet = (DWORD)pThread->Entry();
+ if (traits)
+ traits->TerminateGui(ulHab);
- // enter m_critsect before changing the thread state
- pThread->m_critsect.Enter();
+ // enter m_critsect before changing the thread state
+ pThread->m_critsect.Enter();
- bWasCancelled = pThread->m_internal->GetState() == STATE_CANCELED;
+ bWasCancelled = pThread->m_internal->GetState() == STATE_CANCELED;
- pThread->m_internal->SetState(STATE_EXITED);
- pThread->m_critsect.Leave();
+ pThread->m_internal->SetState(STATE_EXITED);
+ pThread->m_critsect.Leave();
}
pThread->OnExit();
delete pThread;
}
//else: the joinable threads handle will be closed when Wait() is done
- return dwRet;
+ return;
}
void wxThreadInternal::SetPriority(
unsigned int nPriority
)
{
- // translate wxWindows priority to the PM one
+ // translate wxWidgets priority to the PM one
ULONG ulOS2_PriorityClass;
ULONG ulOS2_SubPriority;
ULONG ulrc;
, unsigned int uStackSize
)
{
- APIRET ulrc;
-
- ulrc = ::DosCreateThread( &m_hThread
- ,(PFNTHREAD)wxThreadInternal::OS2ThreadStart
- ,(ULONG)pThread
- ,CREATE_SUSPENDED | STACK_SPARSE
- ,(ULONG)uStackSize
- );
- if(ulrc != 0)
+ int tid;
+
+ if (!uStackSize)
+ uStackSize = 131072;
+ pThread->m_critsect.Enter();
+ tid = _beginthread(wxThreadInternal::OS2ThreadStart,
+ NULL, uStackSize, pThread);
+ if(tid == -1)
{
wxLogSysError(_("Can't create thread"));
return FALSE;
}
+ m_hThread = tid;
if (m_nPriority != WXTHREAD_DEFAULT_PRIORITY)
{
SetPriority(m_nPriority);
if (ulrc != 0)
{
- wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
+ wxLogSysError(_("Can not resume thread %lu"), m_hThread);
return FALSE;
}
wxThreadError wxThread::Resume()
{
+ if (m_internal->GetState() == STATE_NEW)
+ {
+ m_internal->SetState(STATE_RUNNING);
+ m_critsect.Leave();
+ return wxTHREAD_NO_ERROR;
+ }
+
wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
{
// set flag for wxIsWaitingForThread()
gs_bWaitingForThread = TRUE;
- }
+ }
// ask the thread to terminate
if ( shouldCancel )
m_internal->Cancel();
}
-#if wxUSE_GUI
+#if 0
// 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
}
}
- result = ::DosWaitThread(&hThread, DCWW_WAIT);
- // FIXME: We ought to have a message processing loop here!!
+ result = ::DosWaitThread(&hThread, DCWW_NOWAIT);
+ // FIXME: We ought to have a message processing loop here!!
switch ( result )
- {
- case ERROR_THREAD_NOT_TERMINATED:
- case ERROR_INVALID_THREADID:
- // error
- wxLogSysError(_("Can not wait for thread termination"));
- Kill();
- return wxTHREAD_KILLED;
-
+ {
+ case ERROR_INTERRUPT:
+ case ERROR_THREAD_NOT_TERMINATED:
+ break;
+ case ERROR_INVALID_THREADID:
case NO_ERROR:
- // thread we're waiting for terminated
+ // thread we're waiting for just terminated
+ // or even does not exist any more.
+ result = NO_ERROR;
break;
-
default:
wxFAIL_MSG(wxT("unexpected result of DosWaitThread"));
}
+ if ( IsMain() )
+ {
+ // event processing - needed if we are the main thread
+ // to give other threads a chance to do remaining GUI
+ // processing and terminate cleanly.
+ wxTheApp->HandleSockets();
+ if (wxTheApp->Pending())
+ if ( !wxTheApp->DoMessage() )
+ {
+ // WM_QUIT received: kill the thread
+ Kill();
+
+ return wxTHREAD_KILLED;
+ }
+ else
+ wxUsleep(10);
+ }
+ else
+ wxUsleep(10);
} while ( result != NO_ERROR );
#else // !wxUSE_GUI
// simply wait for the thread to terminate
)
{
delete this;
- ::DosExit(EXIT_THREAD, ULONG(pStatus));
+ _endthread();
wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
}
// wake up the main thread if it's in ::GetMessage()
void WXDLLEXPORT wxWakeUpMainThread()
{
+#if 0
if ( !::WinPostQueueMsg(wxTheApp->m_hMq, WM_NULL, 0, 0) )
{
// should never happen
wxLogLastError(wxT("WinPostMessage(WM_NULL)"));
}
+#endif
}
void WXDLLEXPORT wxMutexGuiEnter()
projects / wxWidgets.git / blobdiff