src/os2/utils.cpp

   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/intl.h"
  19     #include "wx/log.h"
  20 #endif  //WX_PRECOMP
  21
  22 #include "wx/os2/private.h"
  23 #include "wx/apptrait.h"
  24 #include "wx/filename.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[] = wxT("wxWidgets");
  54 static const wxChar eHOSTNAME[]  = wxT("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 = wxT("noname");
  85
  86     if ((zSysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL &&
  87             (zSysname = wxGetenv(wxT("HOSTNAME"))) == 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         zBuf[nMaxSize] = wxT('\0');
  97     }
  98     else
  99     {
 100         wxStrlcpy(zBuf, zSysname, nMaxSize);
 101     }
 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     wxStrlcpy(zBuf, wxT("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 = wxT("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 = wxT("/C ") + rCommand;
 159     SData.PgmInputs     = (BYTE*)sInputs.wx_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 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
 201 wxMemorySize wxGetFreeMemory()
 202 {
 203     void* pMemptr = NULL;
 204     LONG  lSize;
 205     ULONG lMemFlags;
 206     APIRET rc;
 207
 208     lMemFlags = PAG_FREE;
 209     rc = ::DosQueryMem(pMemptr, (PULONG)&lSize, &lMemFlags);
 210     if (rc != 0)
 211         lSize = -1L;
 212     return (wxMemorySize)lSize;
 213 }
 214
 215 // Get Process ID
 216 unsigned long wxGetProcessId()
 217 {
 218     return (unsigned long)getpid();
 219 }
 220
 221 // ----------------------------------------------------------------------------
 222 // env vars
 223 // ----------------------------------------------------------------------------
 224
 225 bool wxGetEnv(const wxString& var, wxString *value)
 226 {
 227     // wxGetenv is defined as getenv()
 228     wxChar *p = wxGetenv((const wxChar *)var);
 229     if ( !p )
 230         return false;
 231
 232     if ( value )
 233     {
 234         *value = p;
 235     }
 236
 237     return true;
 238 }
 239
 240 static bool wxDoSetEnv(const wxString& variable, const char *value)
 241 {
 242 #if defined(HAVE_SETENV)
 243     if ( !value )
 244     {
 245 #ifdef HAVE_UNSETENV
 246         return unsetenv(variable.mb_str()) == 0;
 247 #else
 248         value = wxT(""); // mustn't pass NULL to setenv()
 249 #endif
 250     }
 251     return setenv(variable.mb_str(), value, 1 /* overwrite */) == 0;
 252 #elif defined(HAVE_PUTENV)
 253     wxString s = variable;
 254     if ( value )
 255         s << wxT('=') << value;
 256
 257     // transform to ANSI
 258     const char *p = s.mb_str();
 259
 260     // the string will be free()d by libc
 261     char *buf = (char *)malloc(strlen(p) + 1);
 262     strcpy(buf, p);
 263
 264     return putenv(buf) == 0;
 265 #else // no way to set an env var
 266     wxUnusedVar(variable);
 267     wxUnusedVar(value);
 268     return false;
 269 #endif
 270 }
 271
 272 bool wxSetEnv(const wxString& variable, const wxString& value)
 273 {
 274     return wxDoSetEnv(variable, value.mb_str());
 275 }
 276
 277 bool wxUnsetEnv(const wxString& variable)
 278 {
 279     return wxDoSetEnv(variable, NULL);
 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 // Emit a beeeeeep
 310 void wxBell()
 311 {
 312     DosBeep(1000,1000); // 1kHz during 1 sec.
 313 }
 314
 315 wxString wxGetOsDescription()
 316 {
 317     wxString strVer(wxT("OS/2"));
 318     ULONG ulSysInfo = 0;
 319
 320     if (::DosQuerySysInfo( QSV_VERSION_MINOR,
 321                            QSV_VERSION_MINOR,
 322                            (PVOID)&ulSysInfo,
 323                            sizeof(ULONG)
 324                          ) == 0L )
 325     {
 326         wxString ver;
 327         ver.Printf( wxT(" ver. %d.%d"),
 328                     int(ulSysInfo / 10),
 329                     int(ulSysInfo % 10)
 330                   );
 331         strVer += ver;
 332     }
 333
 334     return strVer;
 335 }
 336
 337 bool wxIsPlatform64Bit()
 338 {
 339     // FIXME: No idea how to test for 64 bit processor
 340     //        (Probably irrelevant anyhow, though).
 341     return false;
 342 }
 343
 344 void wxAppTraits::InitializeGui(unsigned long &WXUNUSED(ulHab))
 345 {
 346 }
 347
 348 void wxAppTraits::TerminateGui(unsigned long WXUNUSED(ulHab))
 349 {
 350 }
 351
 352 wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
 353 {
 354     ULONG                 ulSysInfo = 0;
 355     APIRET                ulrc;
 356
 357     ulrc = ::DosQuerySysInfo( QSV_VERSION_MINOR,
 358                               QSV_VERSION_MINOR,
 359                               (PVOID)&ulSysInfo,
 360                               sizeof(ULONG)
 361                             );
 362
 363     if (ulrc == 0L)
 364     {
 365         if ( verMaj )
 366             *verMaj = ulSysInfo / 10;
 367         if ( verMin )
 368             *verMin = ulSysInfo % 10;
 369     }
 370
 371     return wxOS_OS2;
 372 }
 373
 374
 375 // ---------------------------------------------------------------------------
 376 const wxChar* wxGetHomeDir(
 377   wxString*                         pStr
 378 )
 379 {
 380     wxString&                       rStrDir = *pStr;
 381
 382     // OS/2 has no idea about home,
 383     // so use the working directory instead.
 384     // However, we might have a valid HOME directory,
 385     // as is used on many machines that have unix utilities
 386     // on them, so we should use that, if available.
 387
 388     // 256 was taken from os2def.h
 389 #ifndef MAX_PATH
 390 #  define MAX_PATH  256
 391 #endif
 392
 393     const wxChar *szHome = wxGetenv((wxChar*)"HOME");
 394     if ( szHome == NULL ) {
 395       // we're homeless, use current directory.
 396       rStrDir = wxT(".");
 397     }
 398     else
 399        rStrDir = szHome;
 400
 401     return rStrDir.c_str();
 402 }
 403
 404 wxString wxGetUserHome ( const wxString &rUser )
 405 {
 406     wxChar*    zHome;
 407     wxString   sUser(rUser);
 408
 409     wxString home;
 410
 411 #ifndef __EMX__
 412     if (!sUser.empty())
 413     {
 414         const wxString currentUser = wxGetUserId();
 415
 416         // Guests belong in the temp dir
 417         if ( currentUser == "annonymous" )
 418         {
 419             zHome = wxGetenv(wxT("TMP"));
 420             if ( !zHome )
 421                 zHome = wxGetenv(wxT("TMPDIR"));
 422             if ( !zHome )
 423                 zHome = wxGetenv(wxT("TEMP"));
 424
 425             if ( zHome && *zHome )
 426                 return zHome;
 427         }
 428
 429         if ( sUser == currentUser )
 430             sUser.clear();
 431     }
 432 #endif
 433     if (sUser.empty())
 434     {
 435         if ((zHome = wxGetenv(wxT("HOME"))) != NULL)
 436         {
 437             home = zHome;
 438             home.Replace("/", "\\");
 439         }
 440     }
 441
 442     return home;
 443 }
 444
 445 bool wxGetDiskSpace(const wxString& path,
 446                     wxDiskspaceSize_t *pTotal,
 447                     wxDiskspaceSize_t *pFree)
 448 {
 449     if (path.empty())
 450         return false;
 451
 452     wxFileName fn(path);
 453     FSALLOCATE fsaBuf = {0};
 454     APIRET rc = NO_ERROR;
 455     ULONG disknum = 0;
 456
 457     fn.MakeAbsolute();
 458
 459     if (wxDirExists(fn.GetFullPath()) == false)
 460         return false;
 461
 462     disknum = wxToupper(fn.GetVolume().GetChar(0)) - wxT('A') + 1;
 463
 464     rc = ::DosQueryFSInfo(disknum,             // 1 = A, 2 = B, 3 = C, ...
 465                           FSIL_ALLOC,          // allocation info
 466                           (PVOID)&fsaBuf,
 467                           sizeof(FSALLOCATE));
 468
 469     if (rc != NO_ERROR)
 470         return false;
 471     else
 472     {
 473         if(pTotal)
 474         {
 475            // to try to avoid 32-bit overflow, let's not multiply right away
 476             // (num of alloc units)
 477             *pTotal = fsaBuf.cUnit;
 478             // * (num of sectors per alloc unit) * (num of bytes per sector)
 479             (*pTotal) *= fsaBuf.cSectorUnit * fsaBuf.cbSector;
 480         }
 481         if(pFree)
 482         {
 483             *pFree = fsaBuf.cUnitAvail;
 484             (*pFree) *= fsaBuf.cSectorUnit * fsaBuf.cbSector;
 485         }
 486         return true;
 487     }
 488 }
 489
 490 wxString wxPMErrorToStr(ERRORID vError)
 491 {
 492     wxString sError;
 493
 494     //
 495     // Remove the high order byte -- it is useless
 496     //
 497     vError &= 0x0000ffff;
 498     switch(vError)
 499     {
 500         case PMERR_INVALID_HWND:
 501             sError = wxT("Invalid window handle specified");
 502             break;
 503
 504         case PMERR_INVALID_FLAG:
 505             sError = wxT("Invalid flag bit set");
 506             break;
 507
 508         case PMERR_NO_MSG_QUEUE:
 509             sError = wxT("No message queue available");
 510             break;
 511
 512         case PMERR_INVALID_PARM:
 513             sError = wxT("Parameter contained invalid data");
 514             break;
 515
 516         case PMERR_INVALID_PARAMETERS:
 517             sError = wxT("Parameter value is out of range");
 518             break;
 519
 520         case PMERR_PARAMETER_OUT_OF_RANGE:
 521             sError = wxT("Parameter value is out of range");
 522             break;
 523
 524         case PMERR_INVALID_INTEGER_ATOM:
 525             sError = wxT("Not a valid atom");
 526             break;
 527
 528         case PMERR_INVALID_HATOMTBL:
 529             sError = wxT("Atom table handle is invalid");
 530             break;
 531
 532         case PMERR_INVALID_ATOM_NAME:
 533             sError = wxT("Not a valid atom name");
 534             break;
 535
 536         case PMERR_ATOM_NAME_NOT_FOUND:
 537             sError = wxT("Valid name format, but cannot find name in atom table");
 538             break;
 539
 540         case PMERR_INV_HPS:
 541             sError = wxT("PMERR_INV_HPS");
 542             break;
 543
 544         case PMERR_PS_BUSY:
 545             sError = wxT("PMERR_PS_BUSY");
 546             break;
 547
 548         case PMERR_INV_PRIMITIVE_TYPE:
 549             sError = wxT("PMERR_INV_PRIMITIVE_TYPE");
 550             break;
 551
 552         case PMERR_UNSUPPORTED_ATTR:
 553             sError = wxT("PMERR_UNSUPPORTED_ATTR");
 554             break;
 555
 556         case PMERR_INV_COLOR_ATTR:
 557             sError = wxT("PMERR_INV_COLOR_ATTR");
 558             break;
 559
 560         case PMERR_INV_BACKGROUND_COL_ATTR:
 561             sError = wxT("PMERR_INV_BACKGROUND_COL_ATTR");
 562             break;
 563
 564         case PMERR_INV_MIX_ATTR:
 565             sError = wxT("PMERR_INV_MIX_ATTR");
 566             break;
 567
 568         case PMERR_INV_LINE_WIDTH_ATTR:
 569             sError = wxT("PMERR_INV_LINE_WIDTH_ATTR");
 570             break;
 571
 572         case PMERR_INV_GEOM_LINE_WIDTH_ATTR:
 573             sError = wxT("PMERR_INV_GEOM_LINE_WIDTH_ATTR");
 574             break;
 575
 576         case PMERR_INV_LINE_TYPE_ATTR:
 577             sError = wxT("PMERR_INV_LINE_TYPE_ATTR");
 578             break;
 579
 580         case PMERR_INV_LINE_END_ATTR:
 581             sError = wxT("PMERR_INV_LINE_END_ATTR");
 582             break;
 583
 584         case PMERR_INV_LINE_JOIN_ATTR:
 585             sError = wxT("PMERR_INV_LINE_JOIN_ATTR");
 586             break;
 587
 588         case PMERR_INV_CHAR_SET_ATTR:
 589             sError = wxT("PMERR_INV_CHAR_SET_ATTR");
 590             break;
 591
 592         case PMERR_INV_CHAR_MODE_ATTR:
 593             sError = wxT("PMERR_INV_CHAR_MODE_ATTR");
 594             break;
 595
 596         case PMERR_INV_CHAR_DIRECTION_ATTR:
 597             sError = wxT("PMERR_INV_CHAR_DIRECTION_ATTR");
 598             break;
 599
 600         case PMERR_INV_CHAR_SHEAR_ATTR:
 601             sError = wxT("PMERR_INV_CHAR_SHEAR_ATTR");
 602             break;
 603
 604         case PMERR_INV_CHAR_ANGLE_ATTR:
 605             sError = wxT("PMERR_INV_CHAR_ANGLE_ATTR");
 606             break;
 607
 608         case PMERR_INV_MARKER_SET_ATTR:
 609             sError = wxT("PMERR_INV_MARKER_SET_ATTR");
 610             break;
 611
 612         case PMERR_INV_MARKER_SYMBOL_ATTR:
 613             sError = wxT("PMERR_INV_MARKER_SYMBOL_ATTR");
 614             break;
 615
 616         case PMERR_INV_PATTERN_SET_ATTR:
 617             sError = wxT("PMERR_INV_PATTERN_SET_ATTR");
 618             break;
 619
 620         case PMERR_INV_PATTERN_ATTR:
 621             sError = wxT("PMERR_INV_PATTERN_ATTR");
 622             break;
 623
 624         case PMERR_INV_COORDINATE:
 625             sError = wxT("PMERR_INV_COORDINATE");
 626             break;
 627
 628         case PMERR_UNSUPPORTED_ATTR_VALUE:
 629             sError = wxT("PMERR_UNSUPPORTED_ATTR_VALUE");
 630             break;
 631
 632         case PMERR_INV_PATTERN_SET_FONT:
 633             sError = wxT("PMERR_INV_PATTERN_SET_FONT");
 634             break;
 635
 636         case PMERR_HUGE_FONTS_NOT_SUPPORTED:
 637             sError = wxT("PMERR_HUGE_FONTS_NOT_SUPPORTED");
 638             break;
 639
 640         default:
 641             sError = wxT("Unknown error");
 642     }
 643     return sError;
 644 } // end of wxPMErrorToStr
 645
 646 // replacement for implementation in unix/utilsunx.cpp,
 647 // to be used by all X11 based ports.
 648 struct wxEndProcessData;
 649
 650 void wxHandleProcessTermination(wxEndProcessData *WXUNUSED(proc_data))
 651 {
 652     // For now, just do nothing. To be filled in as needed.
 653 }