Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new wxMenu stuff and thread implementations

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4291 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
1999-11-02 04:36:20 +00:00
parent dd60b9ec1e
commit c5fb56c07a
5 changed files with 854 additions and 1222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1125
src/os2/menu.cpp
View File

File diff suppressed because it is too large Load Diff

155
src/os2/menuitem.cpp
View File

@@ -27,18 +27,29 @@
#include "wx/string.h" #include "wx/string.h"
#endif #endif
#include "wx/ownerdrw.h"
#include "wx/menuitem.h" #include "wx/menuitem.h"
#include "wx/log.h" #include "wx/log.h"
#if wxUSE_ACCEL
#include "wx/accel.h"
#endif // wxUSE_ACCEL
#include "wx/os2/private.h" #include "wx/os2/private.h"
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// convenience macro // macro
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// hide the ugly cast
#define GetHMenuOf(menu) ((HMENU)menu->GetHMenu()) #define GetHMenuOf(menu) ((HMENU)menu->GetHMenu())
// conditional compilation
#if wxUSE_OWNER_DRAWN
#define OWNER_DRAWN_ONLY( code ) if ( IsOwnerDrawn() ) code
#else // !wxUSE_OWNER_DRAWN
#define OWNER_DRAWN_ONLY( code )
#endif // wxUSE_OWNER_DRAWN/!wxUSE_OWNER_DRAWN
// ============================================================================ // ============================================================================
// implementation // implementation
// ============================================================================ // ============================================================================
@@ -49,11 +60,10 @@
#if !defined(USE_SHARED_LIBRARY) || !USE_SHARED_LIBRARY #if !defined(USE_SHARED_LIBRARY) || !USE_SHARED_LIBRARY
#if wxUSE_OWNER_DRAWN #if wxUSE_OWNER_DRAWN
IMPLEMENT_DYNAMIC_CLASS2(wxMenuItem, wxObject, wxOwnerDrawn) IMPLEMENT_DYNAMIC_CLASS2(wxMenuItem, wxMenuItemBase, wxOwnerDrawn)
#else //!USE_OWNER_DRAWN #else //!USE_OWNER_DRAWN
IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject) IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxMenuItemBase)
#endif //USE_OWNER_DRAWN #endif //USE_OWNER_DRAWN
#endif //USE_SHARED_LIBRARY #endif //USE_SHARED_LIBRARY
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -63,17 +73,15 @@
// ctor & dtor // ctor & dtor
// ----------- // -----------
wxMenuItem::wxMenuItem(wxMenu *pParentMenu, int id, wxMenuItem::wxMenuItem(wxMenu *pParentMenu,
const wxString& strName, const wxString& strHelp, int id,
const wxString& text,
const wxString& strHelp,
bool bCheckable, bool bCheckable,
wxMenu *pSubMenu) : wxMenu *pSubMenu) :
#if wxUSE_OWNER_DRAWN #if wxUSE_OWNER_DRAWN
wxOwnerDrawn(strName, bCheckable), wxOwnerDrawn(text, bCheckable)
#else //no owner drawn support
m_bCheckable(bCheckable),
m_strName(strName),
#endif // owner drawn #endif // owner drawn
m_strHelp(strHelp)
{ {
wxASSERT_MSG( pParentMenu != NULL, wxT("a menu item should have a parent") ); wxASSERT_MSG( pParentMenu != NULL, wxT("a menu item should have a parent") );
@@ -88,13 +96,16 @@ wxMenuItem::wxMenuItem(wxMenu *pParentMenu, int id,
ResetOwnerDrawn(); ResetOwnerDrawn();
#undef SYS_COLOR #undef SYS_COLOR
#endif #endif // wxUSE_OWNER_DRAWN
m_pParentMenu = pParentMenu; m_parentMenu = pParentMenu;
m_pSubMenu = pSubMenu; m_subMenu = pSubMenu;
m_bEnabled = TRUE; m_isEnabled = TRUE;
m_bChecked = FALSE; m_isChecked = FALSE;
m_idItem = id; m_id = id;
m_text = text;
m_isCheckable = bCheckable;
m_help = strHelp;
} }
wxMenuItem::~wxMenuItem() wxMenuItem::~wxMenuItem()
@@ -107,74 +118,96 @@ wxMenuItem::~wxMenuItem()
// return the id for calling Win32 API functions // return the id for calling Win32 API functions
int wxMenuItem::GetRealId() const int wxMenuItem::GetRealId() const
{ {
return m_pSubMenu ? (int)m_pSubMenu->GetHMenu() : GetId(); return m_subMenu ? (int)m_subMenu->GetHMenu() : GetId();
} }
// delete the sub menu // get item state
// ------------------- // --------------
void wxMenuItem::DeleteSubMenu()
bool wxMenuItem::IsChecked() const
{ {
delete m_pSubMenu; /*
m_pSubMenu = NULL; int flag = ::GetMenuState(GetHMenuOf(m_parentMenu), GetId(), MF_BYCOMMAND);
// don't "and" with MF_ENABLED because its value is 0
return (flag & MF_DISABLED) == 0;
*/
return FALSE;
} }
wxString wxMenuItem::GetLabel() const
{
return wxStripMenuCodes(m_text);
}
// accelerators
// ------------
#if wxUSE_ACCEL
wxAcceleratorEntry *wxMenuItem::GetAccel() const
{
return wxGetAccelFromString(GetText());
}
#endif // wxUSE_ACCEL
// change item state // change item state
// ----------------- // -----------------
void wxMenuItem::Enable(bool bDoEnable) void wxMenuItem::Enable(bool enable)
{ {
// TODO: if ( m_isEnabled == enable )
return;
/* /*
if ( m_bEnabled != bDoEnable ) { long rc = EnableMenuItem(GetHMenuOf(m_parentMenu),
long rc = EnableMenuItem(GetHMenuOf(m_pParentMenu),
GetRealId(), GetRealId(),
MF_BYCOMMAND | MF_BYCOMMAND |
(bDoEnable ? MF_ENABLED : MF_GRAYED)); (enable ? MF_ENABLED : MF_GRAYED));
if ( rc == -1 ) { if ( rc == -1 ) {
wxLogLastError("EnableMenuItem"); wxLogLastError("EnableMenuItem");
} }
m_bEnabled = bDoEnable;
}
*/ */
wxMenuItemBase::Enable(enable);
} }
void wxMenuItem::Check(bool bDoCheck) void wxMenuItem::Check(bool check)
{ {
wxCHECK_RET( IsCheckable(), wxT("only checkable items may be checked") ); wxCHECK_RET( m_isCheckable, wxT("only checkable items may be checked") );
// TODO: if ( m_isChecked == check )
return;
/* /*
if ( m_bChecked != bDoCheck ) { long rc = CheckMenuItem(GetHMenuOf(m_parentMenu),
long rc = CheckMenuItem(GetHMenuOf(m_pParentMenu), GetRealId(),
GetId(),
MF_BYCOMMAND | MF_BYCOMMAND |
(bDoCheck ? MF_CHECKED : MF_UNCHECKED)); (check ? MF_CHECKED : MF_UNCHECKED));
if ( rc == -1 ) { if ( rc == -1 ) {
wxLogLastError("CheckMenuItem"); wxLogLastError("CheckMenuItem");
} }
m_bChecked = bDoCheck;
}
*/ */
wxMenuItemBase::Check(check);
} }
void wxMenuItem::SetName(const wxString& strName) void wxMenuItem::SetText(const wxString& text)
{ {
// don't do anything if label didn't change // don't do anything if label didn't change
if ( m_strName == strName ) if ( m_text == text )
return; return;
m_strName = strName; wxMenuItemBase::SetText(text);
OWNER_DRAWN_ONLY( wxOwnerDrawn::SetName(text) );
/*
HMENU hMenu = GetHMenuOf(m_parentMenu);
wxCHECK_RET( hMenu, wxT("menuitem without menu") );
HMENU hMenu = GetHMenuOf(m_pParentMenu); #if wxUSE_ACCEL
m_parentMenu->UpdateAccel(this);
#endif // wxUSE_ACCEL
UINT id = GetRealId(); UINT id = GetRealId();
// TODO:
/*
UINT flagsOld = ::GetMenuState(hMenu, id, MF_BYCOMMAND); UINT flagsOld = ::GetMenuState(hMenu, id, MF_BYCOMMAND);
if ( flagsOld == 0xFFFFFFFF ) if ( flagsOld == 0xFFFFFFFF )
{ {
@@ -190,6 +223,7 @@ void wxMenuItem::SetName(const wxString& strName)
} }
LPCTSTR data; LPCTSTR data;
#if wxUSE_OWNER_DRAWN #if wxUSE_OWNER_DRAWN
if ( IsOwnerDrawn() ) if ( IsOwnerDrawn() )
{ {
@@ -200,12 +234,12 @@ void wxMenuItem::SetName(const wxString& strName)
#endif //owner drawn #endif //owner drawn
{ {
flagsOld |= MF_STRING; flagsOld |= MF_STRING;
data = strName; data = (char*) text.c_str();
} }
if ( ::ModifyMenu(hMenu, id, if ( ::ModifyMenu(hMenu, id,
MF_BYCOMMAND | flagsOld, MF_BYCOMMAND | flagsOld,
id, data) == 0xFFFFFFFF ) id, data) == (int)0xFFFFFFFF )
{ {
wxLogLastError(wxT("ModifyMenu")); wxLogLastError(wxT("ModifyMenu"));
} }
@@ -213,3 +247,22 @@ void wxMenuItem::SetName(const wxString& strName)
*/ */
} }
void wxMenuItem::SetCheckable(bool checkable)
{
wxMenuItemBase::SetCheckable(checkable);
OWNER_DRAWN_ONLY( wxOwnerDrawn::SetCheckable(checkable) );
}
// ----------------------------------------------------------------------------
// wxMenuItemBase
// ----------------------------------------------------------------------------
wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
int id,
const wxString& name,
const wxString& help,
bool isCheckable,
wxMenu *subMenu)
{
return new wxMenuItem(parentMenu, id, name, help, isCheckable, subMenu);
}

