src/os2/utils.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        utils.cpp
// Purpose:     Various utilities
// Author:      David Webster
// Modified by:
// Created:     09/17/99
// RCS-ID:      $Id$
// Copyright:   (c) David Webster
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifndef WX_PRECOMP
    #include "wx/setup.h"
    #include "wx/utils.h"
    #include "wx/app.h"
#endif  //WX_PRECOMP

#include "wx/os2/private.h"
#include "wx/intl.h"
#include "wx/apptrait.h"

#include <ctype.h>
#ifdef __EMX__
#include <dirent.h>
#endif

#include "wx/log.h"

#include <io.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>

#define PURE_32

#if defined(__WATCOMC__)
extern "C"
{
    #include <upm.h>
}
#elif !defined(__EMX__)
    #include <upm.h>
    #include <netcons.h>
    #include <netbios.h>
#endif

static const wxChar WX_SECTION[] = _T("wxWidgets");
static const wxChar eHOSTNAME[]  = _T("HostName");

// For the following functions we SHOULD fill in support
// for Windows-NT (which I don't know) as I assume it begin
// a POSIX Unix (so claims MS) that it has some special
// functions beyond those provided by WinSock

// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
bool wxGetHostName(
  wxChar*                           zBuf
, int                               nMaxSize
)
{
#if wxUSE_NET_API
    char                            zServer[256];
    char                            zComputer[256];
    unsigned long                   ulLevel = 0;
    unsigned char*                  zBuffer = NULL;
    unsigned long                   ulBuffer = 256;
    unsigned long*                  pulTotalAvail = NULL;

    NetBios32GetInfo( (const unsigned char*)zServer
                     ,(const unsigned char*)zComputer
                     ,ulLevel
                     ,zBuffer
                     ,ulBuffer
                     ,pulTotalAvail
                    );
    strcpy(zBuf, zServer);
#else
    wxChar*                         zSysname;
    const wxChar*                   zDefaultHost = _T("noname");

    if ((zSysname = wxGetenv(_T("SYSTEM_NAME"))) == NULL)
    {
        ::PrfQueryProfileString( HINI_PROFILE
                                ,(PSZ)WX_SECTION
                                ,(PSZ)eHOSTNAME
                                ,(PSZ)zDefaultHost
                                ,(void*)zBuf
                                ,(ULONG)nMaxSize - 1
                               );
    }
    else
        wxStrncpy(zBuf, zSysname, nMaxSize - 1);
    zBuf[nMaxSize] = _T('\0');
#endif
    return *zBuf ? true : false;
}

// Get user ID e.g. jacs
bool wxGetUserId(wxChar* zBuf, int nType)
{
#if defined(__VISAGECPP__) || defined(__WATCOMC__)
    // UPM procs return 0 on success
    long lrc = U32ELOCU((PUCHAR)zBuf, (PULONG)&nType);
    if (lrc == 0) return true;
#endif
    return false;
}

bool wxGetUserName( wxChar* zBuf, int nMaxSize )
{
#ifdef USE_NET_API
    wxGetUserId( zBuf, nMaxSize );
#else
    wxStrncpy(zBuf, _T("Unknown User"), nMaxSize);
#endif
    return true;
}

int wxKill(long         lPid,
           wxSignal     WXUNUSED(eSig),
           wxKillError* WXUNUSED(peError),
           int          WXUNUSED(flags))
{
    return((int)::DosKillProcess(0, (PID)lPid));
}

//
// Execute a program in an Interactive Shell
//
bool wxShell(
  const wxString&                   rCommand
)
{
    wxChar*                         zShell = _T("CMD.EXE");
    wxString                        sInputs;
    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;

    SData.Length   = sizeof(STARTDATA);
    SData.Related  = SSF_RELATED_INDEPENDENT;
    SData.FgBg     = SSF_FGBG_FORE;
    SData.TraceOpt = SSF_TRACEOPT_NONE;
    SData.PgmTitle = PgmTitle;
    SData.PgmName  = (char*)zShell;

    sInputs = _T("/C ") + rCommand;
    SData.PgmInputs     = (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 || rc == 457) // NO_ERROR or SMG_START_IN_BACKGROUND
    {
        PTIB                            ptib;
        PPIB                            ppib;

        ::DosGetInfoBlocks(&ptib, &ppib);

        ::DosWaitChild( DCWA_PROCESS
                       ,DCWW_WAIT
                       ,&vResult
                       ,&ppib->pib_ulpid
                       ,vPid
                      );
    }
    return (rc != 0);
}

