]>
Commit | Line | Data |
---|---|---|
c801d85f KB |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: utilscmn.cpp | |
3 | // Purpose: Miscellaneous utility functions and classes | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 29/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998 Julian Smart | |
65571936 | 9 | // Licence: wxWindows licence |
c801d85f KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
e90c1d2a VZ |
12 | // ============================================================================ |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
e4844687 SN |
20 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && !defined(__EMX__) |
21 | // Some older compilers (such as EMX) cannot handle | |
13d13a9e | 22 | // #pragma interface/implementation correctly, iff |
e4844687 SN |
23 | // #pragma implementation is used in _two_ translation |
24 | // units (as created by e.g. event.cpp compiled for | |
25 | // libwx_base and event.cpp compiled for libwx_gui_core). | |
26 | // So we must not use those pragmas for those compilers in | |
27 | // such files. | |
e90c1d2a | 28 | #pragma implementation "utils.h" |
c801d85f KB |
29 | #endif |
30 | ||
31 | // For compilers that support precompilation, includes "wx.h". | |
32 | #include "wx/wxprec.h" | |
33 | ||
34 | #ifdef __BORLANDC__ | |
e90c1d2a | 35 | #pragma hdrstop |
c801d85f KB |
36 | #endif |
37 | ||
38 | #ifndef WX_PRECOMP | |
fcdb9b38 | 39 | #include "wx/app.h" |
e90c1d2a VZ |
40 | #include "wx/string.h" |
41 | #include "wx/utils.h" | |
974e8d94 VZ |
42 | #include "wx/intl.h" |
43 | #include "wx/log.h" | |
e90c1d2a VZ |
44 | |
45 | #if wxUSE_GUI | |
46 | #include "wx/window.h" | |
e90c1d2a | 47 | #include "wx/frame.h" |
1e6feb95 | 48 | #include "wx/menu.h" |
e90c1d2a VZ |
49 | #include "wx/msgdlg.h" |
50 | #include "wx/textdlg.h" | |
78bcfcfc | 51 | #include "wx/textctrl.h" // for wxTE_PASSWORD |
974e8d94 VZ |
52 | #if wxUSE_ACCEL |
53 | #include "wx/menuitem.h" | |
54 | #include "wx/accel.h" | |
55 | #endif // wxUSE_ACCEL | |
e90c1d2a VZ |
56 | #endif // wxUSE_GUI |
57 | #endif // WX_PRECOMP | |
c801d85f | 58 | |
2739d4f0 VZ |
59 | #include "wx/apptrait.h" |
60 | ||
cd6ce4a9 VZ |
61 | #include "wx/process.h" |
62 | #include "wx/txtstrm.h" | |
498a1eeb RN |
63 | #include "wx/uri.h" |
64 | #include "wx/mimetype.h" | |
65 | #include "wx/config.h" | |
cd6ce4a9 | 66 | |
4676948b JS |
67 | #if defined(__WXWINCE__) && wxUSE_DATETIME |
68 | #include "wx/datetime.h" | |
69 | #endif | |
70 | ||
c801d85f KB |
71 | #include <ctype.h> |
72 | #include <stdio.h> | |
73 | #include <stdlib.h> | |
74 | #include <string.h> | |
e90c1d2a | 75 | |
c801d85f | 76 | #if !defined(__WATCOMC__) |
3f4a0c5b VZ |
77 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) |
78 | #include <errno.h> | |
79 | #endif | |
c801d85f | 80 | #endif |
e90c1d2a | 81 | |
91b4c08d VZ |
82 | #if wxUSE_GUI |
83 | #include "wx/colordlg.h" | |
bf31fa26 | 84 | #include "wx/fontdlg.h" |
d1c8aaa3 JS |
85 | #include "wx/notebook.h" |
86 | #include "wx/frame.h" | |
87 | #include "wx/statusbr.h" | |
91b4c08d VZ |
88 | #endif // wxUSE_GUI |
89 | ||
1c193821 | 90 | #ifndef __WXWINCE__ |
c801d85f | 91 | #include <time.h> |
1c193821 JS |
92 | #else |
93 | #include "wx/msw/wince/time.h" | |
94 | #endif | |
e90c1d2a | 95 | |
4676948b | 96 | #if !defined(__MWERKS__) && !defined(__WXWINCE__) |
e90c1d2a VZ |
97 | #include <sys/types.h> |
98 | #include <sys/stat.h> | |
469e1e5c | 99 | #endif |
c801d85f | 100 | |
82ef81ed | 101 | #if defined(__WXMSW__) |
5e1febfa | 102 | #include "wx/msw/private.h" |
c801d85f KB |
103 | #endif |
104 | ||
ec67cff1 | 105 | #if wxUSE_BASE |
7c072018 | 106 | |
73deed44 VZ |
107 | // ---------------------------------------------------------------------------- |
108 | // common data | |
109 | // ---------------------------------------------------------------------------- | |
110 | ||
111 | #if WXWIN_COMPATIBILITY_2_2 | |
77ffb593 JS |
112 | const wxChar *wxInternalErrorStr = wxT("wxWidgets Internal Error"); |
113 | const wxChar *wxFatalErrorStr = wxT("wxWidgets Fatal Error"); | |
73deed44 VZ |
114 | #endif // WXWIN_COMPATIBILITY_2_2 |
115 | ||
e90c1d2a VZ |
116 | // ============================================================================ |
117 | // implementation | |
118 | // ============================================================================ | |
c801d85f | 119 | |
7c072018 VZ |
120 | #if WXWIN_COMPATIBILITY_2_4 |
121 | ||
0080691b OK |
122 | wxChar * |
123 | copystring (const wxChar *s) | |
c801d85f | 124 | { |
657a7545 WS |
125 | if (s == NULL) s = wxEmptyString; |
126 | size_t len = wxStrlen (s) + 1; | |
c801d85f | 127 | |
657a7545 WS |
128 | wxChar *news = new wxChar[len]; |
129 | memcpy (news, s, len * sizeof(wxChar)); // Should be the fastest | |
c801d85f | 130 | |
657a7545 | 131 | return news; |
c801d85f KB |
132 | } |
133 | ||
7c072018 VZ |
134 | #endif // WXWIN_COMPATIBILITY_2_4 |
135 | ||
e12c92c2 VZ |
136 | // ---------------------------------------------------------------------------- |
137 | // String <-> Number conversions (deprecated) | |
138 | // ---------------------------------------------------------------------------- | |
139 | ||
140 | #if WXWIN_COMPATIBILITY_2_4 | |
141 | ||
fd242375 VS |
142 | WXDLLIMPEXP_DATA_BASE(const wxChar *) wxFloatToStringStr = wxT("%.2f"); |
143 | WXDLLIMPEXP_DATA_BASE(const wxChar *) wxDoubleToStringStr = wxT("%.2f"); | |
e12c92c2 | 144 | |
3f4a0c5b | 145 | void |
bc87fd68 | 146 | StringToFloat (const wxChar *s, float *number) |
c801d85f | 147 | { |
657a7545 WS |
148 | if (s && *s && number) |
149 | *number = (float) wxStrtod (s, (wxChar **) NULL); | |
c801d85f KB |
150 | } |
151 | ||
3f4a0c5b | 152 | void |
bc87fd68 | 153 | StringToDouble (const wxChar *s, double *number) |
c801d85f | 154 | { |
657a7545 WS |
155 | if (s && *s && number) |
156 | *number = wxStrtod (s, (wxChar **) NULL); | |
c801d85f KB |
157 | } |
158 | ||
0080691b OK |
159 | wxChar * |
160 | FloatToString (float number, const wxChar *fmt) | |
c801d85f | 161 | { |
657a7545 | 162 | static wxChar buf[256]; |
c801d85f | 163 | |
657a7545 WS |
164 | wxSprintf (buf, fmt, number); |
165 | return buf; | |
c801d85f KB |
166 | } |
167 | ||
0080691b OK |
168 | wxChar * |
169 | DoubleToString (double number, const wxChar *fmt) | |
c801d85f | 170 | { |
657a7545 | 171 | static wxChar buf[256]; |
c801d85f | 172 | |
657a7545 WS |
173 | wxSprintf (buf, fmt, number); |
174 | return buf; | |
c801d85f KB |
175 | } |
176 | ||
3f4a0c5b | 177 | void |
bc87fd68 | 178 | StringToInt (const wxChar *s, int *number) |
c801d85f | 179 | { |
657a7545 WS |
180 | if (s && *s && number) |
181 | *number = (int) wxStrtol (s, (wxChar **) NULL, 10); | |
c801d85f KB |
182 | } |
183 | ||
3f4a0c5b | 184 | void |
bc87fd68 | 185 | StringToLong (const wxChar *s, long *number) |
c801d85f | 186 | { |
657a7545 WS |
187 | if (s && *s && number) |
188 | *number = wxStrtol (s, (wxChar **) NULL, 10); | |
c801d85f KB |
189 | } |
190 | ||
84fff0b3 | 191 | wxChar * |
c801d85f KB |
192 | IntToString (int number) |
193 | { | |
657a7545 | 194 | static wxChar buf[20]; |
c801d85f | 195 | |
657a7545 WS |
196 | wxSprintf (buf, wxT("%d"), number); |
197 | return buf; | |
c801d85f KB |
198 | } |
199 | ||
84fff0b3 | 200 | wxChar * |
c801d85f KB |
201 | LongToString (long number) |
202 | { | |
657a7545 | 203 | static wxChar buf[20]; |
c801d85f | 204 | |
657a7545 WS |
205 | wxSprintf (buf, wxT("%ld"), number); |
206 | return buf; | |
c801d85f KB |
207 | } |
208 | ||
e12c92c2 VZ |
209 | #endif // WXWIN_COMPATIBILITY_2_4 |
210 | ||
c801d85f | 211 | // Array used in DecToHex conversion routine. |
223d09f6 | 212 | static wxChar hexArray[] = wxT("0123456789ABCDEF"); |
c801d85f KB |
213 | |
214 | // Convert 2-digit hex number to decimal | |
fd71308f | 215 | int wxHexToDec(const wxString& buf) |
c801d85f | 216 | { |
657a7545 | 217 | int firstDigit, secondDigit; |
3f4a0c5b | 218 | |
657a7545 WS |
219 | if (buf.GetChar(0) >= wxT('A')) |
220 | firstDigit = buf.GetChar(0) - wxT('A') + 10; | |
221 | else | |
222 | firstDigit = buf.GetChar(0) - wxT('0'); | |
c801d85f | 223 | |
657a7545 WS |
224 | if (buf.GetChar(1) >= wxT('A')) |
225 | secondDigit = buf.GetChar(1) - wxT('A') + 10; | |
226 | else | |
227 | secondDigit = buf.GetChar(1) - wxT('0'); | |
3f4a0c5b | 228 | |
657a7545 | 229 | return (firstDigit & 0xF) * 16 + (secondDigit & 0xF ); |
c801d85f KB |
230 | } |
231 | ||
232 | // Convert decimal integer to 2-character hex string | |
84fff0b3 | 233 | void wxDecToHex(int dec, wxChar *buf) |
c801d85f | 234 | { |
657a7545 WS |
235 | int firstDigit = (int)(dec/16.0); |
236 | int secondDigit = (int)(dec - (firstDigit*16.0)); | |
237 | buf[0] = hexArray[firstDigit]; | |
238 | buf[1] = hexArray[secondDigit]; | |
239 | buf[2] = 0; | |
c801d85f KB |
240 | } |
241 | ||
fd71308f JS |
242 | // Convert decimal integer to 2-character hex string |
243 | wxString wxDecToHex(int dec) | |
244 | { | |
84fff0b3 | 245 | wxChar buf[3]; |
fd71308f JS |
246 | wxDecToHex(dec, buf); |
247 | return wxString(buf); | |
248 | } | |
249 | ||
7c072018 VZ |
250 | // ---------------------------------------------------------------------------- |
251 | // misc functions | |
252 | // ---------------------------------------------------------------------------- | |
c801d85f KB |
253 | |
254 | // Return the current date/time | |
e90c1d2a | 255 | wxString wxNow() |
c801d85f | 256 | { |
4676948b JS |
257 | #ifdef __WXWINCE__ |
258 | #if wxUSE_DATETIME | |
259 | wxDateTime now = wxDateTime::Now(); | |
260 | return now.Format(); | |
261 | #else | |
262 | return wxEmptyString; | |
263 | #endif | |
264 | #else | |
2b5f62a0 VZ |
265 | time_t now = time((time_t *) NULL); |
266 | char *date = ctime(&now); | |
267 | date[24] = '\0'; | |
268 | return wxString::FromAscii(date); | |
4676948b | 269 | #endif |
c801d85f KB |
270 | } |
271 | ||
08873d36 VZ |
272 | void wxUsleep(unsigned long milliseconds) |
273 | { | |
274 | wxMilliSleep(milliseconds); | |
275 | } | |
276 | ||
7c072018 VZ |
277 | const wxChar *wxGetInstallPrefix() |
278 | { | |
279 | wxString prefix; | |
280 | ||
281 | if ( wxGetEnv(wxT("WXPREFIX"), &prefix) ) | |
282 | return prefix.c_str(); | |
283 | ||
284 | #ifdef wxINSTALL_PREFIX | |
285 | return wxT(wxINSTALL_PREFIX); | |
286 | #else | |
525d8583 | 287 | return wxEmptyString; |
7c072018 VZ |
288 | #endif |
289 | } | |
290 | ||
291 | wxString wxGetDataDir() | |
292 | { | |
10f206ad RL |
293 | wxString dir = wxGetInstallPrefix(); |
294 | dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx"); | |
7c072018 VZ |
295 | return dir; |
296 | } | |
e90c1d2a | 297 | |
2739d4f0 VZ |
298 | int wxGetOsVersion(int *verMaj, int *verMin) |
299 | { | |
300 | // we want this function to work even if there is no wxApp | |
301 | wxConsoleAppTraits traitsConsole; | |
302 | wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; | |
303 | if ( ! traits ) | |
304 | traits = &traitsConsole; | |
305 | ||
324899f6 | 306 | wxToolkitInfo& info = traits->GetToolkitInfo(); |
a8eaaeb2 | 307 | if ( verMaj ) |
324899f6 | 308 | *verMaj = info.versionMajor; |
a8eaaeb2 | 309 | if ( verMin ) |
324899f6 VS |
310 | *verMin = info.versionMinor; |
311 | return info.os; | |
2739d4f0 | 312 | } |
1e6feb95 | 313 | |
e90c1d2a | 314 | // ---------------------------------------------------------------------------- |
7c072018 | 315 | // network and user id functions |
e90c1d2a | 316 | // ---------------------------------------------------------------------------- |
c801d85f | 317 | |
7c072018 VZ |
318 | // Get Full RFC822 style email address |
319 | bool wxGetEmailAddress(wxChar *address, int maxSize) | |
c801d85f | 320 | { |
7c072018 VZ |
321 | wxString email = wxGetEmailAddress(); |
322 | if ( !email ) | |
cb719f2e | 323 | return false; |
c801d85f | 324 | |
7c072018 VZ |
325 | wxStrncpy(address, email, maxSize - 1); |
326 | address[maxSize - 1] = wxT('\0'); | |
327 | ||
cb719f2e | 328 | return true; |
c801d85f KB |
329 | } |
330 | ||
7c072018 | 331 | wxString wxGetEmailAddress() |
47bc1060 | 332 | { |
7c072018 | 333 | wxString email; |
974e8d94 | 334 | |
7c072018 | 335 | wxString host = wxGetFullHostName(); |
4055ed82 | 336 | if ( !host.empty() ) |
1e6feb95 | 337 | { |
7c072018 | 338 | wxString user = wxGetUserId(); |
4055ed82 | 339 | if ( !user.empty() ) |
1e6feb95 | 340 | { |
7c072018 | 341 | email << user << wxT('@') << host; |
974e8d94 | 342 | } |
974e8d94 VZ |
343 | } |
344 | ||
7c072018 | 345 | return email; |
974e8d94 VZ |
346 | } |
347 | ||
7c072018 | 348 | wxString wxGetUserId() |
c801d85f | 349 | { |
7c072018 | 350 | static const int maxLoginLen = 256; // FIXME arbitrary number |
c801d85f | 351 | |
7c072018 | 352 | wxString buf; |
4c3ebca9 | 353 | bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen); |
c801d85f | 354 | |
7c072018 VZ |
355 | if ( !ok ) |
356 | buf.Empty(); | |
c801d85f | 357 | |
7c072018 | 358 | return buf; |
c801d85f KB |
359 | } |
360 | ||
7c072018 | 361 | wxString wxGetUserName() |
c801d85f | 362 | { |
7c072018 | 363 | static const int maxUserNameLen = 1024; // FIXME arbitrary number |
1e6feb95 | 364 | |
7c072018 | 365 | wxString buf; |
4c3ebca9 | 366 | bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen); |
7c072018 VZ |
367 | |
368 | if ( !ok ) | |
369 | buf.Empty(); | |
370 | ||
371 | return buf; | |
59a12e90 JS |
372 | } |
373 | ||
7c072018 | 374 | wxString wxGetHostName() |
59a12e90 | 375 | { |
7c072018 | 376 | static const size_t hostnameSize = 257; |
c67d6888 | 377 | |
7c072018 | 378 | wxString buf; |
4c3ebca9 | 379 | bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); |
59a12e90 | 380 | |
7c072018 VZ |
381 | if ( !ok ) |
382 | buf.Empty(); | |
59a12e90 | 383 | |
7c072018 | 384 | return buf; |
59a12e90 JS |
385 | } |
386 | ||
7c072018 | 387 | wxString wxGetFullHostName() |
59a12e90 | 388 | { |
7c072018 | 389 | static const size_t hostnameSize = 257; |
c801d85f | 390 | |
7c072018 | 391 | wxString buf; |
4c3ebca9 | 392 | bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); |
7c072018 VZ |
393 | |
394 | if ( !ok ) | |
395 | buf.Empty(); | |
c801d85f | 396 | |
7c072018 VZ |
397 | return buf; |
398 | } | |
c801d85f | 399 | |
7c072018 VZ |
400 | wxString wxGetHomeDir() |
401 | { | |
402 | wxString home; | |
403 | wxGetHomeDir(&home); | |
c801d85f | 404 | |
7c072018 VZ |
405 | return home; |
406 | } | |
c801d85f | 407 | |
c801d85f KB |
408 | #if 0 |
409 | ||
7c072018 | 410 | wxString wxGetCurrentDir() |
c801d85f | 411 | { |
7c072018 VZ |
412 | wxString dir; |
413 | size_t len = 1024; | |
414 | bool ok; | |
415 | do | |
416 | { | |
417 | ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL; | |
418 | dir.UngetWriteBuf(); | |
c801d85f | 419 | |
7c072018 VZ |
420 | if ( !ok ) |
421 | { | |
422 | if ( errno != ERANGE ) | |
423 | { | |
424 | wxLogSysError(_T("Failed to get current directory")); | |
c801d85f | 425 | |
7c072018 VZ |
426 | return wxEmptyString; |
427 | } | |
3f4a0c5b | 428 | else |
7c072018 VZ |
429 | { |
430 | // buffer was too small, retry with a larger one | |
431 | len *= 2; | |
432 | } | |
3f4a0c5b | 433 | } |
7c072018 VZ |
434 | //else: ok |
435 | } while ( !ok ); | |
c801d85f | 436 | |
7c072018 | 437 | return dir; |
c801d85f KB |
438 | } |
439 | ||
7c072018 | 440 | #endif // 0 |
e90c1d2a VZ |
441 | |
442 | // ---------------------------------------------------------------------------- | |
7c072018 | 443 | // wxExecute |
e90c1d2a | 444 | // ---------------------------------------------------------------------------- |
ead7ce10 | 445 | |
7c072018 VZ |
446 | // wxDoExecuteWithCapture() helper: reads an entire stream into one array |
447 | // | |
cb719f2e | 448 | // returns true if ok, false if error |
7c072018 VZ |
449 | #if wxUSE_STREAMS |
450 | static bool ReadAll(wxInputStream *is, wxArrayString& output) | |
dfad0599 | 451 | { |
cb719f2e | 452 | wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") ); |
dfad0599 | 453 | |
7c072018 VZ |
454 | // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state |
455 | is->Reset(); | |
1e6feb95 | 456 | |
7c072018 | 457 | wxTextInputStream tis(*is); |
1e6feb95 | 458 | |
cb719f2e | 459 | bool cont = true; |
7c072018 | 460 | while ( cont ) |
d2f50933 | 461 | { |
7c072018 VZ |
462 | wxString line = tis.ReadLine(); |
463 | if ( is->Eof() ) | |
464 | break; | |
465 | ||
466 | if ( !*is ) | |
467 | { | |
cb719f2e | 468 | cont = false; |
7c072018 VZ |
469 | } |
470 | else | |
471 | { | |
472 | output.Add(line); | |
473 | } | |
d2f50933 VZ |
474 | } |
475 | ||
7c072018 | 476 | return cont; |
dfad0599 | 477 | } |
7c072018 | 478 | #endif // wxUSE_STREAMS |
d2f50933 | 479 | |
7c072018 VZ |
480 | // this is a private function because it hasn't a clean interface: the first |
481 | // array is passed by reference, the second by pointer - instead we have 2 | |
482 | // public versions of wxExecute() below | |
483 | static long wxDoExecuteWithCapture(const wxString& command, | |
484 | wxArrayString& output, | |
4d172154 VZ |
485 | wxArrayString* error, |
486 | int flags) | |
d2f50933 | 487 | { |
7c072018 VZ |
488 | // create a wxProcess which will capture the output |
489 | wxProcess *process = new wxProcess; | |
490 | process->Redirect(); | |
dfad0599 | 491 | |
4d172154 | 492 | long rc = wxExecute(command, wxEXEC_SYNC | flags, process); |
1e6feb95 | 493 | |
7c072018 VZ |
494 | #if wxUSE_STREAMS |
495 | if ( rc != -1 ) | |
bf31fa26 | 496 | { |
7c072018 VZ |
497 | if ( !ReadAll(process->GetInputStream(), output) ) |
498 | rc = -1; | |
91b4c08d | 499 | |
7c072018 VZ |
500 | if ( error ) |
501 | { | |
502 | if ( !ReadAll(process->GetErrorStream(), *error) ) | |
503 | rc = -1; | |
504 | } | |
91b4c08d | 505 | |
7c072018 | 506 | } |
e70ba80d WS |
507 | #else |
508 | wxUnusedVar(output); | |
509 | wxUnusedVar(error); | |
510 | #endif // wxUSE_STREAMS/!wxUSE_STREAMS | |
91b4c08d | 511 | |
7c072018 | 512 | delete process; |
1e6feb95 | 513 | |
7c072018 | 514 | return rc; |
7c072018 | 515 | } |
bf31fa26 | 516 | |
4d172154 | 517 | long wxExecute(const wxString& command, wxArrayString& output, int flags) |
bf31fa26 | 518 | { |
4d172154 | 519 | return wxDoExecuteWithCapture(command, output, NULL, flags); |
7c072018 | 520 | } |
bf31fa26 | 521 | |
7c072018 VZ |
522 | long wxExecute(const wxString& command, |
523 | wxArrayString& output, | |
4d172154 VZ |
524 | wxArrayString& error, |
525 | int flags) | |
7c072018 | 526 | { |
4d172154 | 527 | return wxDoExecuteWithCapture(command, output, &error, flags); |
bf31fa26 VZ |
528 | } |
529 | ||
498a1eeb RN |
530 | // ---------------------------------------------------------------------------- |
531 | // Launch default browser | |
532 | // ---------------------------------------------------------------------------- | |
533 | ||
534 | bool wxLaunchDefaultBrowser(const wxString& url) | |
535 | { | |
532d575b WS |
536 | bool success = true; |
537 | ||
498a1eeb RN |
538 | wxString finalurl = url; |
539 | ||
540 | //if it isn't a full url, try appending http:// to it | |
541 | if(wxURI(url).IsReference()) | |
542 | finalurl = wxString(wxT("http://")) + url; | |
543 | ||
657a7545 WS |
544 | #if defined(__WXMSW__) && wxUSE_CONFIG_NATIVE |
545 | ||
498a1eeb RN |
546 | wxString command; |
547 | ||
548 | // ShellExecute() always opens in the same window, | |
549 | // so do it manually for new window (from Mahogany) | |
550 | wxRegKey key(wxRegKey::HKCR, url.BeforeFirst(':') + wxT("\\shell\\open")); | |
551 | if ( key.Exists() ) | |
552 | { | |
553 | wxRegKey keyDDE(key, wxT("DDEExec")); | |
554 | if ( keyDDE.Exists() ) | |
555 | { | |
657a7545 WS |
556 | wxString ddeTopic = wxRegKey(keyDDE, wxT("topic")); |
557 | ||
558 | // we only know the syntax of WWW_OpenURL DDE request | |
559 | if ( ddeTopic == wxT("WWW_OpenURL") ) | |
560 | { | |
561 | wxString ddeCmd = keyDDE; | |
562 | ||
563 | // this is a bit naive but should work as -1 can't appear | |
564 | // elsewhere in the DDE topic, normally | |
565 | if ( ddeCmd.Replace(wxT("-1"), wxT("0"), | |
566 | false /* only first occurence */) == 1 ) | |
567 | { | |
568 | // and also replace the parameters | |
569 | if ( ddeCmd.Replace(wxT("%1"), url, false) == 1 ) | |
570 | { | |
571 | // magic incantation understood by wxMSW | |
572 | command << wxT("WX_DDE#") | |
573 | << wxRegKey(key, wxT("command")).QueryDefaultValue() << wxT('#') | |
574 | << wxRegKey(keyDDE, wxT("application")).QueryDefaultValue() | |
575 | << wxT('#') << ddeTopic << wxT('#') | |
576 | << ddeCmd; | |
577 | } | |
578 | } | |
579 | } | |
498a1eeb RN |
580 | } |
581 | } | |
582 | ||
657a7545 WS |
583 | //Try wxExecute - if it doesn't work or the regkey stuff |
584 | //above failed, fallback to opening the file in the same | |
585 | //browser window | |
586 | if ( command.empty() || wxExecute(command) == -1) | |
587 | { | |
fab79d44 JS |
588 | int nResult; //HINSTANCE error code |
589 | ||
590 | #if !defined(__WXWINCE__) | |
657a7545 WS |
591 | // CYGWIN and MINGW may have problems - so load ShellExecute |
592 | // dynamically | |
fab79d44 | 593 | typedef HINSTANCE (WINAPI *LPShellExecute)(HWND hwnd, const wxChar* lpOperation, |
657a7545 WS |
594 | const wxChar* lpFile, |
595 | const wxChar* lpParameters, | |
596 | const wxChar* lpDirectory, | |
597 | INT nShowCmd); | |
598 | ||
599 | HINSTANCE hShellDll = ::LoadLibrary(wxT("shell32.dll")); | |
600 | if(hShellDll == NULL) | |
601 | return false; | |
602 | ||
603 | LPShellExecute lpShellExecute = | |
604 | (LPShellExecute) ::GetProcAddress(hShellDll, | |
605 | wxString::Format(wxT("ShellExecute%s"), | |
eb5b252d | 606 | |
8cc3b2e9 | 607 | #if wxUSE_UNICODE |
657a7545 | 608 | wxT("W") |
498a1eeb | 609 | #else |
657a7545 | 610 | wxT("A") |
498a1eeb | 611 | #endif |
eb5b252d | 612 | #ifdef __WXWINCE__ |
498a1eeb | 613 | ) |
eb5b252d RN |
614 | #else |
615 | ).mb_str(wxConvLocal) | |
616 | #endif | |
617 | ); | |
657a7545 WS |
618 | if(lpShellExecute == NULL) |
619 | return false; | |
498a1eeb RN |
620 | |
621 | // Windows sometimes doesn't open the browser correctly when using mime | |
622 | // types, so do ShellExecute - i.e. start <url> (from James Carroll) | |
fab79d44 | 623 | nResult = (int) (*lpShellExecute)(NULL, NULL, finalurl.c_str(), |
532d575b | 624 | NULL, wxT(""), SW_SHOWNORMAL); |
498a1eeb RN |
625 | // Unload Shell32.dll |
626 | ::FreeLibrary(hShellDll); | |
fab79d44 JS |
627 | #else |
628 | //Windows CE does not have normal ShellExecute - but it has | |
629 | //ShellExecuteEx all the way back to version 1.0 | |
630 | ||
631 | ||
632 | //Set up the SHELLEXECUTEINFO structure to pass to ShellExecuteEx | |
633 | SHELLEXECUTEINFO sei; | |
634 | sei.cbSize = sizeof(SHELLEXECUTEINFO); | |
635 | sei.dwHotKey = 0; | |
636 | sei.fMask = 0; | |
637 | sei.hIcon = NULL; | |
638 | sei.hInstApp = NULL; | |
639 | sei.hkeyClass = NULL; | |
f8c10795 JS |
640 | // Not in WinCE |
641 | #if 0 | |
fab79d44 | 642 | sei.hMonitor = NULL; |
f8c10795 | 643 | #endif |
fab79d44 JS |
644 | sei.hProcess = NULL; |
645 | sei.hwnd = NULL; | |
646 | sei.lpClass = NULL; | |
647 | sei.lpDirectory = NULL; | |
648 | sei.lpFile = finalurl.c_str(); | |
649 | sei.lpIDList = NULL; | |
650 | sei.lpParameters = NULL; | |
651 | sei.lpVerb = TEXT("open"); | |
652 | sei.nShow = SW_SHOWNORMAL; | |
653 | ||
654 | //Call ShellExecuteEx | |
655 | ShellExecuteEx(&sei); | |
656 | ||
657 | //Get error code | |
658 | nResult = (int) sei.hInstApp; | |
659 | #endif | |
498a1eeb RN |
660 | |
661 | // Hack for Firefox (returns file not found for some reason) | |
662 | // from Angelo Mandato's wxHyperlinksCtrl | |
fab79d44 JS |
663 | // HINSTANCE_ERROR == 32 (HINSTANCE_ERROR does not exist on Windows CE) |
664 | if (nResult <= 32 && nResult != SE_ERR_FNF) | |
657a7545 | 665 | return false; |
498a1eeb | 666 | |
657a7545 | 667 | #ifdef __WXDEBUG__ |
498a1eeb RN |
668 | // Log something if SE_ERR_FNF happens |
669 | if(nResult == SE_ERR_FNF) | |
670 | wxLogDebug(wxT("Got SE_ERR_FNF from ShellExecute - maybe FireFox")); | |
657a7545 WS |
671 | #endif |
672 | } | |
673 | ||
674 | #elif wxUSE_MIMETYPE | |
498a1eeb | 675 | |
498a1eeb | 676 | // Non-windows way |
657a7545 WS |
677 | wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension (_T("html")); |
678 | if (!ft) | |
679 | { | |
680 | wxLogError(_T("No default application can open .html extension")); | |
681 | return false; | |
682 | } | |
498a1eeb RN |
683 | |
684 | wxString mt; | |
685 | ft->GetMimeType(&mt); | |
686 | ||
657a7545 WS |
687 | wxString cmd; |
688 | bool ok = ft->GetOpenCommand (&cmd, wxFileType::MessageParameters(finalurl)); | |
689 | delete ft; | |
690 | ||
691 | if (ok) | |
498a1eeb RN |
692 | { |
693 | if( wxExecute (cmd, wxEXEC_ASYNC) == -1 ) | |
694 | { | |
695 | wxLogError(_T("Failed to launch application for wxLaunchDefaultBrowser")); | |
696 | return false; | |
697 | } | |
698 | } | |
699 | else | |
2830b4a4 RD |
700 | { |
701 | // fallback to checking for the BROWSER environment variable | |
702 | cmd = wxGetenv(wxT("BROWSER")); | |
703 | if ( cmd.empty() || wxExecute(cmd + wxT(" ") + finalurl) == -1) | |
704 | return false; | |
705 | } | |
532d575b | 706 | |
657a7545 WS |
707 | |
708 | #else // !wxUSE_MIMETYPE && !(WXMSW && wxUSE_NATIVE_CONFIG) | |
709 | ||
532d575b | 710 | success = false; |
d6a7c33a | 711 | |
498a1eeb RN |
712 | #endif |
713 | ||
714 | //success - hopefully | |
532d575b | 715 | return success; |
498a1eeb RN |
716 | } |
717 | ||
91b4c08d | 718 | // ---------------------------------------------------------------------------- |
7c072018 | 719 | // wxApp::Yield() wrappers for backwards compatibility |
91b4c08d VZ |
720 | // ---------------------------------------------------------------------------- |
721 | ||
7c072018 | 722 | bool wxYield() |
469e1e5c | 723 | { |
7c072018 | 724 | return wxTheApp && wxTheApp->Yield(); |
469e1e5c | 725 | } |
7c072018 VZ |
726 | |
727 | bool wxYieldIfNeeded() | |
469e1e5c | 728 | { |
cb719f2e | 729 | return wxTheApp && wxTheApp->Yield(true); |
469e1e5c | 730 | } |
7c072018 | 731 | |
ec67cff1 | 732 | #endif // wxUSE_BASE |
7c072018 VZ |
733 | |
734 | // ============================================================================ | |
735 | // GUI-only functions from now on | |
736 | // ============================================================================ | |
737 | ||
738 | #if wxUSE_GUI | |
739 | ||
4c3ebca9 MB |
740 | // Id generation |
741 | static long wxCurrentId = 100; | |
742 | ||
c838b68e | 743 | long wxNewId() |
4c3ebca9 | 744 | { |
c838b68e VS |
745 | // skip the part of IDs space that contains hard-coded values: |
746 | if (wxCurrentId == wxID_LOWEST) | |
747 | wxCurrentId = wxID_HIGHEST + 1; | |
748 | ||
749 | return wxCurrentId++; | |
4c3ebca9 MB |
750 | } |
751 | ||
752 | long | |
753 | wxGetCurrentId(void) { return wxCurrentId; } | |
754 | ||
755 | void | |
756 | wxRegisterId (long id) | |
757 | { | |
758 | if (id >= wxCurrentId) | |
759 | wxCurrentId = id + 1; | |
760 | } | |
761 | ||
7c072018 | 762 | #if wxUSE_MENUS |
e90c1d2a VZ |
763 | |
764 | // ---------------------------------------------------------------------------- | |
7c072018 | 765 | // Menu accelerators related functions |
e90c1d2a VZ |
766 | // ---------------------------------------------------------------------------- |
767 | ||
7c072018 | 768 | wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out) |
e90c1d2a | 769 | { |
7c072018 VZ |
770 | wxString s = wxMenuItem::GetLabelFromText(in); |
771 | if ( out ) | |
772 | { | |
773 | // go smash their buffer if it's not big enough - I love char * params | |
774 | memcpy(out, s.c_str(), s.length() * sizeof(wxChar)); | |
775 | } | |
776 | else | |
777 | { | |
f526f752 MB |
778 | // MYcopystring - for easier search... |
779 | out = new wxChar[s.length() + 1]; | |
780 | wxStrcpy(out, s.c_str()); | |
7c072018 VZ |
781 | } |
782 | ||
783 | return out; | |
e90c1d2a VZ |
784 | } |
785 | ||
7c072018 | 786 | wxString wxStripMenuCodes(const wxString& in) |
e90c1d2a | 787 | { |
7c072018 | 788 | wxString out; |
79f585d9 | 789 | |
7c072018 VZ |
790 | size_t len = in.length(); |
791 | out.reserve(len); | |
79f585d9 | 792 | |
7c072018 VZ |
793 | for ( size_t n = 0; n < len; n++ ) |
794 | { | |
795 | wxChar ch = in[n]; | |
796 | if ( ch == _T('&') ) | |
cd6ce4a9 | 797 | { |
7c072018 VZ |
798 | // skip it, it is used to introduce the accel char (or to quote |
799 | // itself in which case it should still be skipped): note that it | |
800 | // can't be the last character of the string | |
801 | if ( ++n == len ) | |
79f585d9 | 802 | { |
7c072018 VZ |
803 | wxLogDebug(_T("Invalid menu string '%s'"), in.c_str()); |
804 | } | |
805 | else | |
806 | { | |
807 | // use the next char instead | |
808 | ch = in[n]; | |
79f585d9 | 809 | } |
cd6ce4a9 | 810 | } |
7c072018 | 811 | else if ( ch == _T('\t') ) |
79f585d9 | 812 | { |
7c072018 VZ |
813 | // everything after TAB is accel string, exit the loop |
814 | break; | |
79f585d9 | 815 | } |
7c072018 VZ |
816 | |
817 | out += ch; | |
225fe9d6 VZ |
818 | } |
819 | ||
7c072018 | 820 | return out; |
cd6ce4a9 VZ |
821 | } |
822 | ||
7c072018 | 823 | #endif // wxUSE_MENUS |
e90c1d2a | 824 | |
cbc66a27 | 825 | // ---------------------------------------------------------------------------- |
7c072018 | 826 | // Window search functions |
cbc66a27 VZ |
827 | // ---------------------------------------------------------------------------- |
828 | ||
7c072018 VZ |
829 | /* |
830 | * If parent is non-NULL, look through children for a label or title | |
831 | * matching the specified string. If NULL, look through all top-level windows. | |
832 | * | |
833 | */ | |
e2a6f233 | 834 | |
7c072018 VZ |
835 | wxWindow * |
836 | wxFindWindowByLabel (const wxString& title, wxWindow * parent) | |
134677bd | 837 | { |
7c072018 VZ |
838 | return wxWindow::FindWindowByLabel( title, parent ); |
839 | } | |
b829bf55 | 840 | |
b829bf55 | 841 | |
7c072018 VZ |
842 | /* |
843 | * If parent is non-NULL, look through children for a name | |
844 | * matching the specified string. If NULL, look through all top-level windows. | |
845 | * | |
846 | */ | |
134677bd | 847 | |
7c072018 VZ |
848 | wxWindow * |
849 | wxFindWindowByName (const wxString& name, wxWindow * parent) | |
2c18f21d | 850 | { |
7c072018 | 851 | return wxWindow::FindWindowByName( name, parent ); |
2c18f21d VS |
852 | } |
853 | ||
cb719f2e | 854 | // Returns menu item id or wxNOT_FOUND if none. |
7c072018 VZ |
855 | int |
856 | wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString) | |
e2a6f233 | 857 | { |
7c072018 VZ |
858 | #if wxUSE_MENUS |
859 | wxMenuBar *menuBar = frame->GetMenuBar (); | |
860 | if ( menuBar ) | |
861 | return menuBar->FindMenuItem (menuString, itemString); | |
862 | #endif // wxUSE_MENUS | |
0fb67cd1 | 863 | |
cb719f2e | 864 | return wxNOT_FOUND; |
e2a6f233 JS |
865 | } |
866 | ||
7c072018 VZ |
867 | // Try to find the deepest child that contains 'pt'. |
868 | // We go backwards, to try to allow for controls that are spacially | |
869 | // within other controls, but are still siblings (e.g. buttons within | |
870 | // static boxes). Static boxes are likely to be created _before_ controls | |
871 | // that sit inside them. | |
872 | wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt) | |
e2a6f233 | 873 | { |
7c072018 VZ |
874 | if (!win->IsShown()) |
875 | return NULL; | |
0fb67cd1 | 876 | |
7c072018 VZ |
877 | // Hack for wxNotebook case: at least in wxGTK, all pages |
878 | // claim to be shown, so we must only deal with the selected one. | |
879 | #if wxUSE_NOTEBOOK | |
880 | if (win->IsKindOf(CLASSINFO(wxNotebook))) | |
e2a6f233 | 881 | { |
7c072018 VZ |
882 | wxNotebook* nb = (wxNotebook*) win; |
883 | int sel = nb->GetSelection(); | |
884 | if (sel >= 0) | |
885 | { | |
886 | wxWindow* child = nb->GetPage(sel); | |
887 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
888 | if (foundWin) | |
889 | return foundWin; | |
890 | } | |
e2a6f233 | 891 | } |
7c072018 | 892 | #endif |
0fb67cd1 | 893 | |
df5168c4 | 894 | wxWindowList::compatibility_iterator node = win->GetChildren().GetLast(); |
7c072018 VZ |
895 | while (node) |
896 | { | |
897 | wxWindow* child = node->GetData(); | |
898 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
899 | if (foundWin) | |
900 | return foundWin; | |
901 | node = node->GetPrevious(); | |
902 | } | |
903 | ||
904 | wxPoint pos = win->GetPosition(); | |
905 | wxSize sz = win->GetSize(); | |
906 | if (win->GetParent()) | |
907 | { | |
908 | pos = win->GetParent()->ClientToScreen(pos); | |
909 | } | |
910 | ||
911 | wxRect rect(pos, sz); | |
912 | if (rect.Inside(pt)) | |
913 | return win; | |
914 | else | |
915 | return NULL; | |
0fb67cd1 VZ |
916 | } |
917 | ||
7c072018 | 918 | wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt) |
0fb67cd1 | 919 | { |
7c072018 VZ |
920 | // Go backwards through the list since windows |
921 | // on top are likely to have been appended most | |
922 | // recently. | |
df5168c4 | 923 | wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast(); |
7c072018 VZ |
924 | while (node) |
925 | { | |
926 | wxWindow* win = node->GetData(); | |
927 | wxWindow* found = wxFindWindowAtPoint(win, pt); | |
928 | if (found) | |
929 | return found; | |
930 | node = node->GetPrevious(); | |
931 | } | |
932 | return NULL; | |
933 | } | |
0fb67cd1 | 934 | |
7c072018 VZ |
935 | // ---------------------------------------------------------------------------- |
936 | // GUI helpers | |
937 | // ---------------------------------------------------------------------------- | |
0fb67cd1 | 938 | |
7c072018 VZ |
939 | /* |
940 | * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp | |
941 | * since otherwise the generic code may be pulled in unnecessarily. | |
942 | */ | |
0fb67cd1 | 943 | |
7c072018 | 944 | #if wxUSE_MSGDLG |
0fb67cd1 | 945 | |
7c072018 VZ |
946 | int wxMessageBox(const wxString& message, const wxString& caption, long style, |
947 | wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) ) | |
0fb67cd1 | 948 | { |
53a6ac21 DS |
949 | long decorated_style = style; |
950 | ||
951 | if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 ) | |
952 | { | |
953 | decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ; | |
954 | } | |
955 | ||
956 | wxMessageDialog dialog(parent, message, caption, decorated_style); | |
0fb67cd1 | 957 | |
7c072018 VZ |
958 | int ans = dialog.ShowModal(); |
959 | switch ( ans ) | |
960 | { | |
961 | case wxID_OK: | |
962 | return wxOK; | |
963 | case wxID_YES: | |
964 | return wxYES; | |
965 | case wxID_NO: | |
966 | return wxNO; | |
967 | case wxID_CANCEL: | |
968 | return wxCANCEL; | |
969 | } | |
0fb67cd1 | 970 | |
7c072018 | 971 | wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") ); |
0fb67cd1 | 972 | |
7c072018 | 973 | return wxCANCEL; |
e2a6f233 JS |
974 | } |
975 | ||
7c072018 | 976 | #endif // wxUSE_MSGDLG |
518b5d2f | 977 | |
7c072018 | 978 | #if wxUSE_TEXTDLG |
518b5d2f | 979 | |
7c072018 VZ |
980 | wxString wxGetTextFromUser(const wxString& message, const wxString& caption, |
981 | const wxString& defaultValue, wxWindow *parent, | |
13d13a9e | 982 | wxCoord x, wxCoord y, bool centre ) |
7c072018 VZ |
983 | { |
984 | wxString str; | |
13d13a9e WS |
985 | long style = wxTextEntryDialogStyle; |
986 | ||
987 | if (centre) | |
988 | style |= wxCENTRE; | |
989 | else | |
990 | style &= ~wxCENTRE; | |
991 | ||
992 | wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y)); | |
993 | ||
7c072018 VZ |
994 | if (dialog.ShowModal() == wxID_OK) |
995 | { | |
996 | str = dialog.GetValue(); | |
997 | } | |
0fb67cd1 | 998 | |
7c072018 | 999 | return str; |
518b5d2f VZ |
1000 | } |
1001 | ||
7c072018 VZ |
1002 | wxString wxGetPasswordFromUser(const wxString& message, |
1003 | const wxString& caption, | |
1004 | const wxString& defaultValue, | |
b3bb2a74 KH |
1005 | wxWindow *parent, |
1006 | wxCoord x, wxCoord y, bool centre ) | |
96c5bd7f | 1007 | { |
7c072018 | 1008 | wxString str; |
b3bb2a74 KH |
1009 | long style = wxTextEntryDialogStyle; |
1010 | ||
1011 | if (centre) | |
1012 | style |= wxCENTRE; | |
1013 | else | |
1014 | style &= ~wxCENTRE; | |
1015 | ||
12cfa304 KH |
1016 | wxPasswordEntryDialog dialog(parent, message, caption, defaultValue, |
1017 | style, wxPoint(x, y)); | |
7c072018 VZ |
1018 | if ( dialog.ShowModal() == wxID_OK ) |
1019 | { | |
1020 | str = dialog.GetValue(); | |
1021 | } | |
96c5bd7f | 1022 | |
7c072018 VZ |
1023 | return str; |
1024 | } | |
96c5bd7f | 1025 | |
7c072018 | 1026 | #endif // wxUSE_TEXTDLG |
96c5bd7f | 1027 | |
7c072018 | 1028 | #if wxUSE_COLOURDLG |
96c5bd7f | 1029 | |
7c072018 | 1030 | wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit) |
c51deffc | 1031 | { |
7c072018 | 1032 | wxColourData data; |
cb719f2e | 1033 | data.SetChooseFull(true); |
7c072018 VZ |
1034 | if ( colInit.Ok() ) |
1035 | { | |
1036 | data.SetColour((wxColour &)colInit); // const_cast | |
1037 | } | |
c51deffc | 1038 | |
7c072018 VZ |
1039 | wxColour colRet; |
1040 | wxColourDialog dialog(parent, &data); | |
1041 | if ( dialog.ShowModal() == wxID_OK ) | |
1042 | { | |
1043 | colRet = dialog.GetColourData().GetColour(); | |
1044 | } | |
1045 | //else: leave it invalid | |
1046 | ||
1047 | return colRet; | |
c51deffc | 1048 | } |
bc385ba9 | 1049 | |
7c072018 | 1050 | #endif // wxUSE_COLOURDLG |
bc385ba9 | 1051 | |
7c072018 VZ |
1052 | #if wxUSE_FONTDLG |
1053 | ||
1054 | wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit) | |
bc385ba9 | 1055 | { |
7c072018 VZ |
1056 | wxFontData data; |
1057 | if ( fontInit.Ok() ) | |
bc385ba9 | 1058 | { |
7c072018 VZ |
1059 | data.SetInitialFont(fontInit); |
1060 | } | |
bc385ba9 | 1061 | |
7c072018 VZ |
1062 | wxFont fontRet; |
1063 | wxFontDialog dialog(parent, data); | |
1064 | if ( dialog.ShowModal() == wxID_OK ) | |
1065 | { | |
1066 | fontRet = dialog.GetFontData().GetChosenFont(); | |
1067 | } | |
1068 | //else: leave it invalid | |
bc385ba9 | 1069 | |
7c072018 | 1070 | return fontRet; |
bc385ba9 VZ |
1071 | } |
1072 | ||
7c072018 | 1073 | #endif // wxUSE_FONTDLG |
2b5f62a0 | 1074 | |
7c072018 VZ |
1075 | // ---------------------------------------------------------------------------- |
1076 | // wxSafeYield and supporting functions | |
1077 | // ---------------------------------------------------------------------------- | |
2b5f62a0 | 1078 | |
7c072018 VZ |
1079 | void wxEnableTopLevelWindows(bool enable) |
1080 | { | |
df5168c4 | 1081 | wxWindowList::compatibility_iterator node; |
7c072018 VZ |
1082 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) |
1083 | node->GetData()->Enable(enable); | |
1084 | } | |
2b5f62a0 | 1085 | |
7c072018 VZ |
1086 | wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip) |
1087 | { | |
1088 | // remember the top level windows which were already disabled, so that we | |
1089 | // don't reenable them later | |
1090 | m_winDisabled = NULL; | |
1091 | ||
df5168c4 | 1092 | wxWindowList::compatibility_iterator node; |
7c072018 | 1093 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) |
2b5f62a0 | 1094 | { |
7c072018 VZ |
1095 | wxWindow *winTop = node->GetData(); |
1096 | if ( winTop == winToSkip ) | |
1097 | continue; | |
2b5f62a0 | 1098 | |
7c072018 VZ |
1099 | // we don't need to disable the hidden or already disabled windows |
1100 | if ( winTop->IsEnabled() && winTop->IsShown() ) | |
2b5f62a0 | 1101 | { |
7c072018 | 1102 | winTop->Disable(); |
2b5f62a0 VZ |
1103 | } |
1104 | else | |
1105 | { | |
7c072018 VZ |
1106 | if ( !m_winDisabled ) |
1107 | { | |
1108 | m_winDisabled = new wxWindowList; | |
1109 | } | |
1110 | ||
1111 | m_winDisabled->Append(winTop); | |
2b5f62a0 VZ |
1112 | } |
1113 | } | |
2b5f62a0 VZ |
1114 | } |
1115 | ||
7c072018 | 1116 | wxWindowDisabler::~wxWindowDisabler() |
cd6ce4a9 | 1117 | { |
df5168c4 | 1118 | wxWindowList::compatibility_iterator node; |
7c072018 | 1119 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) |
cd6ce4a9 | 1120 | { |
7c072018 VZ |
1121 | wxWindow *winTop = node->GetData(); |
1122 | if ( !m_winDisabled || !m_winDisabled->Find(winTop) ) | |
cd6ce4a9 | 1123 | { |
7c072018 | 1124 | winTop->Enable(); |
cd6ce4a9 | 1125 | } |
7c072018 | 1126 | //else: had been already disabled, don't reenable |
cd6ce4a9 | 1127 | } |
f6bcfd97 | 1128 | |
7c072018 | 1129 | delete m_winDisabled; |
f6bcfd97 BP |
1130 | } |
1131 | ||
7c072018 VZ |
1132 | // Yield to other apps/messages and disable user input to all windows except |
1133 | // the given one | |
1134 | bool wxSafeYield(wxWindow *win, bool onlyIfNeeded) | |
f6bcfd97 | 1135 | { |
7c072018 | 1136 | wxWindowDisabler wd(win); |
21709999 | 1137 | |
7c072018 VZ |
1138 | bool rc; |
1139 | if (onlyIfNeeded) | |
1140 | rc = wxYieldIfNeeded(); | |
1141 | else | |
1142 | rc = wxYield(); | |
8461e4c2 | 1143 | |
7c072018 | 1144 | return rc; |
8461e4c2 VZ |
1145 | } |
1146 | ||
7c072018 VZ |
1147 | // Don't synthesize KeyUp events holding down a key and producing KeyDown |
1148 | // events with autorepeat. On by default and always on in wxMSW. wxGTK version | |
1149 | // in utilsgtk.cpp. | |
1150 | #ifndef __WXGTK__ | |
1151 | bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) ) | |
8461e4c2 | 1152 | { |
cb719f2e | 1153 | return true; // detectable auto-repeat is the only mode MSW supports |
8461e4c2 | 1154 | } |
7c072018 VZ |
1155 | #endif // !wxGTK |
1156 | ||
1157 | #endif // wxUSE_GUI | |
21709999 | 1158 |