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
;
24 class WXDLLIMPEXP_BASE wxArrayInt
;
26 // need this for wxGetDiskSpace() as we can't, unfortunately, forward declare
28 #include "wx/longlong.h"
39 // ----------------------------------------------------------------------------
40 // Forward declaration
41 // ----------------------------------------------------------------------------
43 class WXDLLIMPEXP_CORE wxProcess
;
44 class WXDLLIMPEXP_CORE wxFrame
;
45 class WXDLLIMPEXP_CORE wxWindow
;
46 class WXDLLIMPEXP_CORE wxWindowList
;
47 class WXDLLIMPEXP_CORE wxPoint
;
49 // ----------------------------------------------------------------------------
51 // ----------------------------------------------------------------------------
53 #define wxMax(a,b) (((a) > (b)) ? (a) : (b))
54 #define wxMin(a,b) (((a) < (b)) ? (a) : (b))
56 // wxGetFreeMemory can return huge amount of memory on 32-bit platforms as well
57 // so to always use long long for its result type on all platforms which
60 typedef wxLongLong wxMemorySize
;
62 typedef long wxMemorySize
;
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();
105 * Class to make it easier to specify platform-dependent values
108 * long val = wxPlatform::If(wxMac, 1).ElseIf(wxGTK, 2).ElseIf(stPDA, 5).Else(3);
109 * wxString strVal = wxPlatform::If(wxMac, wxT("Mac")).ElseIf(wxMSW, wxT("MSW")).Else(wxT("Other"));
111 * A custom platform symbol:
115 * wxPlatform::AddPlatform(stPDA);
118 * long windowStyle = wxCAPTION | (long) wxPlatform::IfNot(stPDA, wxRESIZE_BORDER);
122 class WXDLLIMPEXP_BASE wxPlatform
125 wxPlatform() { Init(); }
126 wxPlatform(const wxPlatform
& platform
) { Copy(platform
); }
127 void operator = (const wxPlatform
& platform
) { Copy(platform
); }
128 void Copy(const wxPlatform
& platform
);
129 void Init() { m_longValue
= 0; m_doubleValue
= 0.0; }
131 // Specify an optional default value
132 wxPlatform(long defValue
) { m_longValue
= defValue
; m_doubleValue
= 0.0; }
133 wxPlatform(const wxString
& defValue
) { m_stringValue
= defValue
; m_longValue
= 0; m_doubleValue
= 0.0; }
134 wxPlatform(double defValue
) { m_longValue
= 0; m_doubleValue
= defValue
; }
136 static wxPlatform
If(int platform
, long value
);
137 static wxPlatform
IfNot(int platform
, long value
);
138 wxPlatform
& ElseIf(int platform
, long value
);
139 wxPlatform
& ElseIfNot(int platform
, long value
);
140 wxPlatform
& Else(long value
);
142 static wxPlatform
If(int platform
, int value
);
143 static wxPlatform
IfNot(int platform
, int value
) { return IfNot(platform
, (long)value
); }
144 wxPlatform
& ElseIf(int platform
, int value
) { return ElseIf(platform
, (long) value
); }
145 wxPlatform
& ElseIfNot(int platform
, int value
) { return ElseIfNot(platform
, (long) value
); }
146 wxPlatform
& Else(int value
) { return Else((long) value
); }
148 static wxPlatform
If(int platform
, double value
);
149 static wxPlatform
IfNot(int platform
, double value
);
150 wxPlatform
& ElseIf(int platform
, double value
);
151 wxPlatform
& ElseIfNot(int platform
, double value
);
152 wxPlatform
& Else(double value
);
154 static wxPlatform
If(int platform
, const wxString
& value
);
155 static wxPlatform
IfNot(int platform
, const wxString
& value
);
156 wxPlatform
& ElseIf(int platform
, const wxString
& value
);
157 wxPlatform
& ElseIfNot(int platform
, const wxString
& value
);
158 wxPlatform
& Else(const wxString
& value
);
160 long GetInteger() const { return m_longValue
; }
161 const wxString
& GetString() const { return m_stringValue
; }
162 double GetDouble() const { return m_doubleValue
; }
164 operator int() const { return (int) GetInteger(); }
165 operator long() const { return GetInteger(); }
166 operator double() const { return GetDouble(); }
167 operator const wxString() const { return GetString(); }
168 operator const wxChar
*() const { return (const wxChar
*) GetString(); }
170 static void AddPlatform(int platform
);
171 static bool Is(int platform
);
172 static void ClearPlatforms();
176 double m_doubleValue
;
177 wxString m_stringValue
;
178 static wxArrayInt
* sm_customPlatforms
;
181 /// Function for testing current platform
182 inline bool wxPlatformIs(int platform
) { return wxPlatform::Is(platform
); }
186 // Get the state of a key (true if pressed, false if not)
187 // This is generally most useful getting the state of
188 // the modifier or toggle keys.
189 WXDLLEXPORT
bool wxGetKeyState(wxKeyCode key
);
192 // Don't synthesize KeyUp events holding down a key and producing
193 // KeyDown events with autorepeat. On by default and always on
195 WXDLLEXPORT
bool wxSetDetectableAutoRepeat( bool flag
);
198 // wxMouseState is used to hold information about button and modifier state
199 // and is what is returned from wxGetMouseState.
200 class WXDLLEXPORT wxMouseState
205 m_leftDown(false), m_middleDown(false), m_rightDown(false),
206 m_controlDown(false), m_shiftDown(false), m_altDown(false),
210 wxCoord
GetX() { return m_x
; }
211 wxCoord
GetY() { return m_y
; }
213 bool LeftDown() { return m_leftDown
; }
214 bool MiddleDown() { return m_middleDown
; }
215 bool RightDown() { return m_rightDown
; }
217 bool ControlDown() { return m_controlDown
; }
218 bool ShiftDown() { return m_shiftDown
; }
219 bool AltDown() { return m_altDown
; }
220 bool MetaDown() { return m_metaDown
; }
223 #if defined(__WXMAC__) || defined(__WXCOCOA__)
226 return ControlDown();
230 void SetX(wxCoord x
) { m_x
= x
; }
231 void SetY(wxCoord y
) { m_y
= y
; }
233 void SetLeftDown(bool down
) { m_leftDown
= down
; }
234 void SetMiddleDown(bool down
) { m_middleDown
= down
; }
235 void SetRightDown(bool down
) { m_rightDown
= down
; }
237 void SetControlDown(bool down
) { m_controlDown
= down
; }
238 void SetShiftDown(bool down
) { m_shiftDown
= down
; }
239 void SetAltDown(bool down
) { m_altDown
= down
; }
240 void SetMetaDown(bool down
) { m_metaDown
= down
; }
257 // Returns the current state of the mouse position, buttons and modifers
258 WXDLLEXPORT wxMouseState
wxGetMouseState();
261 // ----------------------------------------------------------------------------
262 // Window ID management
263 // ----------------------------------------------------------------------------
265 // Generate a unique ID
266 WXDLLEXPORT
long wxNewId();
268 // Ensure subsequent IDs don't clash with this one
269 WXDLLEXPORT
void wxRegisterId(long id
);
271 // Return the current ID
272 WXDLLEXPORT
long wxGetCurrentId();
276 // ----------------------------------------------------------------------------
277 // Various conversions
278 // ----------------------------------------------------------------------------
280 // these functions are deprecated, use wxString methods instead!
281 #if WXWIN_COMPATIBILITY_2_4
283 extern WXDLLIMPEXP_DATA_BASE(const wxChar
*) wxFloatToStringStr
;
284 extern WXDLLIMPEXP_DATA_BASE(const wxChar
*) wxDoubleToStringStr
;
286 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToFloat(const wxChar
*s
, float *number
) );
287 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* FloatToString(float number
, const wxChar
*fmt
= wxFloatToStringStr
) );
288 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToDouble(const wxChar
*s
, double *number
) );
289 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* DoubleToString(double number
, const wxChar
*fmt
= wxDoubleToStringStr
) );
290 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToInt(const wxChar
*s
, int *number
) );
291 wxDEPRECATED( WXDLLIMPEXP_BASE
void StringToLong(const wxChar
*s
, long *number
) );
292 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* IntToString(int number
) );
293 wxDEPRECATED( WXDLLIMPEXP_BASE wxChar
* LongToString(long number
) );
295 #endif // WXWIN_COMPATIBILITY_2_4
297 // Convert 2-digit hex number to decimal
298 WXDLLIMPEXP_BASE
int wxHexToDec(const wxString
& buf
);
300 // Convert decimal integer to 2-character hex string
301 WXDLLIMPEXP_BASE
void wxDecToHex(int dec
, wxChar
*buf
);
302 WXDLLIMPEXP_BASE wxString
wxDecToHex(int dec
);
304 // ----------------------------------------------------------------------------
305 // Process management
306 // ----------------------------------------------------------------------------
308 // NB: for backwards compatibility reasons the values of wxEXEC_[A]SYNC *must*
309 // be 0 and 1, don't change!
313 // execute the process asynchronously
316 // execute it synchronously, i.e. wait until it finishes
319 // under Windows, don't hide the child even if it's IO is redirected (this
320 // is done by default)
323 // under Unix, if the process is the group leader then passing wxKILL_CHILDREN to wxKill
324 // kills all children as well as pid
325 wxEXEC_MAKE_GROUP_LEADER
= 4,
327 // by default synchronous execution disables all program windows to avoid
328 // that the user interacts with the program while the child process is
329 // running, you can use this flag to prevent this from happening
333 // Execute another program.
335 // If flags contain wxEXEC_SYNC, return -1 on failure and the exit code of the
336 // process if everything was ok. Otherwise (i.e. if wxEXEC_ASYNC), return 0 on
337 // failure and the PID of the launched process if ok.
338 WXDLLIMPEXP_BASE
long wxExecute(wxChar
**argv
, int flags
= wxEXEC_ASYNC
,
339 wxProcess
*process
= (wxProcess
*) NULL
);
340 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
, int flags
= wxEXEC_ASYNC
,
341 wxProcess
*process
= (wxProcess
*) NULL
);
343 // execute the command capturing its output into an array line by line, this is
344 // always synchronous
345 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
,
346 wxArrayString
& output
,
349 // also capture stderr (also synchronous)
350 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
,
351 wxArrayString
& output
,
352 wxArrayString
& error
,
355 #if defined(__WXMSW__) && wxUSE_IPC
356 // ask a DDE server to execute the DDE request with given parameters
357 WXDLLIMPEXP_BASE
bool wxExecuteDDE(const wxString
& ddeServer
,
358 const wxString
& ddeTopic
,
359 const wxString
& ddeCommand
);
360 #endif // __WXMSW__ && wxUSE_IPC
364 wxSIGNONE
= 0, // verify if the process exists under Unix
371 wxSIGIOT
= wxSIGABRT
, // another name
382 // further signals are different in meaning between different Unix systems
387 wxKILL_OK
, // no error
388 wxKILL_BAD_SIGNAL
, // no such signal
389 wxKILL_ACCESS_DENIED
, // permission denied
390 wxKILL_NO_PROCESS
, // no such process
391 wxKILL_ERROR
// another, unspecified error
396 wxKILL_NOCHILDREN
= 0, // don't kill children
397 wxKILL_CHILDREN
= 1 // kill children
402 wxSHUTDOWN_POWEROFF
, // power off the computer
403 wxSHUTDOWN_REBOOT
// shutdown and reboot
406 // Shutdown or reboot the PC
407 WXDLLIMPEXP_BASE
bool wxShutdown(wxShutdownFlags wFlags
);
416 WXDLLIMPEXP_BASE wxPowerType
wxGetPowerType();
420 wxBATTERY_NORMAL_STATE
, // system is fully usable
421 wxBATTERY_LOW_STATE
, // start to worry
422 wxBATTERY_CRITICAL_STATE
, // save quickly
423 wxBATTERY_SHUTDOWN_STATE
, // too late
424 wxBATTERY_UNKNOWN_STATE
427 WXDLLIMPEXP_BASE wxBatteryState
wxGetBatteryState();
429 // send the given signal to the process (only NONE and KILL are supported under
430 // Windows, all others mean TERM), return 0 if ok and -1 on error
432 // return detailed error in rc if not NULL
433 WXDLLIMPEXP_BASE
int wxKill(long pid
,
434 wxSignal sig
= wxSIGTERM
,
435 wxKillError
*rc
= NULL
,
436 int flags
= wxKILL_NOCHILDREN
);
438 // Execute a command in an interactive shell window (always synchronously)
439 // If no command then just the shell
440 WXDLLIMPEXP_BASE
bool wxShell(const wxString
& command
= wxEmptyString
);
442 // As wxShell(), but must give a (non interactive) command and its output will
443 // be returned in output array
444 WXDLLIMPEXP_BASE
bool wxShell(const wxString
& command
, wxArrayString
& output
);
446 // Sleep for nSecs seconds
447 WXDLLIMPEXP_BASE
void wxSleep(int nSecs
);
449 // Sleep for a given amount of milliseconds
450 WXDLLIMPEXP_BASE
void wxMilliSleep(unsigned long milliseconds
);
452 // Sleep for a given amount of microseconds
453 WXDLLIMPEXP_BASE
void wxMicroSleep(unsigned long microseconds
);
455 // Sleep for a given amount of milliseconds (old, bad name), use wxMilliSleep
456 wxDEPRECATED( WXDLLIMPEXP_BASE
void wxUsleep(unsigned long milliseconds
) );
458 // Get the process id of the current process
459 WXDLLIMPEXP_BASE
unsigned long wxGetProcessId();
461 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
462 WXDLLIMPEXP_BASE wxMemorySize
wxGetFreeMemory();
464 #if wxUSE_ON_FATAL_EXCEPTION
466 // should wxApp::OnFatalException() be called?
467 WXDLLIMPEXP_BASE
bool wxHandleFatalExceptions(bool doit
= true);
469 #endif // wxUSE_ON_FATAL_EXCEPTION
471 // flags for wxLaunchDefaultBrowser
474 wxBROWSER_NEW_WINDOW
= 1
477 // Launch url in the user's default internet browser
478 WXDLLIMPEXP_BASE
bool wxLaunchDefaultBrowser(const wxString
& url
, int flags
= 0);
480 // ----------------------------------------------------------------------------
481 // Environment variables
482 // ----------------------------------------------------------------------------
484 // returns true if variable exists (value may be NULL if you just want to check
486 WXDLLIMPEXP_BASE
bool wxGetEnv(const wxString
& var
, wxString
*value
);
488 // set the env var name to the given value, return true on success
489 WXDLLIMPEXP_BASE
bool wxSetEnv(const wxString
& var
, const wxChar
*value
);
491 // remove the env var from environment
492 inline bool wxUnsetEnv(const wxString
& var
) { return wxSetEnv(var
, NULL
); }
494 // ----------------------------------------------------------------------------
495 // Network and username functions.
496 // ----------------------------------------------------------------------------
498 // NB: "char *" functions are deprecated, use wxString ones!
501 WXDLLIMPEXP_BASE
bool wxGetEmailAddress(wxChar
*buf
, int maxSize
);
502 WXDLLIMPEXP_BASE wxString
wxGetEmailAddress();
505 WXDLLIMPEXP_BASE
bool wxGetHostName(wxChar
*buf
, int maxSize
);
506 WXDLLIMPEXP_BASE wxString
wxGetHostName();
509 WXDLLIMPEXP_BASE wxString
wxGetFullHostName();
510 WXDLLIMPEXP_BASE
bool wxGetFullHostName(wxChar
*buf
, int maxSize
);
512 // Get user ID e.g. jacs (this is known as login name under Unix)
513 WXDLLIMPEXP_BASE
bool wxGetUserId(wxChar
*buf
, int maxSize
);
514 WXDLLIMPEXP_BASE wxString
wxGetUserId();
516 // Get user name e.g. Julian Smart
517 WXDLLIMPEXP_BASE
bool wxGetUserName(wxChar
*buf
, int maxSize
);
518 WXDLLIMPEXP_BASE wxString
wxGetUserName();
520 // Get current Home dir and copy to dest (returns pstr->c_str())
521 WXDLLIMPEXP_BASE wxString
wxGetHomeDir();
522 WXDLLIMPEXP_BASE
const wxChar
* wxGetHomeDir(wxString
*pstr
);
524 // Get the user's home dir (caller must copy --- volatile)
525 // returns NULL is no HOME dir is known
526 #if defined(__UNIX__) && wxUSE_UNICODE
527 WXDLLIMPEXP_BASE
const wxMB2WXbuf
wxGetUserHome(const wxString
& user
= wxEmptyString
);
529 WXDLLIMPEXP_BASE wxChar
* wxGetUserHome(const wxString
& user
= wxEmptyString
);
533 typedef wxLongLong wxDiskspaceSize_t
;
535 typedef long wxDiskspaceSize_t
;
538 // get number of total/free bytes on the disk where path belongs
539 WXDLLIMPEXP_BASE
bool wxGetDiskSpace(const wxString
& path
,
540 wxDiskspaceSize_t
*pTotal
= NULL
,
541 wxDiskspaceSize_t
*pFree
= NULL
);
543 #if wxUSE_GUI // GUI only things from now on
545 // ----------------------------------------------------------------------------
546 // Menu accelerators related things
547 // ----------------------------------------------------------------------------
549 WXDLLEXPORT wxChar
* wxStripMenuCodes(const wxChar
*in
, wxChar
*out
= (wxChar
*) NULL
);
550 WXDLLEXPORT wxString
wxStripMenuCodes(const wxString
& str
);
553 class WXDLLEXPORT wxAcceleratorEntry
;
554 WXDLLEXPORT wxAcceleratorEntry
*wxGetAccelFromString(const wxString
& label
);
555 #endif // wxUSE_ACCEL
557 // ----------------------------------------------------------------------------
559 // ----------------------------------------------------------------------------
561 // Returns menu item id or wxNOT_FOUND if none.
562 WXDLLEXPORT
int wxFindMenuItemId(wxFrame
*frame
, const wxString
& menuString
, const wxString
& itemString
);
564 // Find the wxWindow at the given point. wxGenericFindWindowAtPoint
565 // is always present but may be less reliable than a native version.
566 WXDLLEXPORT wxWindow
* wxGenericFindWindowAtPoint(const wxPoint
& pt
);
567 WXDLLEXPORT wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
);
569 // NB: this function is obsolete, use wxWindow::FindWindowByLabel() instead
571 // Find the window/widget with the given title or label.
572 // Pass a parent to begin the search from, or NULL to look through
574 WXDLLEXPORT wxWindow
* wxFindWindowByLabel(const wxString
& title
, wxWindow
*parent
= (wxWindow
*) NULL
);
576 // NB: this function is obsolete, use wxWindow::FindWindowByName() instead
578 // Find window by name, and if that fails, by label.
579 WXDLLEXPORT wxWindow
* wxFindWindowByName(const wxString
& name
, wxWindow
*parent
= (wxWindow
*) NULL
);
581 // ----------------------------------------------------------------------------
582 // Message/event queue helpers
583 // ----------------------------------------------------------------------------
585 // Yield to other apps/messages and disable user input
586 WXDLLEXPORT
bool wxSafeYield(wxWindow
*win
= NULL
, bool onlyIfNeeded
= false);
588 // Enable or disable input to all top level windows
589 WXDLLEXPORT
void wxEnableTopLevelWindows(bool enable
= true);
591 // Check whether this window wants to process messages, e.g. Stop button
592 // in long calculations.
593 WXDLLEXPORT
bool wxCheckForInterrupt(wxWindow
*wnd
);
595 // Consume all events until no more left
596 WXDLLEXPORT
void wxFlushEvents();
598 // a class which disables all windows (except, may be, thegiven one) in its
599 // ctor and enables them back in its dtor
600 class WXDLLEXPORT wxWindowDisabler
603 wxWindowDisabler(wxWindow
*winToSkip
= (wxWindow
*)NULL
);
607 wxWindowList
*m_winDisabled
;
609 DECLARE_NO_COPY_CLASS(wxWindowDisabler
)
612 // ----------------------------------------------------------------------------
614 // ----------------------------------------------------------------------------
616 // Set the cursor to the busy cursor for all windows
617 class WXDLLEXPORT wxCursor
;
618 extern WXDLLEXPORT_DATA(wxCursor
*) wxHOURGLASS_CURSOR
;
619 WXDLLEXPORT
void wxBeginBusyCursor(wxCursor
*cursor
= wxHOURGLASS_CURSOR
);
621 // Restore cursor to normal
622 WXDLLEXPORT
void wxEndBusyCursor();
624 // true if we're between the above two calls
625 WXDLLEXPORT
bool wxIsBusy();
627 // Convenience class so we can just create a wxBusyCursor object on the stack
628 class WXDLLEXPORT wxBusyCursor
631 wxBusyCursor(wxCursor
* cursor
= wxHOURGLASS_CURSOR
)
632 { wxBeginBusyCursor(cursor
); }
634 { wxEndBusyCursor(); }
636 // FIXME: These two methods are currently only implemented (and needed?)
637 // in wxGTK. BusyCursor handling should probably be moved to
638 // common code since the wxGTK and wxMSW implementations are very
639 // similar except for wxMSW using HCURSOR directly instead of
641 static const wxCursor
&GetStoredCursor();
642 static const wxCursor
GetBusyCursor();
646 // ----------------------------------------------------------------------------
647 // Reading and writing resources (eg WIN.INI, .Xdefaults)
648 // ----------------------------------------------------------------------------
651 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, const wxString
& value
, const wxString
& file
= wxEmptyString
);
652 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, float value
, const wxString
& file
= wxEmptyString
);
653 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, long value
, const wxString
& file
= wxEmptyString
);
654 WXDLLEXPORT
bool wxWriteResource(const wxString
& section
, const wxString
& entry
, int value
, const wxString
& file
= wxEmptyString
);
656 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, wxChar
**value
, const wxString
& file
= wxEmptyString
);
657 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, float *value
, const wxString
& file
= wxEmptyString
);
658 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, long *value
, const wxString
& file
= wxEmptyString
);
659 WXDLLEXPORT
bool wxGetResource(const wxString
& section
, const wxString
& entry
, int *value
, const wxString
& file
= wxEmptyString
);
660 #endif // wxUSE_RESOURCES
662 void WXDLLEXPORT
wxGetMousePosition( int* x
, int* y
);
664 // MSW only: get user-defined resource from the .res file.
665 // Returns NULL or newly-allocated memory, so use delete[] to clean up.
667 extern WXDLLEXPORT
const wxChar
* wxUserResourceStr
;
668 WXDLLEXPORT wxChar
* wxLoadUserResource(const wxString
& resourceName
, const wxString
& resourceType
= wxUserResourceStr
);
671 // ----------------------------------------------------------------------------
672 // Display and colorss (X only)
673 // ----------------------------------------------------------------------------
676 void *wxGetDisplay();
680 WXDLLIMPEXP_CORE WXDisplay
*wxGetDisplay();
681 WXDLLIMPEXP_CORE
bool wxSetDisplay(const wxString
& display_name
);
682 WXDLLIMPEXP_CORE wxString
wxGetDisplayName();
687 #ifdef __VMS__ // Xlib.h for VMS is not (yet) compatible with C++
688 // The resulting warnings are switched off here
689 #pragma message disable nosimpint
691 // #include <X11/Xlib.h>
693 #pragma message enable nosimpint
700 // ----------------------------------------------------------------------------
701 // wxYield(): these functions are obsolete, please use wxApp methods instead!
702 // ----------------------------------------------------------------------------
704 // Yield to other apps/messages
705 WXDLLIMPEXP_BASE
bool wxYield();
707 // Like wxYield, but fails silently if the yield is recursive.
708 WXDLLIMPEXP_BASE
bool wxYieldIfNeeded();
710 // ----------------------------------------------------------------------------
711 // Error message functions used by wxWidgets (deprecated, use wxLog)
712 // ----------------------------------------------------------------------------