// Shutdown or reboot the PC
bool wxShutdown(wxShutdownFlags WXUNUSED(wFlags))
{
    // TODO
    return false;
}

wxPowerType wxGetPowerType()
{
    // TODO
    return wxPOWER_UNKNOWN;
}

wxBatteryState wxGetBatteryState()
{
    // TODO
    return wxBATTERY_UNKNOWN_STATE;
}

// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
wxMemorySize wxGetFreeMemory()
{
    void*                           pMemptr = NULL;
    LONG                            lSize;
    ULONG                           lMemFlags;
    APIRET                          rc;

    lMemFlags = PAG_FREE;
    rc = ::DosQueryMem(pMemptr, (PULONG)&lSize, &lMemFlags);
    if (rc != 0)
        lSize = -1L;
    return (wxMemorySize)lSize;
}

// Get Process ID
unsigned long wxGetProcessId()
{
    return (unsigned long)getpid();
}

// ----------------------------------------------------------------------------
// env vars
// ----------------------------------------------------------------------------

bool wxGetEnv(const wxString& var, wxString *value)
{
    // wxGetenv is defined as getenv()
    wxChar *p = wxGetenv(var);
    if ( !p )
        return false;

    if ( value )
    {
        *value = p;
    }

    return true;
}

bool wxSetEnv(const wxString& variable, const wxChar *value)
{
#if defined(HAVE_SETENV)
    return setenv(variable.mb_str(), value ? wxString(value).mb_str().data()
                                           : NULL, 1 /* overwrite */) == 0;
#elif defined(HAVE_PUTENV)
    wxString s = variable;
    if ( value )
        s << _T('=') << value;

    // transform to ANSI
    const char *p = s.mb_str();

    // the string will be free()d by libc
    char *buf = (char *)malloc(strlen(p) + 1);
    strcpy(buf, p);

    return putenv(buf) == 0;
#else // no way to set an env var
    wxUnusedVar(variable);
    wxUnusedVar(value);
    return false;
#endif
}

void wxMilliSleep(
  unsigned long                     ulMilliseconds
)
{
    ::DosSleep(ulMilliseconds);
}

void wxMicroSleep(
  unsigned long                     ulMicroseconds
)
{
    ::DosSleep(ulMicroseconds/1000);
}

void wxSleep(
  int                               nSecs
)
{
    ::DosSleep(1000 * nSecs);
}

// Consume all events until no more left
void wxFlushEvents()
{
//  wxYield();
}

#if WXWIN_COMPATIBILITY_2_2

// Output a debug mess., in a system dependent fashion.
void wxDebugMsg(
  const wxChar*                     zFmt ...
)
{
    va_list                         vAp;
    static wxChar                   zBuffer[512];

    if (!wxTheApp->GetWantDebugOutput())
        return ;
    va_start(vAp, zFmt);
    sprintf(zBuffer, zFmt, vAp) ;
    va_end(vAp);
}

// Non-fatal error: pop up message box and (possibly) continue
void wxError(
  const wxString&                   rMsg
, const wxString&                   rTitle
)
{
    wxChar *wxBuffer = new wxChar[256];
    wxSprintf(wxBuffer, "%s\nContinue?", WXSTRINGCAST rMsg);
    if (::WinMessageBox( HWND_DESKTOP
                        ,NULL
                        ,(PSZ)wxBuffer
                        ,(PSZ)WXSTRINGCAST rTitle
                        ,0
                        ,MB_ICONEXCLAMATION | MB_YESNO
                       ) == MBID_YES)
    delete[] wxBuffer;
    wxExit();
}

