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

#ifndef __EMX__
#include <upm.h>
#include <netcons.h>
#include <netbios.h>
#endif

static const wxChar WX_SECTION[] = _T("wxWidgets");
static const wxChar eHOSTNAME[]  = _T("HostName");
static const wxChar eUSERID[]    = _T("UserId");
static const wxChar eUSERNAME[]  = _T("UserName");

// 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__)
    long                            lrc;
    // UPM procs return 0 on success
    lrc = U32ELOCU((unsigned char*)zBuf, (unsigned long *)&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                          eSig
, wxKillError*                      peError
, int                               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  = zShell;

    sInputs = "/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 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;
    ULONG                           lSize;
    ULONG                           lMemFlags;
    APIRET                          rc;

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

// ----------------------------------------------------------------------------
// 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
    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 &ulHab)
{
}

void wxAppTraits::TerminateGui(unsigned long 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("HOME");
    if ( szHome == NULL ) {
      // we're homeless, use current directory.
      rStrDir = wxT(".");
    }
    else
       rStrDir = szHome;

    return rStrDir.c_str();
}

// Hack for OS/2
wxChar* wxGetUserHome (
  const wxString&                   rUser
)
{
    wxChar*                         zHome;
    wxString                        sUser1(rUser);

    char *wxBuffer = new wxChar[256];
#ifndef __EMX__
    if (sUser1 != _T(""))
    {
        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 == _T(""))
    {
        if ((zHome = wxGetenv(_T("HOME"))) != NULL)
        {
            wxStrcpy(wxBuffer, zHome);
            wxUnix2DosFilename(wxBuffer);
            wxStrcpy(zHome, wxBuffer);
            delete[] wxBuffer;
            return zHome;
        }
    }
    delete[] wxBuffer;
    return NULL; // No home known!
}

