]> git.saurik.com Git - wxWidgets.git/blob - src/os2/utils.cpp
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / 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 }