568
src/os2/thread.cpp
View File

@@ -20,12 +20,15 @@
#include <stdio.h> #include <stdio.h>
#define INCL_DOS
#include <os2.h>
#include "wx/module.h" #include "wx/module.h"
#include "wx/thread.h" #include "wx/thread.h"
#define INCL_DOSSEMAPHORES
#define INCL_DOSPROCESS
#define INCL_ERRORS
#include <os2.h>
#include <bseerr.h>
// the possible states of the thread ("=>" shows all possible transitions from // the possible states of the thread ("=>" shows all possible transitions from
// this state) // this state)
enum wxThreadState enum wxThreadState
@@ -41,12 +44,13 @@ enum wxThreadState
// static variables // static variables
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// TLS index of the slot where we store the pointer to the current thread
static DWORD s_tlsThisThread = 0xFFFFFFFF;
// id of the main thread - the one which can call GUI functions without first // id of the main thread - the one which can call GUI functions without first
// calling wxMutexGuiEnter() // calling wxMutexGuiEnter()
static DWORD s_idMainThread = 0; static ULONG s_ulIdMainThread = 0;
wxMutex* p_wxMainMutex;
// OS2 substitute for Tls pointer the current parent thread object
wxThread* m_pThread; // pointer to the wxWindows thread object
// if it's FALSE, some secondary thread is holding the GUI lock // if it's FALSE, some secondary thread is holding the GUI lock
static bool s_bGuiOwnedByMainThread = TRUE; static bool s_bGuiOwnedByMainThread = TRUE;
@@ -54,19 +58,19 @@ static bool s_bGuiOwnedByMainThread = TRUE;
// critical section which controls access to all GUI functions: any secondary // 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 // thread (i.e. except the main one) must enter this crit section before doing
// any GUI calls // any GUI calls
static wxCriticalSection *s_critsectGui = NULL; static wxCriticalSection *s_pCritsectGui = NULL;
// critical section which protects s_nWaitingForGui variable // critical section which protects s_nWaitingForGui variable
static wxCriticalSection *s_critsectWaitingForGui = NULL; static wxCriticalSection *s_pCritsectWaitingForGui = NULL;
// number of threads waiting for GUI in wxMutexGuiEnter() // number of threads waiting for GUI in wxMutexGuiEnter()
static size_t s_nWaitingForGui = 0; static size_t s_nWaitingForGui = 0;
// are we waiting for a thread termination? // are we waiting for a thread termination?
static bool s_waitingForThread = FALSE; static bool s_bWaitingForThread = FALSE;
// ============================================================================ // ============================================================================
// Windows implementation of thread classes // OS/2 implementation of thread classes
// ============================================================================ // ============================================================================
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -75,18 +79,19 @@ static bool s_waitingForThread = FALSE;
class wxMutexInternal class wxMutexInternal
{ {
public: public:
HANDLE p_mutex; HMTX m_vMutex;
}; };
wxMutex::wxMutex() wxMutex::wxMutex()
{ {
APIRET ulrc;
p_internal = new wxMutexInternal; p_internal = new wxMutexInternal;
// p_internal->p_mutex = CreateMutex(NULL, FALSE, NULL); ulrc = ::DosCreateMutexSem(NULL, &p_internal->m_vMutex, 0L, FALSE);
if ( !p_internal->p_mutex ) if (ulrc != 0)
{ {
wxLogSysError(_("Can not create mutex.")); wxLogSysError(_("Can not create mutex."));
} }
m_locked = 0; m_locked = 0;
} }
@@ -94,66 +99,65 @@ wxMutex::~wxMutex()
{ {
if (m_locked > 0) if (m_locked > 0)
wxLogDebug(wxT("Warning: freeing a locked mutex (%d locks)."), m_locked); wxLogDebug(wxT("Warning: freeing a locked mutex (%d locks)."), m_locked);
// CloseHandle(p_internal->p_mutex); ::DosCloseMutexSem(p_internal->m_vMutex);
delete p_internal;
p_internal = NULL;
} }
wxMutexError wxMutex::Lock() wxMutexError wxMutex::Lock()
{ {
DWORD ret; APIRET ulrc;
// TODO: ulrc = ::DosRequestMutexSem(p_internal->m_vMutex, SEM_INDEFINITE_WAIT);
/*
ret = WaitForSingleObject(p_internal->p_mutex, INFINITE); switch (ulrc)
switch ( ret )
{ {
case WAIT_ABANDONED: case ERROR_TOO_MANY_SEM_REQUESTS:
return wxMUTEX_BUSY; return wxMUTEX_BUSY;
case WAIT_OBJECT_0: case NO_ERROR:
// ok // ok
break; break;
case WAIT_FAILED: case ERROR_INVALID_HANDLE:
case ERROR_INTERRUPT:
case ERROR_SEM_OWNER_DIED:
wxLogSysError(_("Couldn't acquire a mutex lock")); wxLogSysError(_("Couldn't acquire a mutex lock"));
return wxMUTEX_MISC_ERROR; return wxMUTEX_MISC_ERROR;
case WAIT_TIMEOUT: case ERROR_TIMEOUT:
default: default:
wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock")); wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
} }
m_locked++; m_locked++;
*/
return wxMUTEX_NO_ERROR; return wxMUTEX_NO_ERROR;
} }
wxMutexError wxMutex::TryLock() wxMutexError wxMutex::TryLock()
{ {
DWORD ret; ULONG ulrc;
// TODO: ulrc = ::DosRequestMutexSem(p_internal->m_vMutex, SEM_IMMEDIATE_RETURN /*0L*/);
/* if (ulrc == ERROR_TIMEOUT || ulrc == ERROR_TOO_MANY_SEM_REQUESTS)
ret = WaitForSingleObject(p_internal->p_mutex, 0);
if (ret == WAIT_TIMEOUT || ret == WAIT_ABANDONED)
return wxMUTEX_BUSY; return wxMUTEX_BUSY;
m_locked++; m_locked++;
*/
return wxMUTEX_NO_ERROR; return wxMUTEX_NO_ERROR;
} }
wxMutexError wxMutex::Unlock() wxMutexError wxMutex::Unlock()
{ {
APIRET ulrc;
if (m_locked > 0) if (m_locked > 0)
m_locked--; m_locked--;
BOOL ret = 0; // TODO: ReleaseMutex(p_internal->p_mutex); ulrc = ::DosReleaseMutexSem(p_internal->m_vMutex);
if ( ret == 0 ) if (ulrc != 0)
{ {
wxLogSysError(_("Couldn't release a mutex")); wxLogSysError(_("Couldn't release a mutex"));
return wxMUTEX_MISC_ERROR; return wxMUTEX_MISC_ERROR;
} }
return wxMUTEX_NO_ERROR; return wxMUTEX_NO_ERROR;
} }
@@ -164,117 +168,90 @@ wxMutexError wxMutex::Unlock()
class wxConditionInternal class wxConditionInternal
{ {
public: public:
HANDLE event; HEV m_vEvent;
int waiters; int m_nWaiters;
}; };
wxCondition::wxCondition() wxCondition::wxCondition()
{ {
APIRET ulrc;
ULONG ulCount;
p_internal = new wxConditionInternal; p_internal = new wxConditionInternal;
// TODO: ulrc = ::DosCreateEventSem(NULL, &p_internal->m_vEvent, 0L, FALSE);
/* if (ulrc != 0)
p_internal->event = CreateEvent(NULL, FALSE, FALSE, NULL);
if ( !p_internal->event )
{ {
wxLogSysError(_("Can not create event object.")); wxLogSysError(_("Can not create event object."));
} }
*/ p_internal->m_nWaiters = 0;
p_internal->waiters = 0; // ?? just for good measure?
::DosResetEventSem(p_internal->m_vEvent, &ulCount);
} }
wxCondition::~wxCondition() wxCondition::~wxCondition()
{ {
// CloseHandle(p_internal->event); ::DosCloseEventSem(p_internal->m_vEvent);
delete p_internal;
p_internal = NULL;
} }
void wxCondition::Wait(wxMutex& mutex) void wxCondition::Wait(
wxMutex& rMutex
)
{ {
mutex.Unlock(); rMutex.Unlock();
p_internal->waiters++; p_internal->m_nWaiters++;
// WaitForSingleObject(p_internal->event, INFINITE); ::DosWaitEventSem(p_internal->m_vEvent, SEM_INDEFINITE_WAIT);
p_internal->waiters--; p_internal->m_nWaiters--;
mutex.Lock(); rMutex.Lock();
} }
bool wxCondition::Wait(wxMutex& mutex, bool wxCondition::Wait(
unsigned long sec, wxMutex& rMutex
unsigned long nsec) , unsigned long ulSec
, unsigned long ulMillisec)
{ {
DWORD ret; APIRET ulrc;
mutex.Unlock(); rMutex.Unlock();
p_internal->waiters++; p_internal->m_nWaiters++;
// ret = WaitForSingleObject(p_internal->event, (sec*1000)+(nsec/1000000)); ulrc = ::DosWaitEventSem(p_internal->m_vEvent, ULONG((ulSec * 1000L) + ulMillisec));
p_internal->waiters--; p_internal->m_nWaiters--;
mutex.Lock(); rMutex.Lock();
// return (ret != WAIT_TIMEOUT); return (ulrc != ERROR_TIMEOUT);
return FALSE;
} }
void wxCondition::Signal() void wxCondition::Signal()
{ {
// SetEvent(p_internal->event); ::DosPostEventSem(p_internal->m_vEvent);
} }
void wxCondition::Broadcast() void wxCondition::Broadcast()
{ {
int i; int i;
// TODO: for (i = 0; i < p_internal->m_nWaiters; i++)
/*
for (i=0;i<p_internal->waiters;i++)
{ {
if ( SetEvent(p_internal->event) == 0 ) if (::DosPostEventSem(p_internal->m_vEvent) != 0)
{ {
wxLogSysError(_("Couldn't change the state of event object.")); wxLogSysError(_("Couldn't change the state of event object."));
} }
} }
*/
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxCriticalSection implementation // wxCriticalSection implementation
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#define CRITICAL_SECTION ULONG
class wxCriticalSectionInternal
{
public:
// init the critical section object
wxCriticalSectionInternal()
{ //::InitializeCriticalSection(&m_data);
}
// implicit cast to the associated data
operator CRITICAL_SECTION *() { return &m_data; }
// free the associated ressources
~wxCriticalSectionInternal()
{ //::DeleteCriticalSection(&m_data);
}
private:
CRITICAL_SECTION m_data;
};
wxCriticalSection::wxCriticalSection()
{
m_critsect = new wxCriticalSectionInternal;
}
wxCriticalSection::~wxCriticalSection()
{
delete m_critsect;
}
void wxCriticalSection::Enter() void wxCriticalSection::Enter()
{ {
//TODO: ::EnterCriticalSection(*m_critsect); ::DosEnterCritSec();
} }
void wxCriticalSection::Leave() void wxCriticalSection::Leave()
{ {
// TODO: ::LeaveCriticalSection(*m_critsect); ::DosExitCritSec();
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -287,144 +264,134 @@ void wxCriticalSection::Leave()
class wxThreadInternal class wxThreadInternal
{ {
public: public:
wxThreadInternal() inline wxThreadInternal()
{ {
m_hThread = 0; m_hThread = 0;
m_state = STATE_NEW; m_eState = STATE_NEW;
m_priority = 0; // TODO: WXTHREAD_DEFAULT_PRIORITY; m_nPriority = 0;
} }
// create a new (suspended) thread (for the given thread object) // create a new (suspended) thread (for the given thread object)
bool Create(wxThread *thread); bool Create(wxThread* pThread);
// suspend/resume/terminate // suspend/resume/terminate
bool Suspend(); bool Suspend();
bool Resume(); bool Resume();
void Cancel() { m_state = STATE_CANCELED; } inline void Cancel() { m_eState = STATE_CANCELED; }
// thread state // thread state
void SetState(wxThreadState state) { m_state = state; } inline void SetState(wxThreadState eState) { m_eState = eState; }
wxThreadState GetState() const { return m_state; } inline wxThreadState GetState() const { return m_eState; }
// thread priority // thread priority
void SetPriority(unsigned int priority) { m_priority = priority; } inline void SetPriority(unsigned int nPriority) { m_nPriority = nPriority; }
unsigned int GetPriority() const { return m_priority; } inline unsigned int GetPriority() const { return m_nPriority; }
// thread handle and id // thread handle and id
HANDLE GetHandle() const { return m_hThread; } inline TID GetHandle() const { return m_hThread; }
DWORD GetId() const { return m_tid; } TID GetId() const { return m_hThread; }
// thread function // thread function
static DWORD OS2ThreadStart(wxThread *thread); static DWORD OS2ThreadStart(wxThread *thread);
private: private:
HANDLE m_hThread; // handle of the thread // Threads in OS/2 have only an ID, so m_hThread is both it's handle and ID
wxThreadState m_state; // state, see wxThreadState enum // PM also has no real Tls mechanism to index pointers by so we'll just
unsigned int m_priority; // thread priority in "wx" units // keep track of the wxWindows parent object here.
DWORD m_tid; // thread id 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
}; };
DWORD wxThreadInternal::OS2ThreadStart(wxThread *thread) ULONG wxThreadInternal::OS2ThreadStart(
wxThread* pThread
)
{ {
// store the thread object in the TLS m_pThread = pThread;
// TODO:
/*
if ( !::TlsSetValue(s_tlsThisThread, thread) )
{
wxLogSysError(_("Can not start thread: error writing TLS."));
return (DWORD)-1; DWORD dwRet = (DWORD)pThread->Entry();
}
*/
DWORD ret = (DWORD)thread->Entry();
thread->p_internal->SetState(STATE_EXITED);
thread->OnExit();
delete thread; pThread->p_internal->SetState(STATE_EXITED);
pThread->OnExit();
return ret; delete pThread;
m_pThread = NULL;
return dwRet;
} }
bool wxThreadInternal::Create(wxThread *thread) bool wxThreadInternal::Create(
wxThread* pThread
)
{ {
// TODO: APIRET ulrc;
/*
m_hThread = ::CreateThread ulrc = ::DosCreateThread( &m_hThread
( ,(PFNTHREAD)wxThreadInternal::OS2ThreadStart
NULL, // default security ,(ULONG)pThread
0, // default stack size ,CREATE_SUSPENDED | STACK_SPARSE
(LPTHREAD_START_ROUTINE) // thread entry point ,8192L
wxThreadInternal::OS2ThreadStart, //
(LPVOID)thread, // parameter
CREATE_SUSPENDED, // flags
&m_tid // [out] thread id
); );
if(ulrc != 0)
if ( m_hThread == NULL )
{ {
wxLogSysError(_("Can't create thread")); wxLogSysError(_("Can't create thread"));
return FALSE; return FALSE;
} }
// translate wxWindows priority to the Windows one // translate wxWindows priority to the PM one
int win_priority; ULONG ulOS2_Priority;
if (m_priority <= 20)
win_priority = THREAD_PRIORITY_LOWEST; if (m_nPriority <= 20)
else if (m_priority <= 40) ulOS2_Priority = PRTYC_NOCHANGE;
win_priority = THREAD_PRIORITY_BELOW_NORMAL; else if (m_nPriority <= 40)
else if (m_priority <= 60) ulOS2_Priority = PRTYC_IDLETIME;
win_priority = THREAD_PRIORITY_NORMAL; else if (m_nPriority <= 60)
else if (m_priority <= 80) ulOS2_Priority = PRTYC_REGULAR;
win_priority = THREAD_PRIORITY_ABOVE_NORMAL; else if (m_nPriority <= 80)
else if (m_priority <= 100) ulOS2_Priority = PRTYC_TIMECRITICAL;
win_priority = THREAD_PRIORITY_HIGHEST; else if (m_nPriority <= 100)
ulOS2_Priority = PRTYC_FOREGROUNDSERVER;
else else
{ {
wxFAIL_MSG(wxT("invalid value of thread priority parameter")); wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
win_priority = THREAD_PRIORITY_NORMAL; ulOS2_Priority = PRTYC_REGULAR;
} }
ulrc = ::DosSetPriority( PRTYS_THREAD
if ( ::SetThreadPriority(m_hThread, win_priority) == 0 ) ,ulOS2_Priority
,0
,(ULONG)m_hThread
);
if (ulrc != 0)
{ {
wxLogSysError(_("Can't set thread priority")); wxLogSysError(_("Can't set thread priority"));
} }
*/ return TRUE;
return FALSE;
} }
bool wxThreadInternal::Suspend() bool wxThreadInternal::Suspend()
{ {
// TODO: ULONG ulrc = ::DosSuspendThread(m_hThread);
/*
DWORD nSuspendCount = ::SuspendThread(m_hThread);
if ( nSuspendCount == (DWORD)-1 )
{
wxLogSysError(_("Can not suspend thread %x"), m_hThread);
if (ulrc != 0)
{
wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
return FALSE; return FALSE;
} }
m_eState = STATE_PAUSED;
m_state = STATE_PAUSED; return TRUE;
*/
return FALSE;
} }
bool wxThreadInternal::Resume() bool wxThreadInternal::Resume()
{ {
// TODO: ULONG ulrc = ::DosResumeThread(m_hThread);
/*
DWORD nSuspendCount = ::ResumeThread(m_hThread);
if ( nSuspendCount == (DWORD)-1 )
{
wxLogSysError(_("Can not resume thread %x"), m_hThread);
if (ulrc != 0)
{
wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
return FALSE; return FALSE;
} }
m_eState = STATE_PAUSED;
m_state = STATE_RUNNING; return TRUE;
*/
return FALSE;
} }
// static functions // static functions
@@ -432,24 +399,19 @@ bool wxThreadInternal::Resume()
wxThread *wxThread::This() wxThread *wxThread::This()
{ {
wxThread *thread = NULL; // TODO (wxThread *)::TlsGetValue(s_tlsThisThread); wxThread* pThread = m_pThread;
return pThread;
// TODO:
/*
// 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() bool wxThread::IsMain()
{ {
// TODO: return ::GetCurrentThreadId() == s_idMainThread; PTIB ptib;
PPIB ppib;
::DosGetInfoBlocks(&ptib, &ppib);
if (ptib->tib_ptib2->tib2_ultid == s_ulIdMainThread)
return TRUE;
return FALSE; return FALSE;
} }
@@ -459,13 +421,14 @@ bool wxThread::IsMain()
void wxThread::Yield() void wxThread::Yield()
{ {
// 0 argument to Sleep() is special
::DosSleep(0); ::DosSleep(0);
} }
void wxThread::Sleep(unsigned long milliseconds) void wxThread::Sleep(
unsigned long ulMilliseconds
)
{ {
::DosSleep(milliseconds); ::DosSleep(ulMilliseconds);
} }
// create/start thread // create/start thread
@@ -481,14 +444,13 @@ wxThreadError wxThread::Create()
wxThreadError wxThread::Run() wxThreadError wxThread::Run()
{ {
wxCriticalSectionLocker lock(m_critsect); wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
if ( p_internal->GetState() != STATE_NEW ) if ( p_internal->GetState() != STATE_NEW )
{ {
// actually, it may be almost any state at all, not only STATE_RUNNING // actually, it may be almost any state at all, not only STATE_RUNNING
return wxTHREAD_RUNNING; return wxTHREAD_RUNNING;
} }
return Resume(); return Resume();
} }
@@ -497,14 +459,14 @@ wxThreadError wxThread::Run()
wxThreadError wxThread::Pause() wxThreadError wxThread::Pause()
{ {
wxCriticalSectionLocker lock(m_critsect); wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
return p_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR; return p_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
} }
wxThreadError wxThread::Resume() wxThreadError wxThread::Resume()
{ {
wxCriticalSectionLocker lock(m_critsect); wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
return p_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR; return p_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
} }
@@ -515,6 +477,7 @@ wxThreadError wxThread::Resume()
wxThread::ExitCode wxThread::Delete() wxThread::ExitCode wxThread::Delete()
{ {
ExitCode rc = 0; ExitCode rc = 0;
ULONG ulrc;
// Delete() is always safe to call, so consider all possible states // Delete() is always safe to call, so consider all possible states
if (IsPaused()) if (IsPaused())
@@ -525,14 +488,14 @@ wxThread::ExitCode wxThread::Delete()
if (IsMain()) if (IsMain())
{ {
// set flag for wxIsWaitingForThread() // set flag for wxIsWaitingForThread()
s_waitingForThread = TRUE; s_bWaitingForThread = TRUE;
wxBeginBusyCursor(); wxBeginBusyCursor();
} }
HANDLE hThread; TID hThread;
{ {
wxCriticalSectionLocker lock(m_critsect); wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
p_internal->Cancel(); p_internal->Cancel();
hThread = p_internal->GetHandle(); hThread = p_internal->GetHandle();
@@ -541,42 +504,33 @@ wxThread::ExitCode wxThread::Delete()
// we can't just wait for the thread to terminate because it might be // 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 // calling some GUI functions and so it will never terminate before we
// process the Windows messages that result from these functions // process the Windows messages that result from these functions
DWORD result;
// TODO:
/*
do do
{ {
result = ::MsgWaitForMultipleObjects ulrc = ::DosWaitThread( &hThread
( ,DCWW_NOWAIT
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 (ulrc)
switch ( result )
{ {
case 0xFFFFFFFF: case ERROR_INTERRUPT:
case ERROR_INVALID_THREADID:
// error // error
wxLogSysError(_("Can not wait for thread termination")); wxLogSysError(_("Can not wait for thread termination"));
Kill(); Kill();
return (ExitCode)-1; return (ExitCode)-1;
case WAIT_OBJECT_0: case 0:
// thread we're waiting for terminated // thread we're waiting for terminated
break; break;
case WAIT_OBJECT_0 + 1: case ERROR_THREAD_NOT_TERMINATED:
// new message arrived, process it // new message arrived, process it
if (!wxTheApp->DoMessage()) if (!wxTheApp->DoMessage())
{ {
// WM_QUIT received: kill the thread // WM_QUIT received: kill the thread
Kill(); Kill();
return (ExitCode)-1; return (ExitCode)-1;
} }
if (IsMain()) if (IsMain())
{ {
// give the thread we're waiting for chance to exit // give the thread we're waiting for chance to exit
@@ -586,37 +540,22 @@ wxThread::ExitCode wxThread::Delete()
wxMutexGuiLeave(); wxMutexGuiLeave();
} }
} }
break; break;
default: default:
wxFAIL_MSG(wxT("unexpected result of MsgWaitForMultipleObject")); wxFAIL_MSG(wxT("unexpected result of DosWatiThread"));
} }
} while ( result != WAIT_OBJECT_0 ); } while (ulrc != 0);
*/
if (IsMain()) if (IsMain())
{ {
s_waitingForThread = FALSE; s_bWaitingForThread = FALSE;
wxEndBusyCursor(); wxEndBusyCursor();
} }
// TODO: ::DosExit(EXIT_THREAD, ulrc);
/*
if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
{
wxLogLastError("GetExitCodeThread");
rc = (ExitCode)-1;
} }
rc = (ExitCode)ulrc;
wxASSERT_MSG( (LPVOID)rc != (LPVOID)STILL_ACTIVE,
wxT("thread must be already terminated.") );
::CloseHandle(hThread);
*/
}
return rc; return rc;
} }
@@ -625,34 +564,27 @@ wxThreadError wxThread::Kill()
if (!IsRunning()) if (!IsRunning())
return wxTHREAD_NOT_RUNNING; return wxTHREAD_NOT_RUNNING;
// TODO: ::DosKillThread(p_internal->GetHandle());
/*
if ( !::TerminateThread(p_internal->GetHandle(), (DWORD)-1) )
{
wxLogSysError(_("Couldn't terminate thread"));
return wxTHREAD_MISC_ERROR;
}
*/
delete this; delete this;
return wxTHREAD_NO_ERROR; return wxTHREAD_NO_ERROR;
} }
void wxThread::Exit(void *status) void wxThread::Exit(
void* pStatus
)
{ {
delete this; delete this;
::DosExit(EXIT_THREAD, ULONG(pStatus));
// TODO: ::ExitThread((DWORD)status); wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
wxFAIL_MSG(wxT("Couldn't return from ExitThread()!"));
} }
void wxThread::SetPriority(unsigned int prio) void wxThread::SetPriority(
unsigned int nPrio
)
{ {
wxCriticalSectionLocker lock(m_critsect); wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
p_internal->SetPriority(prio); p_internal->SetPriority(nPrio);
} }
unsigned int wxThread::GetPriority() const unsigned int wxThread::GetPriority() const
@@ -726,98 +658,44 @@ IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
bool wxThreadModule::OnInit() bool wxThreadModule::OnInit()
{ {
// allocate TLS index for storing the pointer to the current thread s_pCritsectWaitingForGui = new wxCriticalSection();
// TODO:
/*
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; s_pCritsectGui = new wxCriticalSection();
} s_pCritsectGui->Enter();
*/
// main thread doesn't have associated wxThread object, so store 0 in the
// TLS instead
// TODO: PTIB ptib;
/* PPIB ppib;
if ( !::TlsSetValue(s_tlsThisThread, (LPVOID)0) )
{
::TlsFree(s_tlsThisThread);
s_tlsThisThread = 0xFFFFFFFF;
wxLogSysError(_("Thread module initialization failed: " ::DosGetInfoBlocks(&ptib, &ppib);
"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();
s_ulIdMainThread = ptib->tib_ptib2->tib2_ultid;
return TRUE; return TRUE;
} }
void wxThreadModule::OnExit() void wxThreadModule::OnExit()
{ {
// TODO: if (s_pCritsectGui)
/*
if ( !::TlsFree(s_tlsThisThread) )
{ {
wxLogLastError("TlsFree failed."); s_pCritsectGui->Leave();
} delete s_pCritsectGui;
*/ s_pCritsectGui = NULL;
if ( s_critsectGui )
{
s_critsectGui->Leave();
delete s_critsectGui;
s_critsectGui = NULL;
} }
wxDELETE(s_critsectWaitingForGui); wxDELETE(s_pCritsectWaitingForGui);
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// under Windows, these functions are implemented usign a critical section and // Helper functions
// not a mutex, so the names are a bit confusing
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void WXDLLEXPORT wxMutexGuiEnter() // Does nothing under OS/2 [for now]
void WXDLLEXPORT wxWakeUpMainThread()
{ {
// 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() void WXDLLEXPORT wxMutexGuiLeave()
{ {
wxCriticalSectionLocker enter(*s_critsectWaitingForGui); wxCriticalSectionLocker enter(*s_pCritsectWaitingForGui);
if ( wxThread::IsMain() ) if ( wxThread::IsMain() )
{ {
@@ -834,7 +712,7 @@ void WXDLLEXPORT wxMutexGuiLeave()
wxWakeUpMainThread(); wxWakeUpMainThread();
} }
s_critsectGui->Leave(); s_pCritsectGui->Leave();
} }
void WXDLLEXPORT wxMutexGuiLeaveOrEnter() void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
@@ -842,7 +720,7 @@ void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
wxASSERT_MSG( wxThread::IsMain(), wxASSERT_MSG( wxThread::IsMain(),
wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") ); wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
wxCriticalSectionLocker enter(*s_critsectWaitingForGui); wxCriticalSectionLocker enter(*s_pCritsectWaitingForGui);
if ( s_nWaitingForGui == 0 ) if ( s_nWaitingForGui == 0 )
{ {
@@ -850,7 +728,7 @@ void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
// any danger (but only if we don't already have it) // any danger (but only if we don't already have it)
if (!wxGuiOwnedByMainThread()) if (!wxGuiOwnedByMainThread())
{ {
s_critsectGui->Enter(); s_pCritsectGui->Enter();
s_bGuiOwnedByMainThread = TRUE; s_bGuiOwnedByMainThread = TRUE;
} }
@@ -872,25 +750,5 @@ bool WXDLLEXPORT wxGuiOwnedByMainThread()
return s_bGuiOwnedByMainThread; 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
// TODO:
/*
if ( !::PostThreadMessage(s_idMainThread, WM_NULL, 0, 0) )
{
// should never happen
wxLogLastError("PostThreadMessage(WM_NULL)");
}
*/
}
bool WXDLLEXPORT wxIsWaitingForThread()
{
return s_waitingForThread;
}
#endif #endif
// wxUSE_THREADS // wxUSE_THREADS

62
src/os2/utils.cpp
View File

@@ -142,23 +142,57 @@ bool wxShell(
const wxString& rCommand const wxString& rCommand
) )
{ {
wxChar* zShell; wxChar* zShell = _T("CMD.EXE");
wxString sInputs;
if ((zShell = wxGetenv(_T("COMSPEC"))) == NULL)
zShell = _T("\\CMD.EXE");
wxChar zTmp[255]; wxChar zTmp[255];
STARTDATA SData = {0};
PSZ PgmTitle = "Command Shell";
APIRET rc;
PID vPid = 0;
ULONG ulSessID = 0;
UCHAR achObjBuf[256] = {0}; //error data if DosStart fails
RESULTCODES vResult;
if (rCommand != "") SData.Length = sizeof(STARTDATA);
wxSprintf( zTmp SData.Related = SSF_RELATED_INDEPENDENT;
,"%s /c %s" SData.FgBg = SSF_FGBG_FORE;
,zShell SData.TraceOpt = SSF_TRACEOPT_NONE;
,WXSTRINGCAST rCommand SData.PgmTitle = PgmTitle;
SData.PgmName = zShell;
// sInputs = "/C " + rCommand;
SData.PgmInputs = NULL; //(BYTE*)sInputs.c_str();
SData.TermQ = 0;
SData.Environment = 0;
SData.InheritOpt = SSF_INHERTOPT_SHELL;
SData.SessionType = SSF_TYPE_WINDOWABLEVIO;
SData.IconFile = 0;
SData.PgmHandle = 0;
SData.PgmControl = SSF_CONTROL_VISIBLE | SSF_CONTROL_MAXIMIZE;
SData.InitXPos = 30;
SData.InitYPos = 40;
SData.InitXSize = 200;
SData.InitYSize = 140;
SData.Reserved = 0;
SData.ObjectBuffer = (char*)achObjBuf;
SData.ObjectBuffLen = (ULONG)sizeof(achObjBuf);
rc = ::DosStartSession(&SData, &ulSessID, &vPid);
if (rc == 0)
{
PTIB ptib;
PPIB ppib;
::DosGetInfoBlocks(&ptib, &ppib);
::DosWaitChild( DCWA_PROCESS
,DCWW_WAIT
,&vResult
,&ppib->pib_ulpid
,vPid
); );
else }
wxStrcpy(zTmp, zShell); return (rc != 0);
return (wxExecute((wxChar*)zTmp, FALSE) != 0);
} }
// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX) // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)

64
src/os2/utilsexc.cpp
View File

@@ -25,6 +25,11 @@
#include "wx/os2/private.h" #include "wx/os2/private.h"
#define INCL_DOSPROCESS
#define INCL_DOSERRORS
#define INCL_DOS
#include <os2.h>
#include <ctype.h> #include <ctype.h>
#include <direct.h> #include <direct.h>
@@ -50,6 +55,7 @@ struct wxExecuteData
public: public:
~wxExecuteData() ~wxExecuteData()
{ {
cout << "Closing thread: " << endl;
DosExit(EXIT_PROCESS, 0); DosExit(EXIT_PROCESS, 0);
} }
@@ -67,8 +73,10 @@ static ULONG wxExecuteThread(
ULONG ulRc; ULONG ulRc;
PID vPidChild; PID vPidChild;
cout << "Executing thread: " << endl;
ulRc = ::DosWaitChild( DCWA_PROCESSTREE ulRc = ::DosWaitChild( DCWA_PROCESSTREE
,DCWW_WAIT ,DCWW_NOWAIT
,&pData->vResultCodes ,&pData->vResultCodes
,&vPidChild ,&vPidChild
,pData->vResultCodes.codeTerminate // process PID to look at ,pData->vResultCodes.codeTerminate // process PID to look at
@@ -78,14 +86,11 @@ static ULONG wxExecuteThread(
wxLogLastError("DosWaitChild"); wxLogLastError("DosWaitChild");
} }
delete pData; delete pData;
// ::WinSendMsg(pData->hWnd, (ULONG)wxWM_PROC_TERMINATED, 0, (MPARAM)pData);
return 0; return 0;
} }
// Unlike windows where everything needs a window, console apps in OS/2 // window procedure of a hidden window which is created just to receive
// need no windows so this is not ever used // the notification message when a process exits
MRESULT APIENTRY wxExecuteWindowCbk( MRESULT APIENTRY wxExecuteWindowCbk(
HWND hWnd HWND hWnd
, ULONG ulMessage , ULONG ulMessage
@@ -128,7 +133,11 @@ long wxExecute(
, wxProcess* pHandler , wxProcess* pHandler
) )
{ {
wxCHECK_MSG(!!rCommand, 0, wxT("empty command in wxExecute")); if (rCommand.IsEmpty())
{
cout << "empty command in wxExecute." << endl;
return 0;
}
// create the process // create the process
UCHAR vLoadError[CCHMAXPATH] = {0}; UCHAR vLoadError[CCHMAXPATH] = {0};
@@ -146,39 +155,20 @@ long wxExecute(
else else
ulExecFlag = EXEC_ASYNCRESULT; ulExecFlag = EXEC_ASYNCRESULT;
if (::DosExecPgm( (PCHAR)vLoadError rc = ::DosExecPgm( (PCHAR)vLoadError
,sizeof(vLoadError) ,sizeof(vLoadError)
,ulExecFlag ,ulExecFlag
,zArgs ,zArgs
,zEnvs ,zEnvs
,&vResultCodes ,&vResultCodes
,rCommand ,(PSZ)rCommand.c_str()
)) );
if (rc != NO_ERROR)
{ {
wxLogSysError(_("Execution of command '%s' failed"), rCommand.c_str()); wxLogSysError(_("Execution of command '%s' failed with error: %ul"), rCommand.c_str(), rc);
return 0; return 0;
} }
cout << "Executing: " << rCommand.c_str() << endl;
// PM does not need non visible object windows to run console child processes
/*
HWND hwnd = ::WinCreateWindow( HWND_DESKTOP
,wxPanelClassName
,NULL
,0
,0
,0
,0
,0
,NULLHANDLE
,NULLHANDLE
,ulWindowId
,NULL
,NULL
);
wxASSERT_MSG( hwnd, wxT("can't create a hidden window for wxExecute") );
pOldProc = ::WinSubclassWindow(hwnd, (PFNWP)&wxExecuteWindowCbk);
*/
// Alloc data // Alloc data
wxExecuteData* pData = new wxExecuteData; wxExecuteData* pData = new wxExecuteData;
@@ -205,8 +195,6 @@ long wxExecute(
if (rc != NO_ERROR) if (rc != NO_ERROR)
{ {
wxLogLastError("CreateThread in wxExecute"); wxLogLastError("CreateThread in wxExecute");
// ::WinDestroyWindow(hwnd);
delete pData; delete pData;
// the process still started up successfully... // the process still started up successfully...
@@ -214,11 +202,15 @@ long wxExecute(
} }
if (!bSync) if (!bSync)
{ {
// clean up will be done when the process terminates
// return the pid // return the pid
// warning: don't exit your app unless you actively
// kill and cleanup you child processes
// Maybe detach the process here???
// If cmd.exe need to pass DETACH to detach the process here
return vResultCodes.codeTerminate; return vResultCodes.codeTerminate;
} }
// waiting until command executed
::DosWaitThread(&vTID, DCWW_WAIT); ::DosWaitThread(&vTID, DCWW_WAIT);
ULONG ulExitCode = pData->vResultCodes.codeResult; ULONG ulExitCode = pData->vResultCodes.codeResult;