src/os2/utils.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/os2/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"

#include "wx/utils.h"

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/intl.h"
    #include "wx/log.h"
#endif  //WX_PRECOMP

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

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


#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 (!zBuf) return false;

#if defined(wxUSE_NET_API) && 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();
}

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

wxString wxGetOsDescription()
{
    wxString strVer(_T("OS/2"));
    ULONG ulSysInfo[QSV_MAX] = {0};

    if (::DosQuerySysInfo( 1L,
                           QSV_MAX,
                           (PVOID)ulSysInfo,
                           sizeof(ULONG) * QSV_MAX
                         ) == 0L )
    {
        wxString ver;
        ver.Printf( _T(" ver. %d.%d rev. %c"),
                    int(ulSysInfo[QSV_VERSION_MAJOR] / 10),
                    int(ulSysInfo[QSV_VERSION_MINOR]),
                    char(ulSysInfo[QSV_VERSION_REVISION])
                  );
        strVer += ver;
    }

    return strVer;
}

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