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.
}

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 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	wxString wxGetOsDescription()
	366	{
	367	wxString strVer(_T("OS/2"));
	368	ULONG ulSysInfo[QSV_MAX] = {0};
	369
	370	if (::DosQuerySysInfo( 1L,
	371	QSV_MAX,
	372	(PVOID)ulSysInfo,
	373	sizeof(ULONG) * QSV_MAX
	374	) == 0L )
	375	{
	376	wxString ver;
	377	ver.Printf( _T(" ver. %d.%d rev. %c"),
	378	int(ulSysInfo[QSV_VERSION_MAJOR] / 10),
	379	int(ulSysInfo[QSV_VERSION_MINOR]),
	380	char(ulSysInfo[QSV_VERSION_REVISION])
	381	);
	382	strVer += ver;
	383	}
	384
	385	return strVer;
	386	}
	387
	388	void wxAppTraits::InitializeGui(unsigned long &WXUNUSED(ulHab))
	389	{
	390	}
	391
	392	void wxAppTraits::TerminateGui(unsigned long WXUNUSED(ulHab))
	393	{
	394	}
	395
	396	wxToolkitInfo & wxConsoleAppTraits::GetToolkitInfo()
	397	{
	398	static wxToolkitInfo vInfo;
	399	ULONG ulSysInfo[QSV_MAX] = {0};
	400	APIRET ulrc;
	401
	402	vInfo.name = _T("wxBase");
	403	ulrc = ::DosQuerySysInfo( 1L
	404	,QSV_MAX
	405	,(PVOID)ulSysInfo
	406	,sizeof(ULONG) * QSV_MAX
	407	);
	408	if (ulrc == 0L)
	409	{
	410	vInfo.versionMajor = ulSysInfo[QSV_VERSION_MAJOR] / 10;
	411	vInfo.versionMinor = ulSysInfo[QSV_VERSION_MINOR];
	412	}
	413	vInfo.os = wxOS2_PM;
	414	return vInfo;
	415	}
	416
	417	// ---------------------------------------------------------------------------
	418	const wxChar* wxGetHomeDir(
	419	wxString* pStr
	420	)
	421	{
	422	wxString& rStrDir = *pStr;
	423
	424	// OS/2 has no idea about home,
	425	// so use the working directory instead.
	426	// However, we might have a valid HOME directory,
	427	// as is used on many machines that have unix utilities
	428	// on them, so we should use that, if available.
	429
	430	// 256 was taken from os2def.h
	431	#ifndef MAX_PATH
	432	# define MAX_PATH 256
	433	#endif
	434
	435	const wxChar szHome = wxGetenv((wxChar)"HOME");
	436	if ( szHome == NULL ) {
	437	// we're homeless, use current directory.
	438	rStrDir = wxT(".");
	439	}
	440	else
	441	rStrDir = szHome;
	442
	443	return rStrDir.c_str();
	444	}
	445
	446	// Hack for OS/2
	447	#if wxUSE_UNICODE
	448	const wxMB2WXbuf wxGetUserHome( const wxString &rUser )
	449	#else // just for binary compatibility -- there is no 'const' here
	450	wxChar* wxGetUserHome ( const wxString &rUser )
	451	#endif
	452	{
	453	wxChar* zHome;
	454	wxString sUser1(rUser);
	455
	456	wxChar *wxBuffer = new wxChar[256];
	457	#ifndef __EMX__
	458	if (!sUser1.empty())
	459	{
	460	wxChar zTmp[64];
	461
	462	if (wxGetUserId( zTmp
	463	,sizeof(zTmp)/sizeof(char)
	464	))
	465	{
	466	// Guests belong in the temp dir
	467	if (wxStricmp(zTmp, _T("annonymous")) == 0)
	468	{
	469	if ((zHome = wxGetenv(_T("TMP"))) != NULL \|\|
	470	(zHome = wxGetenv(_T("TMPDIR"))) != NULL \|\|
	471	(zHome = wxGetenv(_T("TEMP"))) != NULL)
	472	delete[] wxBuffer;
	473	return zHome ? zHome : (wxChar)_T("\\");
	474	}
	475	if (wxStricmp(zTmp, WXSTRINGCAST sUser1) == 0)
	476	sUser1 = wxEmptyString;
	477	}
	478	}
	479	#endif
	480	if (sUser1.empty())
	481	{
	482	if ((zHome = wxGetenv(_T("HOME"))) != NULL)
	483	{
	484	wxStrcpy(wxBuffer, zHome);
	485	wxUnix2DosFilename(wxBuffer);
	486	#if wxUSE_UNICODE
	487	wxWCharBuffer retBuffer (wxBuffer);
	488	delete[] wxBuffer;
	489	return retBuffer;
	490	#else
	491	wxStrcpy(zHome, wxBuffer);
	492	delete[] wxBuffer;
	493	return zHome;
	494	#endif
	495	}
	496	}
	497	delete[] wxBuffer;
	498	return (wxChar*)wxEmptyString; // No home known!
	499	}
	500
	501	wxString WXDLLEXPORT wxPMErrorToStr(ERRORID vError)
	502	{
	503	wxString sError;
	504
	505	//
	506	// Remove the high order byte -- it is useless
	507	//
	508	vError &= 0x0000ffff;
	509	switch(vError)
	510	{
	511	case PMERR_INVALID_HWND:
	512	sError = wxT("Invalid window handle specified");
	513	break;
	514
	515	case PMERR_INVALID_FLAG:
	516	sError = wxT("Invalid flag bit set");
	517	break;
	518
	519	case PMERR_NO_MSG_QUEUE:
	520	sError = wxT("No message queue available");
	521	break;
	522
	523	case PMERR_INVALID_PARM:
	524	sError = wxT("Parameter contained invalid data");
	525	break;
	526
	527	case PMERR_INVALID_PARAMETERS:
	528	sError = wxT("Parameter value is out of range");
	529	break;
	530
	531	case PMERR_PARAMETER_OUT_OF_RANGE:
	532	sError = wxT("Parameter value is out of range");
	533	break;
	534
	535	case PMERR_INVALID_INTEGER_ATOM:
	536	sError = wxT("Not a valid atom");
	537	break;
	538
	539	case PMERR_INVALID_HATOMTBL:
	540	sError = wxT("Atom table handle is invalid");
	541	break;
	542
	543	case PMERR_INVALID_ATOM_NAME:
	544	sError = wxT("Not a valid atom name");
	545	break;
	546
	547	case PMERR_ATOM_NAME_NOT_FOUND:
	548	sError = wxT("Valid name format, but cannot find name in atom table");
	549	break;
	550
	551	default:
	552	sError = wxT("Unknown error");
	553	}
	554	return(sError);
	555	} // end of wxPMErrorToStr
	556
	557	// replacement for implementation in unix/utilsunx.cpp,
	558	// to be used by all X11 based ports.
	559	struct wxEndProcessData;
	560
	561	void wxHandleProcessTermination(wxEndProcessData *WXUNUSED(proc_data))
	562	{
	563	// For now, just do nothing. To be filled in as needed.
	564	}