bool wxDirExists(
  const wxString&                   rDir
)
{
    return (::DosSetCurrentDir(WXSTRINGCAST rDir));
}

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 *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	#ifndef __EMX__
	43	#include <upm.h>
	44	#include <netcons.h>
	45	#include <netbios.h>
	46	#endif
	47
	48	static const wxChar WX_SECTION[] = _T("wxWidgets");
	49	static const wxChar eHOSTNAME[] = _T("HostName");
	50	static const wxChar eUSERID[] = _T("UserId");
	51	static const wxChar eUSERNAME[] = _T("UserName");
	52
	53	// For the following functions we SHOULD fill in support
	54	// for Windows-NT (which I don't know) as I assume it begin
	55	// a POSIX Unix (so claims MS) that it has some special
	56	// functions beyond those provided by WinSock
	57
	58	// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
	59	bool wxGetHostName(
	60	wxChar* zBuf
	61	, int nMaxSize
	62	)
	63	{
	64	#if wxUSE_NET_API
	65	char zServer[256];
	66	char zComputer[256];
	67	unsigned long ulLevel = 0;
	68	unsigned char* zBuffer = NULL;
	69	unsigned long ulBuffer = 256;
	70	unsigned long* pulTotalAvail = NULL;
	71
	72	NetBios32GetInfo( (const unsigned char*)zServer
	73	,(const unsigned char*)zComputer
	74	,ulLevel
	75	,zBuffer
	76	,ulBuffer
	77	,pulTotalAvail
	78	);
	79	strcpy(zBuf, zServer);
	80	#else
	81	wxChar* zSysname;
	82	const wxChar* zDefaultHost = _T("noname");
	83
	84	if ((zSysname = wxGetenv(_T("SYSTEM_NAME"))) == NULL)
	85	{
	86	::PrfQueryProfileString( HINI_PROFILE
	87	,(PSZ)WX_SECTION
	88	,(PSZ)eHOSTNAME
	89	,(PSZ)zDefaultHost
	90	,(void*)zBuf
	91	,(ULONG)nMaxSize - 1
	92	);
	93	}
	94	else
	95	wxStrncpy(zBuf, zSysname, nMaxSize - 1);
	96	zBuf[nMaxSize] = _T('\0');
	97	#endif
	98	return *zBuf ? true : false;
	99	}
	100
	101	// Get user ID e.g. jacs
	102	bool wxGetUserId(
	103	wxChar* zBuf
	104	, int nType
	105	)
	106	{
	107	#if defined(__VISAGECPP__)
	108	long lrc;
	109	// UPM procs return 0 on success
	110	lrc = U32ELOCU((unsigned char)zBuf, (unsigned long )&nType);
	111	if (lrc == 0) return true;
	112	#endif
	113	return false;
	114	}
	115
	116	bool wxGetUserName(
	117	wxChar* zBuf
	118	, int nMaxSize
	119	)
	120	{
	121	#ifdef USE_NET_API
	122	wxGetUserId( zBuf
	123	,nMaxSize
	124	);
	125	#else
	126	wxStrncpy(zBuf, _T("Unknown User"), nMaxSize);
	127	#endif
	128	return true;
	129	}
	130
	131	int wxKill(
	132	long lPid
	133	, wxSignal eSig
	134	, wxKillError* peError
	135	, int flags
	136	)
	137	{
	138	return((int)::DosKillProcess(0, (PID)lPid));
	139	}
	140
	141	//
	142	// Execute a program in an Interactive Shell
	143	//
	144	bool wxShell(
	145	const wxString& rCommand
	146	)
	147	{
	148	wxChar* zShell = _T("CMD.EXE");
	149	wxString sInputs;
	150	STARTDATA SData = {0};
	151	PSZ PgmTitle = "Command Shell";
	152	APIRET rc;
	153	PID vPid = 0;
	154	ULONG ulSessID = 0;
	155	UCHAR achObjBuf[256] = {0}; //error data if DosStart fails
	156	RESULTCODES vResult;
	157
	158	SData.Length = sizeof(STARTDATA);
	159	SData.Related = SSF_RELATED_INDEPENDENT;
	160	SData.FgBg = SSF_FGBG_FORE;
	161	SData.TraceOpt = SSF_TRACEOPT_NONE;
	162	SData.PgmTitle = PgmTitle;
	163	SData.PgmName = zShell;
	164
	165	sInputs = "/C " + rCommand;
	166	SData.PgmInputs = (BYTE*)sInputs.c_str();
	167	SData.TermQ = 0;
	168	SData.Environment = 0;
	169	SData.InheritOpt = SSF_INHERTOPT_SHELL;
	170	SData.SessionType = SSF_TYPE_WINDOWABLEVIO;
	171	SData.IconFile = 0;
	172	SData.PgmHandle = 0;
	173	SData.PgmControl = SSF_CONTROL_VISIBLE \| SSF_CONTROL_MAXIMIZE;
	174	SData.InitXPos = 30;
	175	SData.InitYPos = 40;
	176	SData.InitXSize = 200;
	177	SData.InitYSize = 140;
	178	SData.Reserved = 0;
	179	SData.ObjectBuffer = (char*)achObjBuf;
	180	SData.ObjectBuffLen = (ULONG)sizeof(achObjBuf);
	181
	182	rc = ::DosStartSession(&SData, &ulSessID, &vPid);
	183	if (rc == 0 \|\| rc == 457) // NO_ERROR or SMG_START_IN_BACKGROUND
	184	{
	185	PTIB ptib;
	186	PPIB ppib;
	187
	188	::DosGetInfoBlocks(&ptib, &ppib);
	189
	190	::DosWaitChild( DCWA_PROCESS
	191	,DCWW_WAIT
	192	,&vResult
	193	,&ppib->pib_ulpid
	194	,vPid
	195	);
	196	}
	197	return (rc != 0);
	198	}
	199
	200	// Shutdown or reboot the PC
	201	bool wxShutdown(wxShutdownFlags wFlags)
	202	{
	203	// TODO
	204	return false;
	205	}
	206
	207	wxPowerType wxGetPowerType()
	208	{
	209	// TODO
	210	return wxPOWER_UNKNOWN;
	211	}
	212
	213	wxBatteryState wxGetBatteryState()
	214	{
	215	// TODO
	216	return wxBATTERY_UNKNOWN_STATE;
	217	}
	218
	219	// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
	220	wxMemorySize wxGetFreeMemory()
	221	{
	222	void* pMemptr = NULL;
	223	ULONG lSize;
	224	ULONG lMemFlags;
	225	APIRET rc;
	226
	227	lMemFlags = PAG_FREE;
	228	rc = ::DosQueryMem(pMemptr, &lSize, &lMemFlags);
	229	if (rc != 0)
	230	lSize = -1L;
	231	return (wxMemorySize)lSize;
	232	}
	233
	234	// ----------------------------------------------------------------------------
	235	// env vars
	236	// ----------------------------------------------------------------------------
	237
	238	bool wxGetEnv(const wxString& var, wxString *value)
	239	{
	240	// wxGetenv is defined as getenv()
	241	wxChar *p = wxGetenv(var);
	242	if ( !p )
	243	return false;
	244
	245	if ( value )
	246	{
	247	*value = p;
	248	}
	249
	250	return true;
	251	}
	252
	253	bool wxSetEnv(const wxString& variable, const wxChar *value)
	254	{
	255	#if defined(HAVE_SETENV)
	256	return setenv(variable.mb_str(), value ? wxString(value).mb_str().data()
	257	: NULL, 1 /* overwrite */) == 0;
	258	#elif defined(HAVE_PUTENV)
	259	wxString s = variable;
	260	if ( value )
	261	s << _T('=') << value;
	262
	263	// transform to ANSI
	264	const char *p = s.mb_str();
	265
	266	// the string will be free()d by libc
	267	char buf = (char )malloc(strlen(p) + 1);
	268	strcpy(buf, p);
	269
	270	return putenv(buf) == 0;
	271	#else // no way to set an env var
	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 &ulHab)
	367	{
	368	}
	369
	370	void wxAppTraits::TerminateGui(unsigned long 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("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	wxChar* wxGetUserHome (
	426	const wxString& rUser
	427	)
	428	{
	429	wxChar* zHome;
	430	wxString sUser1(rUser);
	431
	432	char *wxBuffer = new wxChar[256];
	433	#ifndef __EMX__
	434	if (sUser1 != _T(""))
	435	{
	436	wxChar zTmp[64];
	437
	438	if (wxGetUserId( zTmp
	439	,sizeof(zTmp)/sizeof(char)
	440	))
	441	{
	442	// Guests belong in the temp dir
	443	if (wxStricmp(zTmp, _T("annonymous")) == 0)
	444	{
	445	if ((zHome = wxGetenv(_T("TMP"))) != NULL \|\|
	446	(zHome = wxGetenv(_T("TMPDIR"))) != NULL \|\|
	447	(zHome = wxGetenv(_T("TEMP"))) != NULL)
	448	delete[] wxBuffer;
	449	return zHome ? zHome : (wxChar)_T("\\");
	450	}
	451	if (wxStricmp(zTmp, WXSTRINGCAST sUser1) == 0)
	452	sUser1 = _T("");
	453	}
	454	}
	455	#endif
	456	if (sUser1 == _T(""))
	457	{
	458	if ((zHome = wxGetenv(_T("HOME"))) != NULL)
	459	{
	460	wxStrcpy(wxBuffer, zHome);
	461	wxUnix2DosFilename(wxBuffer);
	462	wxStrcpy(zHome, wxBuffer);
	463	delete[] wxBuffer;
	464	return zHome;
	465	}
	466	}
	467	delete[] wxBuffer;
	468	return NULL; // No home known!
	469	}
	470
	471	bool wxDirExists(
	472	const wxString& rDir
	473	)
	474	{
	475	return (::DosSetCurrentDir(WXSTRINGCAST rDir));
	476	}
	477
	478	wxString WXDLLEXPORT wxPMErrorToStr(
	479	ERRORID vError
	480	)
	481	{
	482	wxString sError;
	483
	484	//
	485	// Remove the high order byte -- it is useless
	486	//
	487	vError &= 0x0000ffff;
	488	switch(vError)
	489	{
	490	case PMERR_INVALID_HWND:
	491	sError = wxT("Invalid window handle specified");
	492	break;
	493
	494	case PMERR_INVALID_FLAG:
	495	sError = wxT("Invalid flag bit set");
	496	break;
	497
	498	case PMERR_NO_MSG_QUEUE:
	499	sError = wxT("No message queue available");
	500	break;
	501
	502	case PMERR_INVALID_PARM:
	503	sError = wxT("Parameter contained invalid data");
	504	break;
	505
	506	case PMERR_INVALID_PARAMETERS:
	507	sError = wxT("Parameter value is out of range");
	508	break;
	509
	510	case PMERR_PARAMETER_OUT_OF_RANGE:
	511	sError = wxT("Parameter value is out of range");
	512	break;
	513
	514	case PMERR_INVALID_INTEGER_ATOM:
	515	sError = wxT("Not a valid atom");
	516	break;
	517
	518	case PMERR_INVALID_HATOMTBL:
	519	sError = wxT("Atom table handle is invalid");
	520	break;
	521
	522	case PMERR_INVALID_ATOM_NAME:
	523	sError = wxT("Not a valid atom name");
	524	break;
	525
	526	case PMERR_ATOM_NAME_NOT_FOUND:
	527	sError = wxT("Valid name format, but cannot find name in atom table");
	528	break;
	529
	530	default:
	531	sError = wxT("Unknown error");
	532	}
	533	return(sError);
	534	} // end of wxPMErrorToStr
	535
	536	// replacement for implementation in unix/utilsunx.cpp,
	537	// to be used by all X11 based ports.
	538	struct wxEndProcessData;
	539
	540	void wxHandleProcessTermination(wxEndProcessData *proc_data)
	541	{
	542	// For now, just do nothing. To be filled in as needed.
	543	}