src/os2/utils.cpp

   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     LONG                            lSize;
 224     ULONG                           lMemFlags;
 225     APIRET                          rc;
 226
 227     lMemFlags = PAG_FREE;
 228     rc = ::DosQueryMem(pMemptr, (PULONG)&lSize, &lMemFlags);
 229     if (rc != 0)
 230         lSize = -1L;
 231     return (wxMemorySize)lSize;
 232 }
 233
 234 // Get Process ID
 235 unsigned long wxGetProcessId()
 236 {
 237     return (unsigned long)getpid();
 238 }
 239
 240 // ----------------------------------------------------------------------------
 241 // env vars
 242 // ----------------------------------------------------------------------------
 243
 244 bool wxGetEnv(const wxString& var, wxString *value)
 245 {
 246     // wxGetenv is defined as getenv()
 247     wxChar *p = wxGetenv(var);
 248     if ( !p )
 249         return false;
 250
 251     if ( value )
 252     {
 253         *value = p;
 254     }
 255
 256     return true;
 257 }
 258
 259 bool wxSetEnv(const wxString& variable, const wxChar *value)
 260 {
 261 #if defined(HAVE_SETENV)
 262     return setenv(variable.mb_str(), value ? wxString(value).mb_str().data()
 263                                            : NULL, 1 /* overwrite */) == 0;
 264 #elif defined(HAVE_PUTENV)
 265     wxString s = variable;
 266     if ( value )
 267         s << _T('=') << value;
 268
 269     // transform to ANSI
 270     const char *p = s.mb_str();
 271
 272     // the string will be free()d by libc
 273     char *buf = (char *)malloc(strlen(p) + 1);
 274     strcpy(buf, p);
 275
 276     return putenv(buf) == 0;
 277 #else // no way to set an env var
 278     return false;
 279 #endif
 280 }
 281
 282 void wxMilliSleep(
 283   unsigned long                     ulMilliseconds
 284 )
 285 {
 286     ::DosSleep(ulMilliseconds);
 287 }
 288
 289 void wxMicroSleep(
 290   unsigned long                     ulMicroseconds
 291 )
 292 {
 293     ::DosSleep(ulMicroseconds/1000);
 294 }
 295
 296 void wxSleep(
 297   int                               nSecs
 298 )
 299 {
 300     ::DosSleep(1000 * nSecs);
 301 }
 302
 303 // Consume all events until no more left
 304 void wxFlushEvents()
 305 {
 306 //  wxYield();
 307 }
 308
 309 #if WXWIN_COMPATIBILITY_2_2
 310
 311 // Output a debug mess., in a system dependent fashion.
 312 void wxDebugMsg(
 313   const wxChar*                     zFmt ...
 314 )
 315 {
 316     va_list                         vAp;
 317     static wxChar                   zBuffer[512];
 318
 319     if (!wxTheApp->GetWantDebugOutput())
 320         return ;
 321     va_start(vAp, zFmt);
 322     sprintf(zBuffer, zFmt, vAp) ;
 323     va_end(vAp);
 324 }
 325
 326 // Non-fatal error: pop up message box and (possibly) continue
 327 void wxError(
 328   const wxString&                   rMsg
 329 , const wxString&                   rTitle
 330 )
 331 {
 332     wxChar *wxBuffer = new wxChar[256];
 333     wxSprintf(wxBuffer, "%s\nContinue?", WXSTRINGCAST rMsg);
 334     if (::WinMessageBox( HWND_DESKTOP
 335                         ,NULL
 336                         ,(PSZ)wxBuffer
 337                         ,(PSZ)WXSTRINGCAST rTitle
 338                         ,0
 339                         ,MB_ICONEXCLAMATION | MB_YESNO
 340                        ) == MBID_YES)
 341     delete[] wxBuffer;
 342     wxExit();
 343 }
 344
 345 // Fatal error: pop up message box and abort
 346 void wxFatalError(
 347   const wxString&                   rMsg
 348 , const wxString&                   rTitle
 349 )
 350 {
 351     unsigned long                   ulRc;
 352
 353     ulRc = ::WinMessageBox( HWND_DESKTOP
 354                            ,NULL
 355                            ,WXSTRINGCAST rMsg
 356                            ,WXSTRINGCAST rTitle
 357                            ,0
 358                            ,MB_NOICON | MB_OK
 359                           );
 360     DosExit(EXIT_PROCESS, ulRc);
 361 }
 362
 363 #endif // WXWIN_COMPATIBILITY_2_2
 364
 365 // Emit a beeeeeep
 366 void wxBell()
 367 {
 368     DosBeep(1000,1000); // 1kHz during 1 sec.
 369 }
 370
 371
 372 void wxAppTraits::InitializeGui(unsigned long &ulHab)
 373 {
 374 }
 375
 376 void wxAppTraits::TerminateGui(unsigned long ulHab)
 377 {
 378 }
 379
 380 wxToolkitInfo & wxConsoleAppTraits::GetToolkitInfo()
 381 {
 382     static wxToolkitInfo  vInfo;
 383     ULONG                 ulSysInfo[QSV_MAX] = {0};
 384     APIRET                ulrc;
 385
 386     vInfo.name = _T("wxBase");
 387     ulrc = ::DosQuerySysInfo( 1L
 388                              ,QSV_MAX
 389                              ,(PVOID)ulSysInfo
 390                              ,sizeof(ULONG) * QSV_MAX
 391                             );
 392     if (ulrc == 0L)
 393     {
 394         vInfo.versionMajor = ulSysInfo[QSV_VERSION_MAJOR] / 10;
 395         vInfo.versionMinor = ulSysInfo[QSV_VERSION_MINOR];
 396     }
 397     vInfo.os = wxOS2_PM;
 398     return vInfo;
 399 }
 400
 401 // ---------------------------------------------------------------------------
 402 const wxChar* wxGetHomeDir(
 403   wxString*                         pStr
 404 )
 405 {
 406     wxString&                       rStrDir = *pStr;
 407
 408     // OS/2 has no idea about home,
 409     // so use the working directory instead.
 410     // However, we might have a valid HOME directory,
 411     // as is used on many machines that have unix utilities
 412     // on them, so we should use that, if available.
 413
 414     // 256 was taken from os2def.h
 415 #ifndef MAX_PATH
 416 #  define MAX_PATH  256
 417 #endif
 418
 419     const wxChar *szHome = wxGetenv("HOME");
 420     if ( szHome == NULL ) {
 421       // we're homeless, use current directory.
 422       rStrDir = wxT(".");
 423     }
 424     else
 425        rStrDir = szHome;
 426
 427     return rStrDir.c_str();
 428 }
 429
 430 // Hack for OS/2
 431 wxChar* wxGetUserHome (
 432   const wxString&                   rUser
 433 )
 434 {
 435     wxChar*                         zHome;
 436     wxString                        sUser1(rUser);
 437
 438     char *wxBuffer = new wxChar[256];
 439 #ifndef __EMX__
 440     if (!sUser1.empty())
 441     {
 442         wxChar                      zTmp[64];
 443
 444         if (wxGetUserId( zTmp
 445                         ,sizeof(zTmp)/sizeof(char)
 446                        ))
 447         {
 448             // Guests belong in the temp dir
 449             if (wxStricmp(zTmp, _T("annonymous")) == 0)
 450             {
 451                 if ((zHome = wxGetenv(_T("TMP"))) != NULL    ||
 452                     (zHome = wxGetenv(_T("TMPDIR"))) != NULL ||
 453                     (zHome = wxGetenv(_T("TEMP"))) != NULL)
 454                     delete[] wxBuffer;
 455                     return *zHome ? zHome : (wxChar*)_T("\\");
 456             }
 457             if (wxStricmp(zTmp, WXSTRINGCAST sUser1) == 0)
 458                 sUser1 = _T("");
 459         }
 460     }
 461 #endif
 462     if (sUser1.empty())
 463     {
 464         if ((zHome = wxGetenv(_T("HOME"))) != NULL)
 465         {
 466             wxStrcpy(wxBuffer, zHome);
 467             wxUnix2DosFilename(wxBuffer);
 468             wxStrcpy(zHome, wxBuffer);
 469             delete[] wxBuffer;
 470             return zHome;
 471         }
 472     }
 473     delete[] wxBuffer;
 474     return NULL; // No home known!
 475 }
 476
 477 wxString WXDLLEXPORT wxPMErrorToStr(
 478   ERRORID                           vError
 479 )
 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 *proc_data)
 540 {
 541     // For now, just do nothing. To be filled in as needed.
 542 }