1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Miscellaneous utilities
4 // Author: Julian Smart
8 // Copyright: (c) 1998 Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
15 // ----------------------------------------------------------------------------
17 // ----------------------------------------------------------------------------
19 #include "wx/object.h"
21 #include "wx/filefn.h"
23 class WXDLLIMPEXP_BASE wxArrayString
;
25 // need this for wxGetDiskSpace() as we can't, unfortunately, forward declare
27 #include "wx/longlong.h"
36 // ----------------------------------------------------------------------------
37 // Forward declaration
38 // ----------------------------------------------------------------------------
40 class WXDLLIMPEXP_CORE wxProcess
;
41 class WXDLLIMPEXP_CORE wxFrame
;
42 class WXDLLIMPEXP_CORE wxWindow
;
43 class WXDLLIMPEXP_CORE wxWindowList
;
44 class WXDLLIMPEXP_CORE wxPoint
;
46 // ----------------------------------------------------------------------------
48 // ----------------------------------------------------------------------------
50 #define wxMax(a,b) (((a) > (b)) ? (a) : (b))
51 #define wxMin(a,b) (((a) < (b)) ? (a) : (b))
53 // wxGetFreeMemory can return huge amount of memory on 64-bit platforms
54 // define wxMemorySize according to the type which best fits your platform
55 #if wxUSE_LONGLONG && defined(__WIN64__)
56 // 64 bit Windowses have sizeof(long) only 32 bit long
57 // we need to use wxLongLong to express memory sizes
58 #define wxMemorySize wxLongLong
60 // 64 bit UNIX has sizeof(long) = 64
61 // assume 32 bit platforms cannnot return more than 32bits of
62 #define wxMemorySize long
65 // ----------------------------------------------------------------------------
66 // String functions (deprecated, use wxString)
67 // ----------------------------------------------------------------------------
69 // Make a copy of this string using 'new'
70 #if WXWIN_COMPATIBILITY_2_4
71 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* copystring(const wxChar
*s
) );
74 // A shorter way of using strcmp
75 #define wxStringEq(s1, s2) (s1 && s2 && (wxStrcmp(s1, s2) == 0))
77 // ----------------------------------------------------------------------------
78 // Miscellaneous functions
79 // ----------------------------------------------------------------------------
82 #if !defined __EMX__ && \
83 (defined __WXMOTIF__ || defined __WXGTK__ || defined __WXX11__)
84 WXDLLIMPEXP_CORE
void wxBell();
86 WXDLLIMPEXP_BASE
void wxBell();
89 // Get OS description as a user-readable string
90 WXDLLIMPEXP_BASE wxString
wxGetOsDescription();
93 WXDLLIMPEXP_BASE
int wxGetOsVersion(int *majorVsn
= (int *) NULL
,
94 int *minorVsn
= (int *) NULL
);
96 // Return a string with the current date/time
97 WXDLLIMPEXP_BASE wxString
wxNow();
99 // Return path where wxWidgets is installed (mostly useful in Unices)
100 WXDLLIMPEXP_BASE
const wxChar
*wxGetInstallPrefix();
101 // Return path to wxWin data (/usr/share/wx/%{version}) (Unices)
102 WXDLLIMPEXP_BASE wxString
wxGetDataDir();
107 // Get the state of a key (true if pressed, false if not)
108 // This is generally most useful getting the state of
109 // the modifier or toggle keys.
110 WXDLLEXPORT
bool wxGetKeyState(wxKeyCode key
);
113 // Don't synthesize KeyUp events holding down a key and producing
114 // KeyDown events with autorepeat. On by default and always on
116 WXDLLEXPORT
bool wxSetDetectableAutoRepeat( bool flag
);
118 // ----------------------------------------------------------------------------
119 // Window ID management
120 // ----------------------------------------------------------------------------
122 // Generate a unique ID
123 WXDLLEXPORT
long wxNewId();
125 // Ensure subsequent IDs don't clash with this one
126 WXDLLEXPORT
void wxRegisterId(long id
);
128 // Return the current ID
129 WXDLLEXPORT
long wxGetCurrentId();
133 // ----------------------------------------------------------------------------
134 // Various conversions
135 // ----------------------------------------------------------------------------
137 // these functions are deprecated, use wxString methods instead!
138 #if WXWIN_COMPATIBILITY_2_4
140 extern WXDLLIMPEXP_DATA_BASE(const wxChar
*) wxFloatToStringStr
;
141 extern WXDLLIMPEXP_DATA_BASE(const wxChar
*) wxDoubleToStringStr
;
143 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToFloat(const wxChar
*s
, float *number
) );
144 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* FloatToString(float number
, const wxChar
*fmt
= wxFloatToStringStr
) );
145 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToDouble(const wxChar
*s
, double *number
) );
146 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* DoubleToString(double number
, const wxChar
*fmt
= wxDoubleToStringStr
) );
147 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToInt(const wxChar
*s
, int *number
) );
148 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToLong(const wxChar
*s
, long *number
) );
149 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* IntToString(int number
) );
150 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* LongToString(long number
) );
152 #endif // WXWIN_COMPATIBILITY_2_4
154 // Convert 2-digit hex number to decimal
155 WXDLLIMPEXP_BASE
int wxHexToDec(const wxString
& buf
);
157 // Convert decimal integer to 2-character hex string
158 WXDLLIMPEXP_BASE
void wxDecToHex(int dec
, wxChar
*buf
);
159 WXDLLIMPEXP_BASE wxString
wxDecToHex(int dec
);
161 // ----------------------------------------------------------------------------
162 // Process management
163 // ----------------------------------------------------------------------------
165 // NB: for backwards compatibility reasons the values of wxEXEC_[A]SYNC *must*
166 // be 0 and 1, don't change!
170 // execute the process asynchronously
173 // execute it synchronously, i.e. wait until it finishes
176 // under Windows, don't hide the child even if it's IO is redirected (this
177 // is done by default)
180 // under Unix, if the process is the group leader then passing wxKILL_CHILDREN to wxKill
181 // kills all children as well as pid
182 wxEXEC_MAKE_GROUP_LEADER
= 4,
184 // by default synchronous execution disables all program windows to avoid
185 // that the user interacts with the program while the child process is
186 // running, you can use this flag to prevent this from happening
190 // Execute another program.
192 // If flags contain wxEXEC_SYNC, return -1 on failure and the exit code of the
193 // process if everything was ok. Otherwise (i.e. if wxEXEC_ASYNC), return 0 on
194 // failure and the PID of the launched process if ok.
195 WXDLLIMPEXP_BASE
long wxExecute(wxChar
**argv
, int flags
= wxEXEC_ASYNC
,
196 wxProcess
*process
= (wxProcess
*) NULL
);
197 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
, int flags
= wxEXEC_ASYNC
,
198 wxProcess
*process
= (wxProcess
*) NULL
);
200 // execute the command capturing its output into an array line by line, this is
201 // always synchronous
202 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
,
203 wxArrayString
& output
,
206 // also capture stderr (also synchronous)
207 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
,
208 wxArrayString
& output
,
209 wxArrayString
& error
,
213 // ask a DDE server to execute the DDE request with given parameters
214 WXDLLIMPEXP_BASE
bool wxExecuteDDE(const wxString
& ddeServer
,
215 const wxString
& ddeTopic
,
216 const wxString
& ddeCommand
);
221 wxSIGNONE
= 0, // verify if the process exists under Unix
228 wxSIGIOT
= wxSIGABRT
, // another name
239 // further signals are different in meaning between different Unix systems
244 wxKILL_OK
, // no error
245 wxKILL_BAD_SIGNAL
, // no such signal
246 wxKILL_ACCESS_DENIED
, // permission denied
247 wxKILL_NO_PROCESS
, // no such process
248 wxKILL_ERROR
// another, unspecified error
253 wxKILL_NOCHILDREN
= 0, // don't kill children
254 wxKILL_CHILDREN
= 1 // kill children
259 wxSHUTDOWN_POWEROFF
, // power off the computer
260 wxSHUTDOWN_REBOOT
// shutdown and reboot
263 // Shutdown or reboot the PC
264 WXDLLIMPEXP_BASE
bool wxShutdown(wxShutdownFlags wFlags
);
273 WXDLLIMPEXP_BASE wxPowerType
wxGetPowerType();
277 wxBATTERY_NORMAL_STATE
, // system is fully usable
278 wxBATTERY_LOW_STATE
, // start to worry
279 wxBATTERY_CRITICAL_STATE
, // save quickly
280 wxBATTERY_SHUTDOWN_STATE
, // too late
281 wxBATTERY_UNKNOWN_STATE
284 WXDLLIMPEXP_BASE wxBatteryState
wxGetBatteryState();
286 // send the given signal to the process (only NONE and KILL are supported under
287 // Windows, all others mean TERM), return 0 if ok and -1 on error
289 // return detailed error in rc if not NULL
290 WXDLLIMPEXP_BASE
int wxKill(long pid
,
291 wxSignal sig
= wxSIGTERM
,
292 wxKillError
*rc
= NULL
,
293 int flags
= wxKILL_NOCHILDREN
);
295 // Execute a command in an interactive shell window (always synchronously)
296 // If no command then just the shell
297 WXDLLIMPEXP_BASE
bool wxShell(const wxString
& command
= wxEmptyString
);
299 // As wxShell(), but must give a (non interactive) command and its output will
300 // be returned in output array
301 WXDLLIMPEXP_BASE
bool wxShell(const wxString
& command
, wxArrayString
& output
);
303 // Sleep for nSecs seconds
304 WXDLLIMPEXP_BASE
void wxSleep(int nSecs
);
306 // Sleep for a given amount of milliseconds
307 WXDLLIMPEXP_BASE
void wxMilliSleep(unsigned long milliseconds
);
309 // Sleep for a given amount of microseconds
310 WXDLLIMPEXP_BASE
void wxMicroSleep(unsigned long microseconds
);
312 // Sleep for a given amount of milliseconds (old, bad name), use wxMilliSleep
313 wxDEPRECATED( WXDLLIMPEXP_BASE
void wxUsleep(unsigned long milliseconds
) );
315 // Get the process id of the current process
316 WXDLLIMPEXP_BASE
unsigned long wxGetProcessId();
318 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
319 WXDLLIMPEXP_BASE wxMemorySize
wxGetFreeMemory();
321 #if wxUSE_ON_FATAL_EXCEPTION
323 // should wxApp::OnFatalException() be called?
324 WXDLLIMPEXP_BASE
bool wxHandleFatalExceptions(bool doit
= true);
326 #endif // wxUSE_ON_FATAL_EXCEPTION
328 // flags for wxLaunchDefaultBrowser
331 wxBROWSER_NEW_WINDOW
= 1
334 // Launch url in the user's default internet browser
335 WXDLLIMPEXP_BASE
bool wxLaunchDefaultBrowser(const wxString
& url
, int flags
= 0);
337 // ----------------------------------------------------------------------------
338 // Environment variables
339 // ----------------------------------------------------------------------------
341 // returns true if variable exists (value may be NULL if you just want to check
343 WXDLLIMPEXP_BASE
bool wxGetEnv(const wxString
& var
, wxString
*value
);
345 // set the env var name to the given value, return true on success
346 WXDLLIMPEXP_BASE
bool wxSetEnv(const wxString
& var
, const wxChar
*value
);
348 // remove the env var from environment
349 inline bool wxUnsetEnv(const wxString
& var
) { return wxSetEnv(var
, NULL
); }
351 // ----------------------------------------------------------------------------
352 // Network and username functions.
353 // ----------------------------------------------------------------------------
355 // NB: "char *" functions are deprecated, use wxString ones!
358 WXDLLIMPEXP_BASE
bool wxGetEmailAddress(wxChar
*buf
, int maxSize
);
359 WXDLLIMPEXP_BASE wxString
wxGetEmailAddress();
362 WXDLLIMPEXP_BASE
bool wxGetHostName(wxChar
*buf
, int maxSize
);
363 WXDLLIMPEXP_BASE wxString
wxGetHostName();
366 WXDLLIMPEXP_BASE wxString
wxGetFullHostName();
367 WXDLLIMPEXP_BASE
bool wxGetFullHostName(wxChar
*buf
, int maxSize
);
369 // Get user ID e.g. jacs (this is known as login name under Unix)
370 WXDLLIMPEXP_BASE
bool wxGetUserId(wxChar
*buf
, int maxSize
);
371 WXDLLIMPEXP_BASE wxString
wxGetUserId();
373 // Get user name e.g. Julian Smart
374 WXDLLIMPEXP_BASE
bool wxGetUserName(wxChar
*buf
, int maxSize
);
375 WXDLLIMPEXP_BASE wxString
wxGetUserName();
377 // Get current Home dir and copy to dest (returns pstr->c_str())
378 WXDLLIMPEXP_BASE wxString
wxGetHomeDir();
379 WXDLLIMPEXP_BASE
const wxChar
* wxGetHomeDir(wxString
*pstr
);
381 // Get the user's home dir (caller must copy --- volatile)
382 // returns NULL is no HOME dir is known
383 #if defined(__UNIX__) && wxUSE_UNICODE
384 WXDLLIMPEXP_BASE
const wxMB2WXbuf
wxGetUserHome(const wxString
& user
= wxEmptyString
);
386 WXDLLIMPEXP_BASE wxChar
* wxGetUserHome(const wxString
& user
= wxEmptyString
);
389 // get number of total/free bytes on the disk where path belongs
390 WXDLLIMPEXP_BASE
bool wxGetDiskSpace(const wxString
& path
,
391 wxLongLong
*pTotal
= NULL
,
392 wxLongLong
*pFree
= NULL
);
394 #if wxUSE_GUI // GUI only things from now on
396 // ----------------------------------------------------------------------------
397 // Menu accelerators related things
398 // ----------------------------------------------------------------------------
400 WXDLLEXPORT wxChar
* wxStripMenuCodes(const wxChar
*in
, wxChar
*out
= (wxChar
*) NULL
);
401 WXDLLEXPORT wxString
wxStripMenuCodes(const wxString
& str
);
404 class WXDLLEXPORT wxAcceleratorEntry
;
405 WXDLLEXPORT wxAcceleratorEntry
*wxGetAccelFromString(const wxString
& label
);
406 #endif // wxUSE_ACCEL
408 // ----------------------------------------------------------------------------
410 // ----------------------------------------------------------------------------
412 // Returns menu item id or wxNOT_FOUND if none.
413 WXDLLEXPORT
int wxFindMenuItemId(wxFrame
*frame
, const wxString
& menuString
, const wxString
& itemString
);
415 // Find the wxWindow at the given point. wxGenericFindWindowAtPoint
416 // is always present but may be less reliable than a native version.
417 WXDLLEXPORT wxWindow
* wxGenericFindWindowAtPoint(const wxPoint
& pt
);
418 WXDLLEXPORT wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
);
420 // NB: this function is obsolete, use wxWindow::FindWindowByLabel() instead
422 // Find the window/widget with the given title or label.
423 // Pass a parent to begin the search from, or NULL to look through
425 WXDLLEXPORT wxWindow
* wxFindWindowByLabel(const wxString
& title
, wxWindow
*parent
= (wxWindow
*) NULL
);
427 // NB: this function is obsolete, use wxWindow::FindWindowByName() instead
429 // Find window by name, and if that fails, by label.
430 WXDLLEXPORT wxWindow
* wxFindWindowByName(const wxString
& name
, wxWindow
*parent
= (wxWindow
*) NULL
);
432 // ----------------------------------------------------------------------------
433 // Message/event queue helpers
434 // ----------------------------------------------------------------------------
436 // Yield to other apps/messages and disable user input
437 WXDLLEXPORT
bool wxSafeYield(wxWindow
*win
= NULL
, bool onlyIfNeeded
= false);
439 // Enable or disable input to all top level windows
440 WXDLLEXPORT
void wxEnableTopLevelWindows(bool enable
= true);
442 // Check whether this window wants to process messages, e.g. Stop button
443 // in long calculations.
444 WXDLLEXPORT
bool wxCheckForInterrupt(wxWindow
*wnd
);
446 // Consume all events until no more left
447 WXDLLEXPORT
void wxFlushEvents();
449 // a class which disables all windows (except, may be, thegiven one) in its
450 // ctor and enables them back in its dtor
451 class WXDLLEXPORT wxWindowDisabler
454 wxWindowDisabler(wxWindow
*winToSkip
= (wxWindow
*)NULL
);
458 wxWindowList
*m_winDisabled
;
460 DECLARE_NO_COPY_CLASS(wxWindowDisabler
)
463 // ----------------------------------------------------------------------------
465 // ----------------------------------------------------------------------------
467 // Set the cursor to the busy cursor for all windows
468 class WXDLLEXPORT wxCursor
;
469 extern WXDLLEXPORT_DATA(wxCursor
*) wxHOURGLASS_CURSOR
;
470 WXDLLEXPORT
void wxBeginBusyCursor(wxCursor
*cursor
= wxHOURGLASS_CURSOR
);
472 // Restore cursor to normal
473 WXDLLEXPORT
void wxEndBusyCursor();
475 // true if we're between the above two calls
476 WXDLLEXPORT
bool wxIsBusy();
478 // Convenience class so we can just create a wxBusyCursor object on the stack
479 class WXDLLEXPORT wxBusyCursor
482 wxBusyCursor(wxCursor
* cursor
= wxHOURGLASS_CURSOR
)
483 { wxBeginBusyCursor(cursor
); }
485 { wxEndBusyCursor(); }
487 // FIXME: These two methods are currently only implemented (and needed?)
488 // in wxGTK. BusyCursor handling should probably be moved to
489 // common code since the wxGTK and wxMSW implementations are very
490 // similar except for wxMSW using HCURSOR directly instead of
492 static const wxCursor
&GetStoredCursor();
493 static const wxCursor
GetBusyCursor();
497 // ----------------------------------------------------------------------------
498 // Reading and writing resources (eg WIN.INI, .Xdefaults)
499 // ----------------------------------------------------------------------------
502 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, const wxString
& value
, const wxString
& file
= wxEmptyString
);
503 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, float value
, const wxString
& file
= wxEmptyString
);
504 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, long value
, const wxString
& file
= wxEmptyString
);
505 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, int value
, const wxString
& file
= wxEmptyString
);
507 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, wxChar
**value
, const wxString
& file
= wxEmptyString
);
508 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, float *value
, const wxString
& file
= wxEmptyString
);
509 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, long *value
, const wxString
& file
= wxEmptyString
);
510 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, int *value
, const wxString
& file
= wxEmptyString
);
511 #endif // wxUSE_RESOURCES
513 void WXDLLEXPORT
wxGetMousePosition( int* x
, int* y
);
515 // MSW only: get user-defined resource from the .res file.
516 // Returns NULL or newly-allocated memory, so use delete[] to clean up.
518 extern WXDLLEXPORT
const wxChar
* wxUserResourceStr
;
519 WXDLLEXPORT wxChar
* wxLoadUserResource(const wxString
& resourceName
, const wxString
& resourceType
= wxUserResourceStr
);
522 // ----------------------------------------------------------------------------
523 // Display and colorss (X only)
524 // ----------------------------------------------------------------------------
527 void *wxGetDisplay();
531 WXDLLIMPEXP_CORE WXDisplay
*wxGetDisplay();
532 WXDLLIMPEXP_CORE
bool wxSetDisplay(const wxString
& display_name
);
533 WXDLLIMPEXP_CORE wxString
wxGetDisplayName();
538 #ifdef __VMS__ // Xlib.h for VMS is not (yet) compatible with C++
539 // The resulting warnings are switched off here
540 #pragma message disable nosimpint
542 // #include <X11/Xlib.h>
544 #pragma message enable nosimpint
551 // ----------------------------------------------------------------------------
552 // wxYield(): these functions are obsolete, please use wxApp methods instead!
553 // ----------------------------------------------------------------------------
555 // Yield to other apps/messages
556 WXDLLIMPEXP_BASE
bool wxYield();
558 // Like wxYield, but fails silently if the yield is recursive.
559 WXDLLIMPEXP_BASE
bool wxYieldIfNeeded();
561 // ----------------------------------------------------------------------------
562 // Error message functions used by wxWidgets (deprecated, use wxLog)
563 // ----------------------------------------------------------------------------
565 #if WXWIN_COMPATIBILITY_2_2
567 // Format a message on the standard error (UNIX) or the debugging
569 wxDEPRECATED( WXDLLIMPEXP_BASE
void wxDebugMsg(const wxChar
*fmt
...) ATTRIBUTE_PRINTF_1
);
571 // Non-fatal error (continues)
572 extern WXDLLIMPEXP_DATA_BASE(const wxChar
*) wxInternalErrorStr
;
573 wxDEPRECATED( WXDLLIMPEXP_BASE
void wxError(const wxString
& msg
, const wxString
& title
= wxInternalErrorStr
) );
575 // Fatal error (exits)
576 extern WXDLLIMPEXP_DATA_BASE(const wxChar
*) wxFatalErrorStr
;
577 wxDEPRECATED( WXDLLIMPEXP_BASE
void wxFatalError(const wxString
& msg
, const wxString
& title
= wxFatalErrorStr
) );
579 #endif // WXWIN_COMPATIBILITY_2_2