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

Execution control stuff

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4267 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
1999-10-29 22:29:22 +00:00
parent 33a43c5e1e
commit dde11e6053
3 changed files with 162 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/os2/app.cpp
View File

@@ -1047,25 +1047,19 @@ void wxExit()
// Yield to incoming messages // Yield to incoming messages
bool wxYield() bool wxYield()
{ {
// TODO: HAB vHab;
/* QMSG vMsg;
MSG msg;
// We want to go back to the main message loop // We want to go back to the main message loop
// if we see a WM_QUIT. (?) // if we see a WM_QUIT. (?)
#ifdef __WXWINE__ while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
while (PeekMessage(&msg, (HWND)NULL, 0, 0, PM_NOREMOVE) && msg.message != WM_QUIT)
#else
while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) && msg.message != WM_QUIT)
#endif
{ {
if ( !wxTheApp->DoMessage() ) if (!wxTheApp->DoMessage())
break; break;
} }
// If they are pending events, we must process them. // If they are pending events, we must process them.
#if wxUSE_THREADS #if wxUSE_THREADS
wxTheApp->ProcessPendingEvents(); wxTheApp->ProcessPendingEvents();
#endif #endif
*/
return TRUE; return TRUE;
} }

2
src/os2/utils.cpp
View File

@@ -70,7 +70,7 @@ bool wxGetHostName(
unsigned short nBuffer; unsigned short nBuffer;
unsigned short* pnTotalAvail; unsigned short* pnTotalAvail;
NetBiosGetInfo( (const unsigned char*)zServer NetBios32GetInfo( (const unsigned char*)zServer
,(const unsigned char*)zComputer ,(const unsigned char*)zComputer
,nLevel ,nLevel
,zBuffer ,zBuffer

286
src/os2/utilsexc.cpp
View File

@@ -25,9 +25,6 @@
#include "wx/os2/private.h" #include "wx/os2/private.h"
#define INCL_DOS
#include <os2.h>
#include <ctype.h> #include <ctype.h>
#include <direct.h> #include <direct.h>
@@ -43,220 +40,239 @@
// this message is sent when the process we're waiting for terminates // this message is sent when the process we're waiting for terminates
#define wxWM_PROC_TERMINATED (WM_USER + 10000) #define wxWM_PROC_TERMINATED (WM_USER + 10000)
#ifndef NO_ERROR
# define NO_ERROR 0
#endif
// structure describing the process we're being waiting for // structure describing the process we're being waiting for
struct wxExecuteData struct wxExecuteData
{ {
public: public:
~wxExecuteData() ~wxExecuteData()
{ {
// TODO: DosExit(EXIT_PROCESS, 0);
/*
if ( !::CloseHandle(hProcess) )
{
wxLogLastError("CloseHandle(hProcess)");
}
*/
} }
HWND hWnd; // window to send wxWM_PROC_TERMINATED to HWND hWnd; // window to send wxWM_PROC_TERMINATED to [not used]
HANDLE hProcess; // handle of the process RESULTCODES vResultCodes;
DWORD dwProcessId; // pid of the process wxProcess* pHandler;
wxProcess *handler; ULONG ulExitCode; // the exit code of the process
DWORD dwExitCode; // the exit code of the process bool bState; // set to FALSE when the process finishes
bool state; // set to FALSE when the process finishes
}; };
static ULONG wxExecuteThread(
static DWORD wxExecuteThread(wxExecuteData *data) wxExecuteData* pData
)
{ {
// TODO: ULONG ulRc;
/* PID vPidChild;
WaitForSingleObject(data->hProcess, INFINITE);
// get the exit code ulRc = ::DosWaitChild( DCWA_PROCESSTREE
if ( !GetExitCodeProcess(data->hProcess, &data->dwExitCode) ) ,DCWW_WAIT
,&pData->vResultCodes
,&vPidChild
,pData->vResultCodes.codeTerminate // process PID to look at
);
if (ulRc != NO_ERROR)
{ {
wxLogLastError("GetExitCodeProcess"); wxLogLastError("DosWaitChild");
} }
delete pData;
wxASSERT_MSG( data->dwExitCode != STILL_ACTIVE,
wxT("process should have terminated") );
// send a message indicating process termination to the window // ::WinSendMsg(pData->hWnd, (ULONG)wxWM_PROC_TERMINATED, 0, (MPARAM)pData);
SendMessage(data->hWnd, wxWM_PROC_TERMINATED, 0, (LPARAM)data);
*/
return 0; return 0;
} }
// window procedure of a hidden window which is created just to receive // Unlike windows where everything needs a window, console apps in OS/2
// the notification message when a process exits // need no windows so this is not ever used
MRESULT APIENTRY wxExecuteWindowCbk(HWND hWnd, UINT message, MRESULT APIENTRY wxExecuteWindowCbk(
MPARAM wParam, MPARAM lParam) HWND hWnd
, ULONG ulMessage
, MPARAM wParam
, MPARAM lParam
)
{ {
if ( message == wxWM_PROC_TERMINATED ) if (ulMessage == wxWM_PROC_TERMINATED)
{ {
// DestroyWindow(hWnd); // we don't need it any more wxExecuteData* pData = (wxExecuteData *)lParam;
wxExecuteData *data = (wxExecuteData *)lParam; if (pData->pHandler)
if ( data->handler )
{ {
data->handler->OnTerminate((int)data->dwProcessId, pData->pHandler->OnTerminate( (int)pData->vResultCodes.codeTerminate
(int)data->dwExitCode); ,(int)pData->vResultCodes.codeResult
);
} }
if ( data->state ) if (pData->bState)
{ {
// we're executing synchronously, tell the waiting thread // we're executing synchronously, tell the waiting thread
// that the process finished // that the process finished
data->state = 0; pData->bState = 0;
} }
else else
{ {
// asynchronous execution - we should do the clean up // asynchronous execution - we should do the clean up
delete data; delete pData;
} }
::WinDestroyWindow(hWnd); // we don't need it any more
} }
return 0; return 0;
} }
extern wxChar wxPanelClassName[]; extern wxChar wxPanelClassName[];
long wxExecute(const wxString& command, bool sync, wxProcess *handler) long wxExecute(
const wxString& rCommand
, bool bSync
, wxProcess* pHandler
)
{ {
wxCHECK_MSG( !!command, 0, wxT("empty command in wxExecute") ); wxCHECK_MSG(!!rCommand, 0, wxT("empty command in wxExecute"));
// the old code is disabled because we really need a process handle
// if we want to execute it asynchronously or even just get its
// return code and for this we must use CreateProcess() and not
// ShellExecute()
// create the process // create the process
// TODO: UCHAR vLoadError[CCHMAXPATH] = {0};
/* RESULTCODES vResultCodes = {0};
STARTUPINFO si; ULONG ulExecFlag;
memset(&si, 0, sizeof(si)); PSZ zArgs = NULL;
si.cb = sizeof(si); PSZ zEnvs = NULL;
ULONG ulWindowId;
APIRET rc;
PFNWP pOldProc;
TID vTID;
PROCESS_INFORMATION pi; if (bSync)
ulExecFlag = EXEC_SYNC;
else
ulExecFlag = EXEC_ASYNCRESULT;
if ( ::CreateProcess( if (::DosExecPgm( (PCHAR)vLoadError
NULL, // application name (use only cmd line) ,sizeof(vLoadError)
(wxChar *)command.c_str(), // full command line ,ulExecFlag
NULL, // security attributes: defaults for both ,zArgs
NULL, // the process and its main thread ,zEnvs
FALSE, // don't inherit handles ,&vResultCodes
CREATE_DEFAULT_ERROR_MODE, // flags ,rCommand
NULL, // environment (use the same) ))
NULL, // current directory (use the same)
&si, // startup info (unused here)
&pi // process info
) == 0 )
{ {
wxLogSysError(_("Execution of command '%s' failed"), command.c_str()); wxLogSysError(_("Execution of command '%s' failed"), rCommand.c_str());
return 0; return 0;
} }
// close unneeded handle // PM does not need non visible object windows to run console child processes
if ( !::CloseHandle(pi.hThread) ) /*
wxLogLastError("CloseHandle(hThread)"); HWND hwnd = ::WinCreateWindow( HWND_DESKTOP
,wxPanelClassName
// create a hidden window to receive notification about process ,NULL
// termination ,0
HWND hwnd = ::CreateWindow(wxPanelClassName, NULL, 0, 0, 0, 0, 0, NULL, ,0
(HMENU)NULL, wxGetInstance(), 0); ,0
,0
,0
,NULLHANDLE
,NULLHANDLE
,ulWindowId
,NULL
,NULL
);
wxASSERT_MSG( hwnd, wxT("can't create a hidden window for wxExecute") ); wxASSERT_MSG( hwnd, wxT("can't create a hidden window for wxExecute") );
pOldProc = ::WinSubclassWindow(hwnd, (PFNWP)&wxExecuteWindowCbk);
FARPROC ExecuteWindowInstance = MakeProcInstance((FARPROC)wxExecuteWindowCbk, */
wxGetInstance());
::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) ExecuteWindowInstance);
// Alloc data // Alloc data
wxExecuteData *data = new wxExecuteData; wxExecuteData* pData = new wxExecuteData;
data->hProcess = pi.hProcess;
data->dwProcessId = pi.dwProcessId;
data->hWnd = hwnd;
data->state = sync;
if ( sync )
{
wxASSERT_MSG( !handler, wxT("wxProcess param ignored for sync execution") );
data->handler = NULL; pData->vResultCodes = vResultCodes;
pData->hWnd = NULLHANDLE;
pData->bState = bSync;
if (bSync)
{
wxASSERT_MSG(!pHandler, wxT("wxProcess param ignored for sync execution"));
pData->pHandler = NULL;
} }
else else
{ {
// may be NULL or not // may be NULL or not
data->handler = handler; pData->pHandler = pHandler;
} }
DWORD tid; rc = ::DosCreateThread( &vTID
HANDLE hThread = ::CreateThread(NULL, ,(PFNTHREAD)&wxExecuteThread
0, ,(ULONG)pData
(LPTHREAD_START_ROUTINE)wxExecuteThread, ,CREATE_READY|STACK_SPARSE
(void *)data, ,8192
0, );
&tid); if (rc != NO_ERROR)
if ( !hThread )
{ {
wxLogLastError("CreateThread in wxExecute"); wxLogLastError("CreateThread in wxExecute");
DestroyWindow(hwnd); // ::WinDestroyWindow(hwnd);
delete data; delete pData;
// the process still started up successfully... // the process still started up successfully...
return pi.dwProcessId; return vResultCodes.codeTerminate;
} }
if (!bSync)
if ( !sync )
{ {
// clean up will be done when the process terminates // clean up will be done when the process terminates
// return the pid // return the pid
return pi.dwProcessId; return vResultCodes.codeTerminate;
} }
::DosWaitThread(&vTID, DCWW_WAIT);
// waiting until command executed ULONG ulExitCode = pData->vResultCodes.codeResult;
while ( data->state ) delete pData;
wxYield();
DWORD dwExitCode = data->dwExitCode;
delete data;
// return the exit code // return the exit code
return dwExitCode; return (long)ulExitCode;
*/
return 0;
} }
long wxExecute(char **argv, bool sync, wxProcess *handler) long wxExecute(
char** ppArgv
, bool bSync
, wxProcess* pHandler
)
{ {
wxString command; wxString sCommand;
while ( *argv != NULL ) while (*ppArgv != NULL)
{ {
command << *argv++ << ' '; sCommand << *ppArgv++ << ' ';
} }
sCommand.RemoveLast();
command.RemoveLast(); return wxExecute( sCommand
,bSync
return wxExecute(command, sync, handler); ,pHandler
);
} }
bool wxGetFullHostName(wxChar *buf, int maxSize) bool wxGetFullHostName(
wxChar* zBuf
, int nMaxSize
)
{ {
DWORD nSize = maxSize ; #if wxUSE_NET_API
// TODO: char zServer[256];
/* char zComputer[256];
if ( !::GetComputerName(buf, &nSize) ) unsigned short nLevel = 0;
{ unsigned char* zBuffer;
wxLogLastError("GetComputerName"); unsigned short nBuffer;
unsigned short* pnTotalAvail;
return FALSE; NetBios32GetInfo( (const unsigned char*)zServer
} ,(const unsigned char*)zComputer
*/ ,nLevel
,zBuffer
,nBuffer
,pnTotalAvail
);
strncpy(zBuf, zComputer, nMaxSize);
zBuf[nMaxSize] = _T('\0');
#else
strcpy(zBuf, "noname");
#endif
return *zBuf ? TRUE : FALSE;
return TRUE; return TRUE;
} }