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 #include "wx/gdicmn.h"
26 class WXDLLIMPEXP_FWD_BASE wxArrayString
;
27 class WXDLLIMPEXP_FWD_BASE wxArrayInt
;
29 // need this for wxGetDiskSpace() as we can't, unfortunately, forward declare
31 #include "wx/longlong.h"
33 // need for wxOperatingSystemId
34 #include "wx/platinfo.h"
45 // ----------------------------------------------------------------------------
46 // Forward declaration
47 // ----------------------------------------------------------------------------
49 class WXDLLIMPEXP_FWD_BASE wxProcess
;
50 class WXDLLIMPEXP_FWD_CORE wxFrame
;
51 class WXDLLIMPEXP_FWD_CORE wxWindow
;
52 class WXDLLIMPEXP_FWD_CORE wxWindowList
;
54 // ----------------------------------------------------------------------------
56 // ----------------------------------------------------------------------------
58 #define wxMax(a,b) (((a) > (b)) ? (a) : (b))
59 #define wxMin(a,b) (((a) < (b)) ? (a) : (b))
60 #define wxClip(a,b,c) (((a) < (b)) ? (b) : (((a) > (c)) ? (c) : (a)))
62 // wxGetFreeMemory can return huge amount of memory on 32-bit platforms as well
63 // so to always use long long for its result type on all platforms which
66 typedef wxLongLong wxMemorySize
;
68 typedef long wxMemorySize
;
71 // ----------------------------------------------------------------------------
72 // String functions (deprecated, use wxString)
73 // ----------------------------------------------------------------------------
75 // A shorter way of using strcmp
76 #define wxStringEq(s1, s2) (s1 && s2 && (wxStrcmp(s1, s2) == 0))
78 // ----------------------------------------------------------------------------
79 // Miscellaneous functions
80 // ----------------------------------------------------------------------------
83 #if !defined __EMX__ && \
84 (defined __WXMOTIF__ || defined __WXGTK__ || defined __WXX11__)
85 WXDLLIMPEXP_CORE
void wxBell();
87 WXDLLIMPEXP_BASE
void wxBell();
91 // Show wxWidgets information
92 WXDLLIMPEXP_CORE
void wxInfoMessageBox(wxWindow
* parent
);
93 #endif // wxUSE_MSGDLG
95 // Get OS description as a user-readable string
96 WXDLLIMPEXP_BASE wxString
wxGetOsDescription();
99 WXDLLIMPEXP_BASE wxOperatingSystemId
wxGetOsVersion(int *majorVsn
= (int *) NULL
,
100 int *minorVsn
= (int *) NULL
);
102 // Get platform endianness
103 WXDLLIMPEXP_BASE
bool wxIsPlatformLittleEndian();
105 // Get platform architecture
106 WXDLLIMPEXP_BASE
bool wxIsPlatform64Bit();
108 // Return a string with the current date/time
109 WXDLLIMPEXP_BASE wxString
wxNow();
111 // Return path where wxWidgets is installed (mostly useful in Unices)
112 WXDLLIMPEXP_BASE
const wxChar
*wxGetInstallPrefix();
113 // Return path to wxWin data (/usr/share/wx/%{version}) (Unices)
114 WXDLLIMPEXP_BASE wxString
wxGetDataDir();
117 * Class to make it easier to specify platform-dependent values
120 * long val = wxPlatform::If(wxMac, 1).ElseIf(wxGTK, 2).ElseIf(stPDA, 5).Else(3);
121 * wxString strVal = wxPlatform::If(wxMac, wxT("Mac")).ElseIf(wxMSW, wxT("MSW")).Else(wxT("Other"));
123 * A custom platform symbol:
127 * wxPlatform::AddPlatform(stPDA);
130 * long windowStyle = wxCAPTION | (long) wxPlatform::IfNot(stPDA, wxRESIZE_BORDER);
134 class WXDLLIMPEXP_BASE wxPlatform
137 wxPlatform() { Init(); }
138 wxPlatform(const wxPlatform
& platform
) { Copy(platform
); }
139 void operator = (const wxPlatform
& platform
) { if (&platform
!= this) Copy(platform
); }
140 void Copy(const wxPlatform
& platform
);
142 // Specify an optional default value
143 wxPlatform(int defValue
) { Init(); m_longValue
= (long)defValue
; }
144 wxPlatform(long defValue
) { Init(); m_longValue
= defValue
; }
145 wxPlatform(const wxString
& defValue
) { Init(); m_stringValue
= defValue
; }
146 wxPlatform(double defValue
) { Init(); m_doubleValue
= defValue
; }
148 static wxPlatform
If(int platform
, long value
);
149 static wxPlatform
IfNot(int platform
, long value
);
150 wxPlatform
& ElseIf(int platform
, long value
);
151 wxPlatform
& ElseIfNot(int platform
, long value
);
152 wxPlatform
& Else(long value
);
154 static wxPlatform
If(int platform
, int value
) { return If(platform
, (long)value
); }
155 static wxPlatform
IfNot(int platform
, int value
) { return IfNot(platform
, (long)value
); }
156 wxPlatform
& ElseIf(int platform
, int value
) { return ElseIf(platform
, (long) value
); }
157 wxPlatform
& ElseIfNot(int platform
, int value
) { return ElseIfNot(platform
, (long) value
); }
158 wxPlatform
& Else(int value
) { return Else((long) value
); }
160 static wxPlatform
If(int platform
, double value
);
161 static wxPlatform
IfNot(int platform
, double value
);
162 wxPlatform
& ElseIf(int platform
, double value
);
163 wxPlatform
& ElseIfNot(int platform
, double value
);
164 wxPlatform
& Else(double value
);
166 static wxPlatform
If(int platform
, const wxString
& value
);
167 static wxPlatform
IfNot(int platform
, const wxString
& value
);
168 wxPlatform
& ElseIf(int platform
, const wxString
& value
);
169 wxPlatform
& ElseIfNot(int platform
, const wxString
& value
);
170 wxPlatform
& Else(const wxString
& value
);
172 long GetInteger() const { return m_longValue
; }
173 const wxString
& GetString() const { return m_stringValue
; }
174 double GetDouble() const { return m_doubleValue
; }
176 operator int() const { return (int) GetInteger(); }
177 operator long() const { return GetInteger(); }
178 operator double() const { return GetDouble(); }
179 operator const wxString
&() const { return GetString(); }
181 static void AddPlatform(int platform
);
182 static bool Is(int platform
);
183 static void ClearPlatforms();
187 void Init() { m_longValue
= 0; m_doubleValue
= 0.0; }
190 double m_doubleValue
;
191 wxString m_stringValue
;
192 static wxArrayInt
* sm_customPlatforms
;
195 /// Function for testing current platform
196 inline bool wxPlatformIs(int platform
) { return wxPlatform::Is(platform
); }
200 // Get the state of a key (true if pressed, false if not)
201 // This is generally most useful getting the state of
202 // the modifier or toggle keys.
203 WXDLLIMPEXP_CORE
bool wxGetKeyState(wxKeyCode key
);
206 // Don't synthesize KeyUp events holding down a key and producing
207 // KeyDown events with autorepeat. On by default and always on
209 WXDLLIMPEXP_CORE
bool wxSetDetectableAutoRepeat( bool flag
);
212 // wxMouseState is used to hold information about button and modifier state
213 // and is what is returned from wxGetMouseState.
214 class WXDLLIMPEXP_CORE wxMouseState
219 m_leftDown(false), m_middleDown(false), m_rightDown(false),
220 m_aux1Down(false), m_aux2Down(false),
221 m_controlDown(false), m_shiftDown(false), m_altDown(false),
225 wxCoord
GetX() const { return m_x
; }
226 wxCoord
GetY() const { return m_y
; }
228 bool LeftDown() const { return m_leftDown
; }
229 bool MiddleDown() const { return m_middleDown
; }
230 bool RightDown() const { return m_rightDown
; }
231 bool Aux1Down() const { return m_aux1Down
; }
232 bool Aux2Down() const { return m_aux2Down
; }
234 bool ControlDown() const { return m_controlDown
; }
235 bool ShiftDown() const { return m_shiftDown
; }
236 bool AltDown() const { return m_altDown
; }
237 bool MetaDown() const { return m_metaDown
; }
240 #if defined(__WXMAC__) || defined(__WXCOCOA__)
243 return ControlDown();
247 void SetX(wxCoord x
) { m_x
= x
; }
248 void SetY(wxCoord y
) { m_y
= y
; }
250 void SetLeftDown(bool down
) { m_leftDown
= down
; }
251 void SetMiddleDown(bool down
) { m_middleDown
= down
; }
252 void SetRightDown(bool down
) { m_rightDown
= down
; }
253 void SetAux1Down(bool down
) { m_aux1Down
= down
; }
254 void SetAux2Down(bool down
) { m_aux2Down
= down
; }
256 void SetControlDown(bool down
) { m_controlDown
= down
; }
257 void SetShiftDown(bool down
) { m_shiftDown
= down
; }
258 void SetAltDown(bool down
) { m_altDown
= down
; }
259 void SetMetaDown(bool down
) { m_metaDown
= down
; }
266 bool m_middleDown
: 1;
267 bool m_rightDown
: 1;
271 bool m_controlDown
: 1;
272 bool m_shiftDown
: 1;
278 // Returns the current state of the mouse position, buttons and modifers
279 WXDLLIMPEXP_CORE wxMouseState
wxGetMouseState();
283 // ----------------------------------------------------------------------------
284 // Window ID management
285 // ----------------------------------------------------------------------------
287 // Ensure subsequent IDs don't clash with this one
288 WXDLLIMPEXP_BASE
void wxRegisterId(long id
);
290 // Return the current ID
291 WXDLLIMPEXP_BASE
long wxGetCurrentId();
293 // Generate a unique ID
294 WXDLLIMPEXP_BASE
long wxNewId();
296 // ----------------------------------------------------------------------------
297 // Various conversions
298 // ----------------------------------------------------------------------------
300 // Convert 2-digit hex number to decimal
301 WXDLLIMPEXP_BASE
int wxHexToDec(const wxString
& buf
);
303 // Convert decimal integer to 2-character hex string
304 WXDLLIMPEXP_BASE
void wxDecToHex(int dec
, wxChar
*buf
);
305 WXDLLIMPEXP_BASE
void wxDecToHex(int dec
, char* ch1
, char* ch2
);
306 WXDLLIMPEXP_BASE wxString
wxDecToHex(int dec
);
308 // ----------------------------------------------------------------------------
309 // Process management
310 // ----------------------------------------------------------------------------
312 // NB: for backwards compatibility reasons the values of wxEXEC_[A]SYNC *must*
313 // be 0 and 1, don't change!
317 // execute the process asynchronously
320 // execute it synchronously, i.e. wait until it finishes
323 // under Windows, don't hide the child even if it's IO is redirected (this
324 // is done by default)
327 // under Unix, if the process is the group leader then passing wxKILL_CHILDREN to wxKill
328 // kills all children as well as pid
329 wxEXEC_MAKE_GROUP_LEADER
= 4,
331 // by default synchronous execution disables all program windows to avoid
332 // that the user interacts with the program while the child process is
333 // running, you can use this flag to prevent this from happening
334 wxEXEC_NODISABLE
= 8,
336 // by default, the event loop is run while waiting for synchronous execution
337 // to complete and this flag can be used to simply block the main process
338 // until the child process finishes
339 wxEXEC_NOEVENTS
= 16,
341 // convenient synonym for flags given system()-like behaviour
342 wxEXEC_BLOCK
= wxEXEC_SYNC
| wxEXEC_NOEVENTS
345 // Execute another program.
347 // If flags contain wxEXEC_SYNC, return -1 on failure and the exit code of the
348 // process if everything was ok. Otherwise (i.e. if wxEXEC_ASYNC), return 0 on
349 // failure and the PID of the launched process if ok.
350 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
,
351 int flags
= wxEXEC_ASYNC
,
352 wxProcess
*process
= NULL
);
353 WXDLLIMPEXP_BASE
long wxExecute(char **argv
,
354 int flags
= wxEXEC_ASYNC
,
355 wxProcess
*process
= NULL
);
357 WXDLLIMPEXP_BASE
long wxExecute(wchar_t **argv
,
358 int flags
= wxEXEC_ASYNC
,
359 wxProcess
*process
= NULL
);
360 #endif // wxUSE_UNICODE
362 // execute the command capturing its output into an array line by line, this is
363 // always synchronous
364 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
,
365 wxArrayString
& output
,
368 // also capture stderr (also synchronous)
369 WXDLLIMPEXP_BASE
long wxExecute(const wxString
& command
,
370 wxArrayString
& output
,
371 wxArrayString
& error
,
374 #if defined(__WXMSW__) && wxUSE_IPC
375 // ask a DDE server to execute the DDE request with given parameters
376 WXDLLIMPEXP_BASE
bool wxExecuteDDE(const wxString
& ddeServer
,
377 const wxString
& ddeTopic
,
378 const wxString
& ddeCommand
);
379 #endif // __WXMSW__ && wxUSE_IPC
383 wxSIGNONE
= 0, // verify if the process exists under Unix
390 wxSIGIOT
= wxSIGABRT
, // another name
401 // further signals are different in meaning between different Unix systems
406 wxKILL_OK
, // no error
407 wxKILL_BAD_SIGNAL
, // no such signal
408 wxKILL_ACCESS_DENIED
, // permission denied
409 wxKILL_NO_PROCESS
, // no such process
410 wxKILL_ERROR
// another, unspecified error
415 wxKILL_NOCHILDREN
= 0, // don't kill children
416 wxKILL_CHILDREN
= 1 // kill children
421 wxSHUTDOWN_POWEROFF
, // power off the computer
422 wxSHUTDOWN_REBOOT
// shutdown and reboot
425 // Shutdown or reboot the PC
426 WXDLLIMPEXP_BASE
bool wxShutdown(wxShutdownFlags wFlags
);
428 // send the given signal to the process (only NONE and KILL are supported under
429 // Windows, all others mean TERM), return 0 if ok and -1 on error
431 // return detailed error in rc if not NULL
432 WXDLLIMPEXP_BASE
int wxKill(long pid
,
433 wxSignal sig
= wxSIGTERM
,
434 wxKillError
*rc
= NULL
,
435 int flags
= wxKILL_NOCHILDREN
);
437 // Execute a command in an interactive shell window (always synchronously)
438 // If no command then just the shell
439 WXDLLIMPEXP_BASE
bool wxShell(const wxString
& command
= wxEmptyString
);
441 // As wxShell(), but must give a (non interactive) command and its output will
442 // be returned in output array
443 WXDLLIMPEXP_BASE
bool wxShell(const wxString
& command
, wxArrayString
& output
);
445 // Sleep for nSecs seconds
446 WXDLLIMPEXP_BASE
void wxSleep(int nSecs
);
448 // Sleep for a given amount of milliseconds
449 WXDLLIMPEXP_BASE
void wxMilliSleep(unsigned long milliseconds
);
451 // Sleep for a given amount of microseconds
452 WXDLLIMPEXP_BASE
void wxMicroSleep(unsigned long microseconds
);
454 // Sleep for a given amount of milliseconds (old, bad name), use wxMilliSleep
455 wxDEPRECATED( WXDLLIMPEXP_BASE
void wxUsleep(unsigned long milliseconds
) );
457 // Get the process id of the current process
458 WXDLLIMPEXP_BASE
unsigned long wxGetProcessId();
460 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
461 WXDLLIMPEXP_BASE wxMemorySize
wxGetFreeMemory();
463 #if wxUSE_ON_FATAL_EXCEPTION
465 // should wxApp::OnFatalException() be called?
466 WXDLLIMPEXP_BASE
bool wxHandleFatalExceptions(bool doit
= true);
468 #endif // wxUSE_ON_FATAL_EXCEPTION
470 // ----------------------------------------------------------------------------
471 // Environment variables
472 // ----------------------------------------------------------------------------
474 // returns true if variable exists (value may be NULL if you just want to check
476 WXDLLIMPEXP_BASE
bool wxGetEnv(const wxString
& var
, wxString
*value
);
478 // set the env var name to the given value, return true on success
479 WXDLLIMPEXP_BASE
bool wxSetEnv(const wxString
& var
, const wxString
& value
);
481 // remove the env var from environment
482 WXDLLIMPEXP_BASE
bool wxUnsetEnv(const wxString
& var
);
484 #if WXWIN_COMPATIBILITY_2_8
485 inline bool wxSetEnv(const wxString
& var
, const char *value
)
486 { return wxSetEnv(var
, wxString(value
)); }
487 inline bool wxSetEnv(const wxString
& var
, const wchar_t *value
)
488 { return wxSetEnv(var
, wxString(value
)); }
490 inline bool wxSetEnv(const wxString
& var
, const wxCharTypeBuffer
<T
>& value
)
491 { return wxSetEnv(var
, wxString(value
)); }
492 inline bool wxSetEnv(const wxString
& var
, const wxCStrData
& value
)
493 { return wxSetEnv(var
, wxString(value
)); }
495 // this one is for passing NULL directly - don't use it, use wxUnsetEnv instead
496 wxDEPRECATED( inline bool wxSetEnv(const wxString
& var
, int value
) );
497 inline bool wxSetEnv(const wxString
& var
, int value
)
499 wxASSERT_MSG( value
== 0, "using non-NULL integer as string?" );
501 wxUnusedVar(value
); // fix unused parameter warning in release build
503 return wxUnsetEnv(var
);
505 #endif // WXWIN_COMPATIBILITY_2_8
507 // ----------------------------------------------------------------------------
508 // Network and username functions.
509 // ----------------------------------------------------------------------------
511 // NB: "char *" functions are deprecated, use wxString ones!
514 WXDLLIMPEXP_BASE
bool wxGetEmailAddress(wxChar
*buf
, int maxSize
);
515 WXDLLIMPEXP_BASE wxString
wxGetEmailAddress();
518 WXDLLIMPEXP_BASE
bool wxGetHostName(wxChar
*buf
, int maxSize
);
519 WXDLLIMPEXP_BASE wxString
wxGetHostName();
522 WXDLLIMPEXP_BASE wxString
wxGetFullHostName();
523 WXDLLIMPEXP_BASE
bool wxGetFullHostName(wxChar
*buf
, int maxSize
);
525 // Get user ID e.g. jacs (this is known as login name under Unix)
526 WXDLLIMPEXP_BASE
bool wxGetUserId(wxChar
*buf
, int maxSize
);
527 WXDLLIMPEXP_BASE wxString
wxGetUserId();
529 // Get user name e.g. Julian Smart
530 WXDLLIMPEXP_BASE
bool wxGetUserName(wxChar
*buf
, int maxSize
);
531 WXDLLIMPEXP_BASE wxString
wxGetUserName();
533 // Get current Home dir and copy to dest (returns pstr->c_str())
534 WXDLLIMPEXP_BASE wxString
wxGetHomeDir();
535 WXDLLIMPEXP_BASE
const wxChar
* wxGetHomeDir(wxString
*pstr
);
537 // Get the user's (by default use the current user name) home dir,
538 // return empty string on error
539 WXDLLIMPEXP_BASE wxString
wxGetUserHome(const wxString
& user
= wxEmptyString
);
543 typedef wxLongLong wxDiskspaceSize_t
;
545 typedef long wxDiskspaceSize_t
;
548 // get number of total/free bytes on the disk where path belongs
549 WXDLLIMPEXP_BASE
bool wxGetDiskSpace(const wxString
& path
,
550 wxDiskspaceSize_t
*pTotal
= NULL
,
551 wxDiskspaceSize_t
*pFree
= NULL
);
557 typedef int (wxCMPFUNC_CONV
*CMPFUNCDATA
)(const void* pItem1
, const void* pItem2
, const void* user_data
);
561 WXDLLIMPEXP_BASE
void wxQsort(void *const pbase
, size_t total_elems
,
562 size_t size
, CMPFUNCDATA cmp
, const void* user_data
);
565 #if wxUSE_GUI // GUI only things from now on
567 // ----------------------------------------------------------------------------
568 // Launch default browser
569 // ----------------------------------------------------------------------------
571 // flags for wxLaunchDefaultBrowser
574 wxBROWSER_NEW_WINDOW
= 1
577 // Launch url in the user's default internet browser
578 WXDLLIMPEXP_CORE
bool wxLaunchDefaultBrowser(const wxString
& url
, int flags
= 0);
580 // ----------------------------------------------------------------------------
581 // Menu accelerators related things
582 // ----------------------------------------------------------------------------
584 // flags for wxStripMenuCodes
587 // strip '&' characters
588 wxStrip_Mnemonics
= 1,
590 // strip everything after '\t'
593 // strip everything (this is the default)
594 wxStrip_All
= wxStrip_Mnemonics
| wxStrip_Accel
597 // strip mnemonics and/or accelerators from the label
598 WXDLLIMPEXP_CORE wxString
599 wxStripMenuCodes(const wxString
& str
, int flags
= wxStrip_All
);
601 #if WXWIN_COMPATIBILITY_2_6
602 // obsolete and deprecated version, do not use, use the above overload instead
604 WXDLLIMPEXP_CORE wxChar
* wxStripMenuCodes(const wxChar
*in
, wxChar
*out
= NULL
)
608 class WXDLLIMPEXP_FWD_CORE wxAcceleratorEntry
;
610 // use wxAcceleratorEntry::Create() or FromString() methods instead
612 WXDLLIMPEXP_CORE wxAcceleratorEntry
*wxGetAccelFromString(const wxString
& label
)
614 #endif // wxUSE_ACCEL
616 #endif // WXWIN_COMPATIBILITY_2_6
618 // ----------------------------------------------------------------------------
620 // ----------------------------------------------------------------------------
622 // Returns menu item id or wxNOT_FOUND if none.
623 WXDLLIMPEXP_CORE
int wxFindMenuItemId(wxFrame
*frame
, const wxString
& menuString
, const wxString
& itemString
);
625 // Find the wxWindow at the given point. wxGenericFindWindowAtPoint
626 // is always present but may be less reliable than a native version.
627 WXDLLIMPEXP_CORE wxWindow
* wxGenericFindWindowAtPoint(const wxPoint
& pt
);
628 WXDLLIMPEXP_CORE wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
);
630 // NB: this function is obsolete, use wxWindow::FindWindowByLabel() instead
632 // Find the window/widget with the given title or label.
633 // Pass a parent to begin the search from, or NULL to look through
635 WXDLLIMPEXP_CORE wxWindow
* wxFindWindowByLabel(const wxString
& title
, wxWindow
*parent
= (wxWindow
*) NULL
);
637 // NB: this function is obsolete, use wxWindow::FindWindowByName() instead
639 // Find window by name, and if that fails, by label.
640 WXDLLIMPEXP_CORE wxWindow
* wxFindWindowByName(const wxString
& name
, wxWindow
*parent
= (wxWindow
*) NULL
);
642 // ----------------------------------------------------------------------------
643 // Message/event queue helpers
644 // ----------------------------------------------------------------------------
646 // Yield to other apps/messages and disable user input
647 WXDLLIMPEXP_CORE
bool wxSafeYield(wxWindow
*win
= NULL
, bool onlyIfNeeded
= false);
649 // Enable or disable input to all top level windows
650 WXDLLIMPEXP_CORE
void wxEnableTopLevelWindows(bool enable
= true);
652 // Check whether this window wants to process messages, e.g. Stop button
653 // in long calculations.
654 WXDLLIMPEXP_CORE
bool wxCheckForInterrupt(wxWindow
*wnd
);
656 // Consume all events until no more left
657 WXDLLIMPEXP_CORE
void wxFlushEvents();
659 // a class which disables all windows (except, may be, the given one) in its
660 // ctor and enables them back in its dtor
661 class WXDLLIMPEXP_CORE wxWindowDisabler
664 // this ctor conditionally disables all windows: if the argument is false,
665 // it doesn't do anything
666 wxWindowDisabler(bool disable
= true);
668 // ctor disables all windows except winToSkip
669 wxWindowDisabler(wxWindow
*winToSkip
);
671 // dtor enables back all windows disabled by the ctor
675 // disable all windows except the given one (used by both ctors)
676 void DoDisable(wxWindow
*winToSkip
= NULL
);
679 wxWindowList
*m_winDisabled
;
682 DECLARE_NO_COPY_CLASS(wxWindowDisabler
)
685 // ----------------------------------------------------------------------------
687 // ----------------------------------------------------------------------------
689 // Set the cursor to the busy cursor for all windows
690 WXDLLIMPEXP_CORE
void wxBeginBusyCursor(const wxCursor
*cursor
= wxHOURGLASS_CURSOR
);
692 // Restore cursor to normal
693 WXDLLIMPEXP_CORE
void wxEndBusyCursor();
695 // true if we're between the above two calls
696 WXDLLIMPEXP_CORE
bool wxIsBusy();
698 // Convenience class so we can just create a wxBusyCursor object on the stack
699 class WXDLLIMPEXP_CORE wxBusyCursor
702 wxBusyCursor(const wxCursor
* cursor
= wxHOURGLASS_CURSOR
)
703 { wxBeginBusyCursor(cursor
); }
705 { wxEndBusyCursor(); }
707 // FIXME: These two methods are currently only implemented (and needed?)
708 // in wxGTK. BusyCursor handling should probably be moved to
709 // common code since the wxGTK and wxMSW implementations are very
710 // similar except for wxMSW using HCURSOR directly instead of
712 static const wxCursor
&GetStoredCursor();
713 static const wxCursor
GetBusyCursor();
716 void WXDLLIMPEXP_CORE
wxGetMousePosition( int* x
, int* y
);
718 // MSW only: get user-defined resource from the .res file.
719 // Returns NULL or newly-allocated memory, so use delete[] to clean up.
721 extern WXDLLIMPEXP_CORE
const wxChar
* wxUserResourceStr
;
722 WXDLLIMPEXP_CORE wxChar
* wxLoadUserResource(const wxString
& resourceName
, const wxString
& resourceType
= wxUserResourceStr
);
725 // ----------------------------------------------------------------------------
726 // X11 Display access
727 // ----------------------------------------------------------------------------
729 #if defined(__X__) || defined(__WXGTK__)
732 WXDLLIMPEXP_CORE
void *wxGetDisplay();
736 WXDLLIMPEXP_CORE WXDisplay
*wxGetDisplay();
737 WXDLLIMPEXP_CORE
bool wxSetDisplay(const wxString
& display_name
);
738 WXDLLIMPEXP_CORE wxString
wxGetDisplayName();
741 // use this function instead of the functions above in implementation code
742 inline struct _XDisplay
*wxGetX11Display()
744 return (_XDisplay
*)wxGetDisplay();
747 #endif // X11 || wxGTK
751 // ----------------------------------------------------------------------------
752 // wxYield(): these functions are obsolete, please use wxApp methods instead!
753 // ----------------------------------------------------------------------------
755 // avoid redeclaring this function here if it had been already declated by
756 // wx/app.h, this results in warnings from g++ with -Wredundant-decls
757 #ifndef wx_YIELD_DECLARED
758 #define wx_YIELD_DECLARED
760 // Yield to other apps/messages
761 WXDLLIMPEXP_BASE
bool wxYield();
763 #endif // wx_YIELD_DECLARED
765 // Like wxYield, but fails silently if the yield is recursive.
766 WXDLLIMPEXP_BASE
bool wxYieldIfNeeded();
768 // ----------------------------------------------------------------------------
769 // Error message functions used by wxWidgets (deprecated, use wxLog)
770 // ----------------------------------------------------------------------------