// Fatal error: pop up message box and abort
void wxFatalError(
  const wxString&                   rMsg
, const wxString&                   rTitle
)
{
    unsigned long                   ulRc;

    ulRc = ::WinMessageBox( HWND_DESKTOP
                           ,NULL
                           ,WXSTRINGCAST rMsg
                           ,WXSTRINGCAST rTitle
                           ,0
                           ,MB_NOICON | MB_OK
                          );
    DosExit(EXIT_PROCESS, ulRc);
}

#endif // WXWIN_COMPATIBILITY_2_2

// Emit a beeeeeep
void wxBell()
{
    DosBeep(1000,1000); // 1kHz during 1 sec.
}


void wxAppTraits::InitializeGui(unsigned long &WXUNUSED(ulHab))
{
}

void wxAppTraits::TerminateGui(unsigned long WXUNUSED(ulHab))
{
}

wxToolkitInfo & wxConsoleAppTraits::GetToolkitInfo()
{
    static wxToolkitInfo  vInfo;
    ULONG                 ulSysInfo[QSV_MAX] = {0};
    APIRET                ulrc;

    vInfo.name = _T("wxBase");
    ulrc = ::DosQuerySysInfo( 1L
                             ,QSV_MAX
                             ,(PVOID)ulSysInfo
                             ,sizeof(ULONG) * QSV_MAX
                            );
    if (ulrc == 0L)
    {
        vInfo.versionMajor = ulSysInfo[QSV_VERSION_MAJOR] / 10;
        vInfo.versionMinor = ulSysInfo[QSV_VERSION_MINOR];
    }
    vInfo.os = wxOS2_PM;
    return vInfo;
}

// ---------------------------------------------------------------------------
const wxChar* wxGetHomeDir(
  wxString*                         pStr
)
{
    wxString&                       rStrDir = *pStr;

    // OS/2 has no idea about home,
    // so use the working directory instead.
    // However, we might have a valid HOME directory,
    // as is used on many machines that have unix utilities
    // on them, so we should use that, if available.

    // 256 was taken from os2def.h
#ifndef MAX_PATH
#  define MAX_PATH  256
#endif

    const wxChar *szHome = wxGetenv((wxChar*)"HOME");
    if ( szHome == NULL ) {
      // we're homeless, use current directory.
      rStrDir = wxT(".");
    }
    else
       rStrDir = szHome;

    return rStrDir.c_str();
}

// Hack for OS/2
#if wxUSE_UNICODE
const wxMB2WXbuf wxGetUserHome( const wxString &rUser )
#else // just for binary compatibility -- there is no 'const' here
wxChar* wxGetUserHome ( const wxString &rUser )
#endif
{
    wxChar*                         zHome;
    wxString                        sUser1(rUser);

    wxChar *wxBuffer = new wxChar[256];
#ifndef __EMX__
    if (!sUser1.empty())
    {
        wxChar                      zTmp[64];

        if (wxGetUserId( zTmp
                        ,sizeof(zTmp)/sizeof(char)
                       ))
        {
            // Guests belong in the temp dir
            if (wxStricmp(zTmp, _T("annonymous")) == 0)
            {
                if ((zHome = wxGetenv(_T("TMP"))) != NULL    ||
                    (zHome = wxGetenv(_T("TMPDIR"))) != NULL ||
                    (zHome = wxGetenv(_T("TEMP"))) != NULL)
                    delete[] wxBuffer;
                    return *zHome ? zHome : (wxChar*)_T("\\");
            }
            if (wxStricmp(zTmp, WXSTRINGCAST sUser1) == 0)
                sUser1 = _T("");
        }
    }
#endif
    if (sUser1.empty())
    {
        if ((zHome = wxGetenv(_T("HOME"))) != NULL)
        {
            wxStrcpy(wxBuffer, zHome);
            wxUnix2DosFilename(wxBuffer);
#if wxUSE_UNICODE
            wxWCharBuffer retBuffer (wxBuffer);
            delete[] wxBuffer;
            return retBuffer;
#else
            wxStrcpy(zHome, wxBuffer);
            delete[] wxBuffer;
            return zHome;
#endif
        }
    }
    delete[] wxBuffer;
    return (wxChar*)wxEmptyString; // No home known!
}

