home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / utils.h < prev    next >
C/C++ Source or Header  |  2002-12-17  |  19KB  |  509 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        utils.h
  3. // Purpose:     Miscellaneous utilities
  4. // Author:      Julian Smart
  5. // Modified by:
  6. // Created:     29/01/98
  7. // RCS-ID:      $Id: utils.h,v 1.80.2.2 2002/12/16 22:05:34 RD Exp $
  8. // Copyright:   (c) 1998 Julian Smart
  9. // Licence:     wxWindows license
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifndef _WX_UTILSH__
  13. #define _WX_UTILSH__
  14.  
  15. // ----------------------------------------------------------------------------
  16. // headers
  17. // ----------------------------------------------------------------------------
  18.  
  19. #if defined(__GNUG__) && !defined(__APPLE__)
  20.     #pragma interface "utils.h"
  21. #endif
  22.  
  23. #include "wx/object.h"
  24. #include "wx/list.h"
  25. #include "wx/filefn.h"
  26.  
  27. // need this for wxGetDiskSpace() as we can't, unfortunately, forward declare
  28. // wxLongLong
  29. #include "wx/longlong.h"
  30.  
  31. #ifdef __X__
  32.     #include <dirent.h>
  33.     #include <unistd.h>
  34. #endif
  35.  
  36. #include <stdio.h>
  37.  
  38. // ----------------------------------------------------------------------------
  39. // Forward declaration
  40. // ----------------------------------------------------------------------------
  41.  
  42. class WXDLLEXPORT wxProcess;
  43. class WXDLLEXPORT wxFrame;
  44. class WXDLLEXPORT wxWindow;
  45. class WXDLLEXPORT wxWindowList;
  46. class WXDLLEXPORT wxPoint;
  47.  
  48. // ----------------------------------------------------------------------------
  49. // Macros
  50. // ----------------------------------------------------------------------------
  51.  
  52. #define wxMax(a,b)            (((a) > (b)) ? (a) : (b))
  53. #define wxMin(a,b)            (((a) < (b)) ? (a) : (b))
  54.  
  55. // ----------------------------------------------------------------------------
  56. // String functions (deprecated, use wxString)
  57. // ----------------------------------------------------------------------------
  58.  
  59. // Useful buffer (FIXME VZ: To be removed!!!)
  60. // Now only needed in Mac and MSW ports
  61. #if !defined(__WXMOTIF__) && !defined(__WXGTK__) && !defined(__WXX11__) && !defined(__WXMGL__)
  62. WXDLLEXPORT_DATA(extern wxChar*) wxBuffer;
  63. #endif
  64.  
  65. // Make a copy of this string using 'new'
  66. WXDLLEXPORT wxChar* copystring(const wxChar *s);
  67.  
  68. #if WXWIN_COMPATIBILITY_2
  69. // Matches string one within string two regardless of case
  70. WXDLLEXPORT bool StringMatch(const wxChar *one, const wxChar *two, bool subString = TRUE, bool exact = FALSE);
  71. #endif
  72.  
  73. // A shorter way of using strcmp
  74. #define wxStringEq(s1, s2) (s1 && s2 && (wxStrcmp(s1, s2) == 0))
  75.  
  76. // ----------------------------------------------------------------------------
  77. // Miscellaneous functions
  78. // ----------------------------------------------------------------------------
  79.  
  80. // Sound the bell
  81. WXDLLEXPORT void wxBell();
  82.  
  83. // Get OS description as a user-readable string
  84. WXDLLEXPORT wxString wxGetOsDescription();
  85.  
  86. // Get OS version
  87. WXDLLEXPORT int wxGetOsVersion(int *majorVsn = (int *) NULL,
  88.                                int *minorVsn = (int *) NULL);
  89.  
  90. // Return a string with the current date/time
  91. WXDLLEXPORT wxString wxNow();
  92.  
  93. // Return path where wxWindows is installed (mostly useful in Unices)
  94. WXDLLEXPORT const wxChar *wxGetInstallPrefix();
  95. // Return path to wxWin data (/usr/share/wx/%{version}) (Unices)
  96. WXDLLEXPORT wxString wxGetDataDir();
  97.  
  98.  
  99. #if wxUSE_GUI
  100. // Don't synthesize KeyUp events holding down a key and producing
  101. // KeyDown events with autorepeat. On by default and always on
  102. // in wxMSW.
  103. WXDLLEXPORT bool wxSetDetectableAutoRepeat( bool flag );
  104.  
  105. // ----------------------------------------------------------------------------
  106. // Window ID management
  107. // ----------------------------------------------------------------------------
  108.  
  109. // Generate a unique ID
  110. WXDLLEXPORT long wxNewId();
  111. #if !defined(NewId) && defined(WXWIN_COMPATIBILITY)
  112.     #define NewId wxNewId
  113. #endif
  114.  
  115. // Ensure subsequent IDs don't clash with this one
  116. WXDLLEXPORT void wxRegisterId(long id);
  117. #if !defined(RegisterId) && defined(WXWIN_COMPATIBILITY)
  118.     #define RegisterId wxRegisterId
  119. #endif
  120.  
  121. // Return the current ID
  122. WXDLLEXPORT long wxGetCurrentId();
  123.  
  124. #endif // wxUSE_GUI
  125.  
  126. // ----------------------------------------------------------------------------
  127. // Various conversions
  128. // ----------------------------------------------------------------------------
  129.  
  130. WXDLLEXPORT_DATA(extern const wxChar*) wxFloatToStringStr;
  131. WXDLLEXPORT_DATA(extern const wxChar*) wxDoubleToStringStr;
  132.  
  133. WXDLLEXPORT void StringToFloat(const wxChar *s, float *number);
  134. WXDLLEXPORT wxChar* FloatToString(float number, const wxChar *fmt = wxFloatToStringStr);
  135. WXDLLEXPORT void StringToDouble(const wxChar *s, double *number);
  136. WXDLLEXPORT wxChar* DoubleToString(double number, const wxChar *fmt = wxDoubleToStringStr);
  137. WXDLLEXPORT void StringToInt(const wxChar *s, int *number);
  138. WXDLLEXPORT void StringToLong(const wxChar *s, long *number);
  139. WXDLLEXPORT wxChar* IntToString(int number);
  140. WXDLLEXPORT wxChar* LongToString(long number);
  141.  
  142. // Convert 2-digit hex number to decimal
  143. WXDLLEXPORT int wxHexToDec(const wxString& buf);
  144.  
  145. // Convert decimal integer to 2-character hex string
  146. WXDLLEXPORT void wxDecToHex(int dec, wxChar *buf);
  147. WXDLLEXPORT wxString wxDecToHex(int dec);
  148.  
  149. // ----------------------------------------------------------------------------
  150. // Process management
  151. // ----------------------------------------------------------------------------
  152.  
  153. // NB: for backwars compatibility reasons the values of wxEXEC_[A]SYNC *must*
  154. //     be 0 and 1, don't change!
  155.  
  156. enum
  157. {
  158.     // execute the process asynchronously
  159.     wxEXEC_ASYNC    = 0,
  160.  
  161.     // execute it synchronously, i.e. wait until it finishes
  162.     wxEXEC_SYNC     = 1,
  163.  
  164.     // under Windows, don't hide the child even if it's IO is redirected (this
  165.     // is done by default)
  166.     wxEXEC_NOHIDE   = 2,
  167.  
  168.     // under Unix, if the process is the group leader then killing -pid kills
  169.     // all children as well as pid
  170.     wxEXEC_MAKE_GROUP_LEADER = 4
  171. };
  172.  
  173. // Execute another program.
  174. //
  175. // If flags contain wxEXEC_SYNC, return -1 on failure and the exit code of the
  176. // process if everything was ok. Otherwise (i.e. if wxEXEC_ASYNC), return 0 on
  177. // failure and the PID of the launched process if ok.
  178. WXDLLEXPORT long wxExecute(wxChar **argv, int flags = wxEXEC_ASYNC,
  179.                            wxProcess *process = (wxProcess *) NULL);
  180. WXDLLEXPORT long wxExecute(const wxString& command, int flags = wxEXEC_ASYNC,
  181.                            wxProcess *process = (wxProcess *) NULL);
  182.  
  183. // execute the command capturing its output into an array line by line, this is
  184. // always synchronous
  185. WXDLLEXPORT long wxExecute(const wxString& command,
  186.                            wxArrayString& output);
  187.  
  188. // also capture stderr (also synchronous)
  189. WXDLLEXPORT long wxExecute(const wxString& command,
  190.                            wxArrayString& output,
  191.                            wxArrayString& error);
  192.  
  193. enum wxSignal
  194. {
  195.     wxSIGNONE = 0,  // verify if the process exists under Unix
  196.     wxSIGHUP,
  197.     wxSIGINT,
  198.     wxSIGQUIT,
  199.     wxSIGILL,
  200.     wxSIGTRAP,
  201.     wxSIGABRT,
  202.     wxSIGIOT = wxSIGABRT,   // another name
  203.     wxSIGEMT,
  204.     wxSIGFPE,
  205.     wxSIGKILL,
  206.     wxSIGBUS,
  207.     wxSIGSEGV,
  208.     wxSIGSYS,
  209.     wxSIGPIPE,
  210.     wxSIGALRM,
  211.     wxSIGTERM
  212.  
  213.     // further signals are different in meaning between different Unix systems
  214. };
  215.  
  216. enum wxKillError
  217. {
  218.     wxKILL_OK,              // no error
  219.     wxKILL_BAD_SIGNAL,      // no such signal
  220.     wxKILL_ACCESS_DENIED,   // permission denied
  221.     wxKILL_NO_PROCESS,      // no such process
  222.     wxKILL_ERROR            // another, unspecified error
  223. };
  224.  
  225. enum wxShutdownFlags
  226. {
  227.     wxSHUTDOWN_POWEROFF,    // power off the computer
  228.     wxSHUTDOWN_REBOOT       // shutdown and reboot
  229. };
  230.  
  231. // Shutdown or reboot the PC
  232. WXDLLEXPORT bool wxShutdown(wxShutdownFlags wFlags);
  233.  
  234. // send the given signal to the process (only NONE and KILL are supported under
  235. // Windows, all others mean TERM), return 0 if ok and -1 on error
  236. //
  237. // return detailed error in rc if not NULL
  238. WXDLLEXPORT int wxKill(long pid,
  239.                        wxSignal sig = wxSIGTERM,
  240.                        wxKillError *rc = NULL);
  241.  
  242. // Execute a command in an interactive shell window (always synchronously)
  243. // If no command then just the shell
  244. WXDLLEXPORT bool wxShell(const wxString& command = wxEmptyString);
  245.  
  246. // As wxShell(), but must give a (non interactive) command and its output will
  247. // be returned in output array
  248. WXDLLEXPORT bool wxShell(const wxString& command, wxArrayString& output);
  249.  
  250. // Sleep for nSecs seconds
  251. WXDLLEXPORT void wxSleep(int nSecs);
  252.  
  253. // Sleep for a given amount of milliseconds
  254. WXDLLEXPORT void wxUsleep(unsigned long milliseconds);
  255.  
  256. // Get the process id of the current process
  257. WXDLLEXPORT unsigned long wxGetProcessId();
  258.  
  259. // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
  260. WXDLLEXPORT long wxGetFreeMemory();
  261.  
  262. // should wxApp::OnFatalException() be called?
  263. WXDLLEXPORT bool wxHandleFatalExceptions(bool doit = TRUE);
  264.  
  265. // ----------------------------------------------------------------------------
  266. // Environment variables
  267. // ----------------------------------------------------------------------------
  268.  
  269. // returns TRUE if variable exists (value may be NULL if you just want to check
  270. // for this)
  271. WXDLLEXPORT bool wxGetEnv(const wxString& var, wxString *value);
  272.  
  273. // set the env var name to the given value, return TRUE on success
  274. WXDLLEXPORT bool wxSetEnv(const wxString& var, const wxChar *value);
  275.  
  276. // remove the env var from environment
  277. inline bool wxUnsetEnv(const wxString& var) { return wxSetEnv(var, NULL); }
  278.  
  279. // ----------------------------------------------------------------------------
  280. // Network and username functions.
  281. // ----------------------------------------------------------------------------
  282.  
  283. // NB: "char *" functions are deprecated, use wxString ones!
  284.  
  285. // Get eMail address
  286. WXDLLEXPORT bool wxGetEmailAddress(wxChar *buf, int maxSize);
  287. WXDLLEXPORT wxString wxGetEmailAddress();
  288.  
  289. // Get hostname.
  290. WXDLLEXPORT bool wxGetHostName(wxChar *buf, int maxSize);
  291. WXDLLEXPORT wxString wxGetHostName();
  292.  
  293. // Get FQDN
  294. WXDLLEXPORT wxString wxGetFullHostName();
  295. WXDLLEXPORT bool wxGetFullHostName(wxChar *buf, int maxSize);
  296.  
  297. // Get user ID e.g. jacs (this is known as login name under Unix)
  298. WXDLLEXPORT bool wxGetUserId(wxChar *buf, int maxSize);
  299. WXDLLEXPORT wxString wxGetUserId();
  300.  
  301. // Get user name e.g. Julian Smart
  302. WXDLLEXPORT bool wxGetUserName(wxChar *buf, int maxSize);
  303. WXDLLEXPORT wxString wxGetUserName();
  304.  
  305. // Get current Home dir and copy to dest (returns pstr->c_str())
  306. WXDLLEXPORT wxString wxGetHomeDir();
  307. WXDLLEXPORT const wxChar* wxGetHomeDir(wxString *pstr);
  308.  
  309. // Get the user's home dir (caller must copy --- volatile)
  310. // returns NULL is no HOME dir is known
  311. #if defined(__UNIX__) && wxUSE_UNICODE
  312. WXDLLEXPORT const wxMB2WXbuf wxGetUserHome(const wxString& user = wxEmptyString);
  313. #else
  314. WXDLLEXPORT wxChar* wxGetUserHome(const wxString& user = wxEmptyString);
  315. #endif
  316.  
  317. // get number of total/free bytes on the disk where path belongs
  318. WXDLLEXPORT bool wxGetDiskSpace(const wxString& path,
  319.                                 wxLongLong *pTotal = NULL,
  320.                                 wxLongLong *pFree = NULL);
  321.  
  322. #if wxUSE_GUI // GUI only things from now on
  323.  
  324. // ----------------------------------------------------------------------------
  325. // Menu accelerators related things
  326. // ----------------------------------------------------------------------------
  327.  
  328. WXDLLEXPORT wxChar* wxStripMenuCodes(const wxChar *in, wxChar *out = (wxChar *) NULL);
  329. WXDLLEXPORT wxString wxStripMenuCodes(const wxString& str);
  330.  
  331. #if wxUSE_ACCEL
  332. class WXDLLEXPORT wxAcceleratorEntry;
  333. WXDLLEXPORT wxAcceleratorEntry *wxGetAccelFromString(const wxString& label);
  334. #endif // wxUSE_ACCEL
  335.  
  336. // ----------------------------------------------------------------------------
  337. // Window search
  338. // ----------------------------------------------------------------------------
  339.  
  340. // Returns menu item id or -1 if none.
  341. WXDLLEXPORT int wxFindMenuItemId(wxFrame *frame, const wxString& menuString, const wxString& itemString);
  342.  
  343. // Find the wxWindow at the given point. wxGenericFindWindowAtPoint
  344. // is always present but may be less reliable than a native version.
  345. WXDLLEXPORT wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);
  346. WXDLLEXPORT wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
  347.  
  348. // NB: this function is obsolete, use wxWindow::FindWindowByLabel() instead
  349. //
  350. // Find the window/widget with the given title or label.
  351. // Pass a parent to begin the search from, or NULL to look through
  352. // all windows.
  353. WXDLLEXPORT wxWindow* wxFindWindowByLabel(const wxString& title, wxWindow *parent = (wxWindow *) NULL);
  354.  
  355. // NB: this function is obsolete, use wxWindow::FindWindowByName() instead
  356. //
  357. // Find window by name, and if that fails, by label.
  358. WXDLLEXPORT wxWindow* wxFindWindowByName(const wxString& name, wxWindow *parent = (wxWindow *) NULL);
  359.  
  360. // ----------------------------------------------------------------------------
  361. // Message/event queue helpers
  362. // ----------------------------------------------------------------------------
  363.  
  364. // NB: these functions are obsolete, please use wxApp methods instead!
  365.  
  366. // Yield to other apps/messages
  367. WXDLLEXPORT bool wxYield();
  368.  
  369. // Like wxYield, but fails silently if the yield is recursive.
  370. WXDLLEXPORT bool wxYieldIfNeeded();
  371.  
  372. // Yield to other apps/messages and disable user input
  373. WXDLLEXPORT bool wxSafeYield(wxWindow *win = NULL, bool onlyIfNeeded = FALSE);
  374.  
  375. // Enable or disable input to all top level windows
  376. WXDLLEXPORT void wxEnableTopLevelWindows(bool enable = TRUE);
  377.  
  378. // Check whether this window wants to process messages, e.g. Stop button
  379. // in long calculations.
  380. WXDLLEXPORT bool wxCheckForInterrupt(wxWindow *wnd);
  381.  
  382. // Consume all events until no more left
  383. WXDLLEXPORT void wxFlushEvents();
  384.  
  385. // a class which disables all windows (except, may be, thegiven one) in its
  386. // ctor and enables them back in its dtor
  387. class WXDLLEXPORT wxWindowDisabler
  388. {
  389. public:
  390.     wxWindowDisabler(wxWindow *winToSkip = (wxWindow *)NULL);
  391.     ~wxWindowDisabler();
  392.  
  393. private:
  394.     wxWindowList *m_winDisabled;
  395.  
  396.     DECLARE_NO_COPY_CLASS(wxWindowDisabler)
  397. };
  398.  
  399. // ----------------------------------------------------------------------------
  400. // Cursors
  401. // ----------------------------------------------------------------------------
  402.  
  403. // Set the cursor to the busy cursor for all windows
  404. class WXDLLEXPORT wxCursor;
  405. WXDLLEXPORT_DATA(extern wxCursor*) wxHOURGLASS_CURSOR;
  406. WXDLLEXPORT void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
  407.  
  408. // Restore cursor to normal
  409. WXDLLEXPORT void wxEndBusyCursor();
  410.  
  411. // TRUE if we're between the above two calls
  412. WXDLLEXPORT bool wxIsBusy();
  413.  
  414. // Convenience class so we can just create a wxBusyCursor object on the stack
  415. class WXDLLEXPORT wxBusyCursor
  416. {
  417. public:
  418.     wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR)
  419.         { wxBeginBusyCursor(cursor); }
  420.     ~wxBusyCursor()
  421.         { wxEndBusyCursor(); }
  422.  
  423.     // FIXME: These two methods are currently only implemented (and needed?)
  424.     //        in wxGTK.  BusyCursor handling should probably be moved to
  425.     //        common code since the wxGTK and wxMSW implementations are very
  426.     //        similar except for wxMSW using HCURSOR directly instead of
  427.     //        wxCursor..  -- RL.
  428.     static const wxCursor &GetStoredCursor();
  429.     static const wxCursor GetBusyCursor();
  430. };
  431.  
  432.  
  433. // ----------------------------------------------------------------------------
  434. // Reading and writing resources (eg WIN.INI, .Xdefaults)
  435. // ----------------------------------------------------------------------------
  436.  
  437. #if wxUSE_RESOURCES
  438. WXDLLEXPORT bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file = wxEmptyString);
  439. WXDLLEXPORT bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file = wxEmptyString);
  440. WXDLLEXPORT bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file = wxEmptyString);
  441. WXDLLEXPORT bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file = wxEmptyString);
  442.  
  443. WXDLLEXPORT bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file = wxEmptyString);
  444. WXDLLEXPORT bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file = wxEmptyString);
  445. WXDLLEXPORT bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file = wxEmptyString);
  446. WXDLLEXPORT bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file = wxEmptyString);
  447. #endif // wxUSE_RESOURCES
  448.  
  449. void WXDLLEXPORT wxGetMousePosition( int* x, int* y );
  450.  
  451. // MSW only: get user-defined resource from the .res file.
  452. // Returns NULL or newly-allocated memory, so use delete[] to clean up.
  453. #ifdef __WXMSW__
  454.     WXDLLEXPORT extern const wxChar* wxUserResourceStr;
  455.     WXDLLEXPORT wxChar* wxLoadUserResource(const wxString& resourceName, const wxString& resourceType = wxUserResourceStr);
  456. #endif // MSW
  457.  
  458. // ----------------------------------------------------------------------------
  459. // Display and colorss (X only)
  460. // ----------------------------------------------------------------------------
  461.  
  462. #ifdef __WXGTK__
  463.     void *wxGetDisplay();
  464. #endif
  465.  
  466. #ifdef __X__
  467.     WXDisplay *wxGetDisplay();
  468.     bool wxSetDisplay(const wxString& display_name);
  469.     wxString wxGetDisplayName();
  470. #endif // X or GTK+
  471.  
  472. #ifdef __X__
  473.  
  474. #ifdef __VMS__ // Xlib.h for VMS is not (yet) compatible with C++
  475.                // The resulting warnings are switched off here
  476. #pragma message disable nosimpint
  477. #endif
  478. // #include <X11/Xlib.h>
  479. #ifdef __VMS__
  480. #pragma message enable nosimpint
  481. #endif
  482.  
  483. #endif //__X__
  484.  
  485. #endif // wxUSE_GUI
  486.  
  487. // ----------------------------------------------------------------------------
  488. // Error message functions used by wxWindows (deprecated, use wxLog)
  489. // ----------------------------------------------------------------------------
  490.  
  491. #if WXWIN_COMPATIBILITY_2_2
  492.  
  493. // Format a message on the standard error (UNIX) or the debugging
  494. // stream (Windows)
  495. WXDLLEXPORT void wxDebugMsg(const wxChar *fmt ...) ATTRIBUTE_PRINTF_1;
  496.  
  497. // Non-fatal error (continues)
  498. WXDLLEXPORT_DATA(extern const wxChar*) wxInternalErrorStr;
  499. WXDLLEXPORT void wxError(const wxString& msg, const wxString& title = wxInternalErrorStr);
  500.  
  501. // Fatal error (exits)
  502. WXDLLEXPORT_DATA(extern const wxChar*) wxFatalErrorStr;
  503. WXDLLEXPORT void wxFatalError(const wxString& msg, const wxString& title = wxFatalErrorStr);
  504.  
  505. #endif // WXWIN_COMPATIBILITY_2_2
  506.  
  507. #endif
  508.     // _WX_UTILSH__
  509.