wxString WXDLLEXPORT wxPMErrorToStr(ERRORID vError)
{
    wxString                        sError;

    //
    // Remove the high order byte -- it is useless
    //
    vError &= 0x0000ffff;
    switch(vError)
    {
        case PMERR_INVALID_HWND:
            sError = wxT("Invalid window handle specified");
            break;

        case PMERR_INVALID_FLAG:
            sError = wxT("Invalid flag bit set");
            break;

        case PMERR_NO_MSG_QUEUE:
            sError = wxT("No message queue available");
            break;

        case PMERR_INVALID_PARM:
            sError = wxT("Parameter contained invalid data");
            break;

        case PMERR_INVALID_PARAMETERS:
            sError = wxT("Parameter value is out of range");
            break;

        case PMERR_PARAMETER_OUT_OF_RANGE:
            sError = wxT("Parameter value is out of range");
            break;

        case PMERR_INVALID_INTEGER_ATOM:
            sError = wxT("Not a valid atom");
            break;

        case PMERR_INVALID_HATOMTBL:
            sError = wxT("Atom table handle is invalid");
            break;

        case PMERR_INVALID_ATOM_NAME:
            sError = wxT("Not a valid atom name");
            break;

        case PMERR_ATOM_NAME_NOT_FOUND:
            sError = wxT("Valid name format, but cannot find name in atom table");
            break;

        default:
            sError = wxT("Unknown error");
    }
    return(sError);
} // end of wxPMErrorToStr

// replacement for implementation in unix/utilsunx.cpp,
// to be used by all X11 based ports.
struct wxEndProcessData;

void wxHandleProcessTermination(wxEndProcessData *WXUNUSED(proc_data))
{
    // For now, just do nothing. To be filled in as needed.
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: utils.cpp
	3	// Purpose: Various utilities
	4	// Author: David Webster
	5	// Modified by:
	6	// Created: 09/17/99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) David Webster
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifndef WX_PRECOMP
	16	#include "wx/setup.h"
	17	#include "wx/utils.h"
	18	#include "wx/app.h"
	19	#endif //WX_PRECOMP
	20
	21	#include "wx/os2/private.h"
	22	#include "wx/intl.h"
	23	#include "wx/apptrait.h"
	24
	25	#include <ctype.h>
	26	#ifdef __EMX__
	27	#include <dirent.h>
	28	#endif
	29
	30	#include "wx/log.h"
	31
	32	#include <io.h>
	33
	34	#include <stdio.h>
	35	#include <stdlib.h>
	36	#include <string.h>
	37	#include <errno.h>
	38	#include <stdarg.h>
	39
	40	#define PURE_32
	41
	42	#if defined(__WATCOMC__)
	43	extern "C"
	44	{
	45	#include <upm.h>
	46	}
	47	#elif !defined(__EMX__)
	48	#include <upm.h>
	49	#include <netcons.h>
	50	#include <netbios.h>
	51	#endif
	52
	53	static const wxChar WX_SECTION[] = _T("wxWidgets");
	54	static const wxChar eHOSTNAME[] = _T("HostName");
	55
	56	// For the following functions we SHOULD fill in support
	57	// for Windows-NT (which I don't know) as I assume it begin
	58	// a POSIX Unix (so claims MS) that it has some special
	59	// functions beyond those provided by WinSock
	60
	61	// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
	62	bool wxGetHostName(
	63	wxChar* zBuf
	64	, int nMaxSize
	65	)
	66	{
	67	#if wxUSE_NET_API
	68	char zServer[256];
	69	char zComputer[256];
	70	unsigned long ulLevel = 0;
	71	unsigned char* zBuffer = NULL;
	72	unsigned long ulBuffer = 256;
	73	unsigned long* pulTotalAvail = NULL;
	74
	75	NetBios32GetInfo( (const unsigned char*)zServer
	76	,(const unsigned char*)zComputer
	77	,ulLevel
	78	,zBuffer
	79	,ulBuffer
	80	,pulTotalAvail
	81	);
	82	strcpy(zBuf, zServer);
	83	#else
	84	wxChar* zSysname;
	85	const wxChar* zDefaultHost = _T("noname");
	86
	87	if ((zSysname = wxGetenv(_T("SYSTEM_NAME"))) == NULL)
	88	{
	89	::PrfQueryProfileString( HINI_PROFILE
	90	,(PSZ)WX_SECTION
	91	,(PSZ)eHOSTNAME
	92	,(PSZ)zDefaultHost
	93	,(void*)zBuf
	94	,(ULONG)nMaxSize - 1
	95	);
	96	}
	97	else
	98	wxStrncpy(zBuf, zSysname, nMaxSize - 1);
	99	zBuf[nMaxSize] = _T('\0');
	100	#endif
	101	return *zBuf ? true : false;
	102	}
	103
	104	// Get user ID e.g. jacs
	105	bool wxGetUserId(wxChar* zBuf, int nType)
	106	{
	107	#if defined(__VISAGECPP__) \|\| defined(__WATCOMC__)
	108	// UPM procs return 0 on success
	109	long lrc = U32ELOCU((PUCHAR)zBuf, (PULONG)&nType);
	110	if (lrc == 0) return true;
	111	#endif
	112	return false;
	113	}
	114
	115	bool wxGetUserName( wxChar* zBuf, int nMaxSize )
	116	{
	117	#ifdef USE_NET_API
	118	wxGetUserId( zBuf, nMaxSize );
	119	#else
	120	wxStrncpy(zBuf, _T("Unknown User"), nMaxSize);
	121	#endif
	122	return true;
	123	}
	124
	125	int wxKill(long lPid,
	126	wxSignal WXUNUSED(eSig),
	127	wxKillError* WXUNUSED(peError),
	128	int WXUNUSED(flags))
	129	{
	130	return((int)::DosKillProcess(0, (PID)lPid));
	131	}
	132
	133	//
	134	// Execute a program in an Interactive Shell
	135	//
	136	bool wxShell(
	137	const wxString& rCommand
	138	)
	139	{
	140	wxChar* zShell = _T("CMD.EXE");
	141	wxString sInputs;
	142	STARTDATA SData = {0};
	143	PSZ PgmTitle = "Command Shell";
	144	APIRET rc;
	145	PID vPid = 0;
	146	ULONG ulSessID = 0;
	147	UCHAR achObjBuf[256] = {0}; //error data if DosStart fails
	148	RESULTCODES vResult;
	149
	150	SData.Length = sizeof(STARTDATA);
	151	SData.Related = SSF_RELATED_INDEPENDENT;
	152	SData.FgBg = SSF_FGBG_FORE;
	153	SData.TraceOpt = SSF_TRACEOPT_NONE;
	154	SData.PgmTitle = PgmTitle;
	155	SData.PgmName = (char*)zShell;
	156
	157	sInputs = _T("/C ") + rCommand;
	158	SData.PgmInputs = (BYTE*)sInputs.c_str();
	159	SData.TermQ = 0;
	160	SData.Environment = 0;
	161	SData.InheritOpt = SSF_INHERTOPT_SHELL;
	162	SData.SessionType = SSF_TYPE_WINDOWABLEVIO;
	163	SData.IconFile = 0;
	164	SData.PgmHandle = 0;
	165	SData.PgmControl = SSF_CONTROL_VISIBLE \| SSF_CONTROL_MAXIMIZE;
	166	SData.InitXPos = 30;
	167	SData.InitYPos = 40;
	168	SData.InitXSize = 200;
	169	SData.InitYSize = 140;
	170	SData.Reserved = 0;
	171	SData.ObjectBuffer = (char*)achObjBuf;
	172	SData.ObjectBuffLen = (ULONG)sizeof(achObjBuf);
	173
	174	rc = ::DosStartSession(&SData, &ulSessID, &vPid);
	175	if (rc == 0 \|\| rc == 457) // NO_ERROR or SMG_START_IN_BACKGROUND
	176	{
	177	PTIB ptib;
	178	PPIB ppib;
	179
	180	::DosGetInfoBlocks(&ptib, &ppib);
	181
	182	::DosWaitChild( DCWA_PROCESS
	183	,DCWW_WAIT
	184	,&vResult
	185	,&ppib->pib_ulpid
	186	,vPid
	187	);
	188	}
	189	return (rc != 0);
	190	}
	191
	192	// Shutdown or reboot the PC
	193	bool wxShutdown(wxShutdownFlags WXUNUSED(wFlags))
	194	{
	195	// TODO
	196	return false;
	197	}
	198
	199	wxPowerType wxGetPowerType()
	200	{
	201	// TODO
	202	return wxPOWER_UNKNOWN;
	203	}
	204
	205	wxBatteryState wxGetBatteryState()
	206	{
	207	// TODO
	208	return wxBATTERY_UNKNOWN_STATE;
	209	}
	210
	211	// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
	212	wxMemorySize wxGetFreeMemory()
	213	{
	214	void* pMemptr = NULL;
	215	LONG lSize;
	216	ULONG lMemFlags;
	217	APIRET rc;
	218
	219	lMemFlags = PAG_FREE;
	220	rc = ::DosQueryMem(pMemptr, (PULONG)&lSize, &lMemFlags);
	221	if (rc != 0)
	222	lSize = -1L;
	223	return (wxMemorySize)lSize;
	224	}
	225
	226	// Get Process ID
	227	unsigned long wxGetProcessId()
	228	{
	229	return (unsigned long)getpid();
	230	}
	231
	232	// ----------------------------------------------------------------------------
	233	// env vars
	234	// ----------------------------------------------------------------------------
	235
	236	bool wxGetEnv(const wxString& var, wxString *value)
	237	{
	238	// wxGetenv is defined as getenv()
	239	wxChar *p = wxGetenv(var);
	240	if ( !p )
	241	return false;
	242
	243	if ( value )
	244	{
	245	*value = p;
	246	}
	247
	248	return true;
	249	}
	250
	251	bool wxSetEnv(const wxString& variable, const wxChar *value)
	252	{
	253	#if defined(HAVE_SETENV)
	254	return setenv(variable.mb_str(), value ? wxString(value).mb_str().data()
	255	: NULL, 1 /* overwrite */) == 0;
	256	#elif defined(HAVE_PUTENV)
	257	wxString s = variable;
	258	if ( value )
	259	s << _T('=') << value;
	260
	261	// transform to ANSI
	262	const char *p = s.mb_str();
	263
	264	// the string will be free()d by libc
	265	char buf = (char )malloc(strlen(p) + 1);
	266	strcpy(buf, p);
	267
	268	return putenv(buf) == 0;
	269	#else // no way to set an env var
	270	wxUnusedVar(variable);
	271	wxUnusedVar(value);
	272	return false;
	273	#endif
	274	}
	275
	276	void wxMilliSleep(
	277	unsigned long ulMilliseconds
	278	)
	279	{
	280	::DosSleep(ulMilliseconds);
	281	}
	282
	283	void wxMicroSleep(
	284	unsigned long ulMicroseconds
	285	)
	286	{
	287	::DosSleep(ulMicroseconds/1000);
	288	}
	289
	290	void wxSleep(
	291	int nSecs
	292	)
	293	{
	294	::DosSleep(1000 * nSecs);
	295	}
	296
	297	// Consume all events until no more left
	298	void wxFlushEvents()
	299	{
	300	// wxYield();
	301	}
	302
	303	#if WXWIN_COMPATIBILITY_2_2
	304
	305	// Output a debug mess., in a system dependent fashion.
	306	void wxDebugMsg(
	307	const wxChar* zFmt ...
	308	)
	309	{
	310	va_list vAp;
	311	static wxChar zBuffer[512];
	312
	313	if (!wxTheApp->GetWantDebugOutput())
	314	return ;
	315	va_start(vAp, zFmt);
	316	sprintf(zBuffer, zFmt, vAp) ;
	317	va_end(vAp);
	318	}
	319
	320	// Non-fatal error: pop up message box and (possibly) continue
	321	void wxError(
	322	const wxString& rMsg
	323	, const wxString& rTitle
	324	)
	325	{
	326	wxChar *wxBuffer = new wxChar[256];
	327	wxSprintf(wxBuffer, "%s\nContinue?", WXSTRINGCAST rMsg);
	328	if (::WinMessageBox( HWND_DESKTOP
	329	,NULL
	330	,(PSZ)wxBuffer
	331	,(PSZ)WXSTRINGCAST rTitle
	332	,0
	333	,MB_ICONEXCLAMATION \| MB_YESNO
	334	) == MBID_YES)
	335	delete[] wxBuffer;
	336	wxExit();
	337	}
	338
	339	// Fatal error: pop up message box and abort
	340	void wxFatalError(
	341	const wxString& rMsg
	342	, const wxString& rTitle
	343	)
	344	{
	345	unsigned long ulRc;
	346
	347	ulRc = ::WinMessageBox( HWND_DESKTOP
	348	,NULL
	349	,WXSTRINGCAST rMsg
	350	,WXSTRINGCAST rTitle
	351	,0
	352	,MB_NOICON \| MB_OK
	353	);
	354	DosExit(EXIT_PROCESS, ulRc);
	355	}
	356
	357	#endif // WXWIN_COMPATIBILITY_2_2
	358
	359	// Emit a beeeeeep
	360	void wxBell()
	361	{
	362	DosBeep(1000,1000); // 1kHz during 1 sec.
	363	}
	364
	365
	366	void wxAppTraits::InitializeGui(unsigned long &WXUNUSED(ulHab))
	367	{
	368	}
	369
	370	void wxAppTraits::TerminateGui(unsigned long WXUNUSED(ulHab))
	371	{
	372	}
	373
	374	wxToolkitInfo & wxConsoleAppTraits::GetToolkitInfo()
	375	{
	376	static wxToolkitInfo vInfo;
	377	ULONG ulSysInfo[QSV_MAX] = {0};
	378	APIRET ulrc;
	379
	380	vInfo.name = _T("wxBase");
	381	ulrc = ::DosQuerySysInfo( 1L
	382	,QSV_MAX
	383	,(PVOID)ulSysInfo
	384	,sizeof(ULONG) * QSV_MAX
	385	);
	386	if (ulrc == 0L)
	387	{
	388	vInfo.versionMajor = ulSysInfo[QSV_VERSION_MAJOR] / 10;
	389	vInfo.versionMinor = ulSysInfo[QSV_VERSION_MINOR];
	390	}
	391	vInfo.os = wxOS2_PM;
	392	return vInfo;
	393	}
	394
	395	// ---------------------------------------------------------------------------
	396	const wxChar* wxGetHomeDir(
	397	wxString* pStr
	398	)
	399	{
	400	wxString& rStrDir = *pStr;
	401
	402	// OS/2 has no idea about home,
	403	// so use the working directory instead.
	404	// However, we might have a valid HOME directory,
	405	// as is used on many machines that have unix utilities
	406	// on them, so we should use that, if available.
	407
	408	// 256 was taken from os2def.h
	409	#ifndef MAX_PATH
	410	# define MAX_PATH 256
	411	#endif
	412
	413	const wxChar szHome = wxGetenv((wxChar)"HOME");
	414	if ( szHome == NULL ) {
	415	// we're homeless, use current directory.
	416	rStrDir = wxT(".");
	417	}
	418	else
	419	rStrDir = szHome;
	420
	421	return rStrDir.c_str();
	422	}
	423
	424	// Hack for OS/2
	425	#if wxUSE_UNICODE
	426	const wxMB2WXbuf wxGetUserHome( const wxString &rUser )
	427	#else // just for binary compatibility -- there is no 'const' here
	428	wxChar* wxGetUserHome ( const wxString &rUser )
	429	#endif
	430	{
	431	wxChar* zHome;
	432	wxString sUser1(rUser);
	433
	434	wxChar *wxBuffer = new wxChar[256];
	435	#ifndef __EMX__
	436	if (!sUser1.empty())
	437	{
	438	wxChar zTmp[64];
	439
	440	if (wxGetUserId( zTmp
	441	,sizeof(zTmp)/sizeof(char)
	442	))
	443	{
	444	// Guests belong in the temp dir
	445	if (wxStricmp(zTmp, _T("annonymous")) == 0)
	446	{
	447	if ((zHome = wxGetenv(_T("TMP"))) != NULL \|\|
	448	(zHome = wxGetenv(_T("TMPDIR"))) != NULL \|\|
	449	(zHome = wxGetenv(_T("TEMP"))) != NULL)
	450	delete[] wxBuffer;
	451	return zHome ? zHome : (wxChar)_T("\\");
	452	}
	453	if (wxStricmp(zTmp, WXSTRINGCAST sUser1) == 0)
	454	sUser1 = _T("");
	455	}
	456	}
	457	#endif
	458	if (sUser1.empty())
	459	{
	460	if ((zHome = wxGetenv(_T("HOME"))) != NULL)
	461	{
	462	wxStrcpy(wxBuffer, zHome);
	463	wxUnix2DosFilename(wxBuffer);
	464	#if wxUSE_UNICODE
	465	wxWCharBuffer retBuffer (wxBuffer);
	466	delete[] wxBuffer;
	467	return retBuffer;
	468	#else
	469	wxStrcpy(zHome, wxBuffer);
	470	delete[] wxBuffer;
	471	return zHome;
	472	#endif
	473	}
	474	}
	475	delete[] wxBuffer;
	476	return (wxChar*)wxEmptyString; // No home known!
	477	}
	478
	479	wxString WXDLLEXPORT wxPMErrorToStr(ERRORID vError)
	480	{
	481	wxString sError;
	482
	483	//
	484	// Remove the high order byte -- it is useless
	485	//
	486	vError &= 0x0000ffff;
	487	switch(vError)
	488	{
	489	case PMERR_INVALID_HWND:
	490	sError = wxT("Invalid window handle specified");
	491	break;
	492
	493	case PMERR_INVALID_FLAG:
	494	sError = wxT("Invalid flag bit set");
	495	break;
	496
	497	case PMERR_NO_MSG_QUEUE:
	498	sError = wxT("No message queue available");
	499	break;
	500
	501	case PMERR_INVALID_PARM:
	502	sError = wxT("Parameter contained invalid data");
	503	break;
	504
	505	case PMERR_INVALID_PARAMETERS:
	506	sError = wxT("Parameter value is out of range");
	507	break;
	508
	509	case PMERR_PARAMETER_OUT_OF_RANGE:
	510	sError = wxT("Parameter value is out of range");
	511	break;
	512
	513	case PMERR_INVALID_INTEGER_ATOM:
	514	sError = wxT("Not a valid atom");
	515	break;
	516
	517	case PMERR_INVALID_HATOMTBL:
	518	sError = wxT("Atom table handle is invalid");
	519	break;
	520
	521	case PMERR_INVALID_ATOM_NAME:
	522	sError = wxT("Not a valid atom name");
	523	break;
	524
	525	case PMERR_ATOM_NAME_NOT_FOUND:
	526	sError = wxT("Valid name format, but cannot find name in atom table");
	527	break;
	528
	529	default:
	530	sError = wxT("Unknown error");
	531	}
	532	return(sError);
	533	} // end of wxPMErrorToStr
	534
	535	// replacement for implementation in unix/utilsunx.cpp,
	536	// to be used by all X11 based ports.
	537	struct wxEndProcessData;
	538
	539	void wxHandleProcessTermination(wxEndProcessData *WXUNUSED(proc_data))
	540	{
	541	// For now, just do nothing. To be filled in as needed.
	542	}