]>
Commit | Line | Data |
---|---|---|
c801d85f | 1 | ///////////////////////////////////////////////////////////////////////////// |
3452f00b | 2 | // Name: src/common/utilscmn.cpp |
c801d85f KB |
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 | ||
c801d85f KB |
20 | // For compilers that support precompilation, includes "wx.h". |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
e90c1d2a | 24 | #pragma hdrstop |
c801d85f KB |
25 | #endif |
26 | ||
27 | #ifndef WX_PRECOMP | |
fcdb9b38 | 28 | #include "wx/app.h" |
e90c1d2a VZ |
29 | #include "wx/string.h" |
30 | #include "wx/utils.h" | |
974e8d94 VZ |
31 | #include "wx/intl.h" |
32 | #include "wx/log.h" | |
e90c1d2a VZ |
33 | |
34 | #if wxUSE_GUI | |
35 | #include "wx/window.h" | |
e90c1d2a | 36 | #include "wx/frame.h" |
1e6feb95 | 37 | #include "wx/menu.h" |
e90c1d2a VZ |
38 | #include "wx/msgdlg.h" |
39 | #include "wx/textdlg.h" | |
78bcfcfc | 40 | #include "wx/textctrl.h" // for wxTE_PASSWORD |
974e8d94 VZ |
41 | #if wxUSE_ACCEL |
42 | #include "wx/menuitem.h" | |
43 | #include "wx/accel.h" | |
44 | #endif // wxUSE_ACCEL | |
e90c1d2a VZ |
45 | #endif // wxUSE_GUI |
46 | #endif // WX_PRECOMP | |
c801d85f | 47 | |
2739d4f0 VZ |
48 | #include "wx/apptrait.h" |
49 | ||
cd6ce4a9 VZ |
50 | #include "wx/process.h" |
51 | #include "wx/txtstrm.h" | |
498a1eeb RN |
52 | #include "wx/uri.h" |
53 | #include "wx/mimetype.h" | |
54 | #include "wx/config.h" | |
cd6ce4a9 | 55 | |
4676948b JS |
56 | #if defined(__WXWINCE__) && wxUSE_DATETIME |
57 | #include "wx/datetime.h" | |
58 | #endif | |
59 | ||
c801d85f KB |
60 | #include <ctype.h> |
61 | #include <stdio.h> | |
62 | #include <stdlib.h> | |
63 | #include <string.h> | |
e90c1d2a | 64 | |
13ff2485 | 65 | #if !wxONLY_WATCOM_EARLIER_THAN(1,4) |
3f4a0c5b VZ |
66 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) |
67 | #include <errno.h> | |
68 | #endif | |
c801d85f | 69 | #endif |
e90c1d2a | 70 | |
91b4c08d VZ |
71 | #if wxUSE_GUI |
72 | #include "wx/colordlg.h" | |
bf31fa26 | 73 | #include "wx/fontdlg.h" |
d1c8aaa3 | 74 | #include "wx/notebook.h" |
d1c8aaa3 | 75 | #include "wx/statusbr.h" |
91b4c08d VZ |
76 | #endif // wxUSE_GUI |
77 | ||
1c193821 | 78 | #ifndef __WXWINCE__ |
c801d85f | 79 | #include <time.h> |
1c193821 JS |
80 | #else |
81 | #include "wx/msw/wince/time.h" | |
82 | #endif | |
e90c1d2a | 83 | |
f14d6dd1 JS |
84 | #ifdef __WXMAC__ |
85 | #include "wx/mac/private.h" | |
86 | #ifndef __DARWIN__ | |
87 | #include "InternetConfig.h" | |
88 | #endif | |
89 | #endif | |
90 | ||
4676948b | 91 | #if !defined(__MWERKS__) && !defined(__WXWINCE__) |
e90c1d2a VZ |
92 | #include <sys/types.h> |
93 | #include <sys/stat.h> | |
469e1e5c | 94 | #endif |
c801d85f | 95 | |
82ef81ed | 96 | #if defined(__WXMSW__) |
5e1febfa | 97 | #include "wx/msw/private.h" |
3452f00b | 98 | #include "wx/msw/registry.h" |
b21d68c6 | 99 | #include <shellapi.h> // needed for SHELLEXECUTEINFO |
c801d85f KB |
100 | #endif |
101 | ||
ec67cff1 | 102 | #if wxUSE_BASE |
7c072018 | 103 | |
73deed44 VZ |
104 | // ---------------------------------------------------------------------------- |
105 | // common data | |
106 | // ---------------------------------------------------------------------------- | |
107 | ||
e90c1d2a VZ |
108 | // ============================================================================ |
109 | // implementation | |
110 | // ============================================================================ | |
c801d85f | 111 | |
c801d85f | 112 | // Array used in DecToHex conversion routine. |
223d09f6 | 113 | static wxChar hexArray[] = wxT("0123456789ABCDEF"); |
c801d85f KB |
114 | |
115 | // Convert 2-digit hex number to decimal | |
fd71308f | 116 | int wxHexToDec(const wxString& buf) |
c801d85f | 117 | { |
657a7545 | 118 | int firstDigit, secondDigit; |
3f4a0c5b | 119 | |
657a7545 WS |
120 | if (buf.GetChar(0) >= wxT('A')) |
121 | firstDigit = buf.GetChar(0) - wxT('A') + 10; | |
122 | else | |
123 | firstDigit = buf.GetChar(0) - wxT('0'); | |
c801d85f | 124 | |
657a7545 WS |
125 | if (buf.GetChar(1) >= wxT('A')) |
126 | secondDigit = buf.GetChar(1) - wxT('A') + 10; | |
127 | else | |
128 | secondDigit = buf.GetChar(1) - wxT('0'); | |
3f4a0c5b | 129 | |
657a7545 | 130 | return (firstDigit & 0xF) * 16 + (secondDigit & 0xF ); |
c801d85f KB |
131 | } |
132 | ||
133 | // Convert decimal integer to 2-character hex string | |
84fff0b3 | 134 | void wxDecToHex(int dec, wxChar *buf) |
c801d85f | 135 | { |
657a7545 WS |
136 | int firstDigit = (int)(dec/16.0); |
137 | int secondDigit = (int)(dec - (firstDigit*16.0)); | |
138 | buf[0] = hexArray[firstDigit]; | |
139 | buf[1] = hexArray[secondDigit]; | |
140 | buf[2] = 0; | |
c801d85f KB |
141 | } |
142 | ||
fd71308f JS |
143 | // Convert decimal integer to 2-character hex string |
144 | wxString wxDecToHex(int dec) | |
145 | { | |
84fff0b3 | 146 | wxChar buf[3]; |
fd71308f JS |
147 | wxDecToHex(dec, buf); |
148 | return wxString(buf); | |
149 | } | |
150 | ||
7c072018 VZ |
151 | // ---------------------------------------------------------------------------- |
152 | // misc functions | |
153 | // ---------------------------------------------------------------------------- | |
c801d85f KB |
154 | |
155 | // Return the current date/time | |
e90c1d2a | 156 | wxString wxNow() |
c801d85f | 157 | { |
4676948b JS |
158 | #ifdef __WXWINCE__ |
159 | #if wxUSE_DATETIME | |
160 | wxDateTime now = wxDateTime::Now(); | |
161 | return now.Format(); | |
162 | #else | |
163 | return wxEmptyString; | |
164 | #endif | |
165 | #else | |
2b5f62a0 VZ |
166 | time_t now = time((time_t *) NULL); |
167 | char *date = ctime(&now); | |
168 | date[24] = '\0'; | |
169 | return wxString::FromAscii(date); | |
4676948b | 170 | #endif |
c801d85f KB |
171 | } |
172 | ||
08873d36 VZ |
173 | void wxUsleep(unsigned long milliseconds) |
174 | { | |
175 | wxMilliSleep(milliseconds); | |
176 | } | |
177 | ||
7c072018 VZ |
178 | const wxChar *wxGetInstallPrefix() |
179 | { | |
180 | wxString prefix; | |
181 | ||
182 | if ( wxGetEnv(wxT("WXPREFIX"), &prefix) ) | |
183 | return prefix.c_str(); | |
184 | ||
185 | #ifdef wxINSTALL_PREFIX | |
186 | return wxT(wxINSTALL_PREFIX); | |
187 | #else | |
525d8583 | 188 | return wxEmptyString; |
7c072018 VZ |
189 | #endif |
190 | } | |
191 | ||
192 | wxString wxGetDataDir() | |
193 | { | |
10f206ad RL |
194 | wxString dir = wxGetInstallPrefix(); |
195 | dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx"); | |
7c072018 VZ |
196 | return dir; |
197 | } | |
e90c1d2a | 198 | |
8bb6b2c0 | 199 | bool wxIsPlatformLittleEndian() |
2739d4f0 | 200 | { |
8bb6b2c0 VZ |
201 | // Are we little or big endian? This method is from Harbison & Steele. |
202 | union | |
203 | { | |
204 | long l; | |
205 | char c[sizeof(long)]; | |
206 | } u; | |
207 | u.l = 1; | |
208 | ||
209 | return u.c[0] == 1; | |
2739d4f0 | 210 | } |
1e6feb95 | 211 | |
8bb6b2c0 | 212 | |
230c9077 JS |
213 | /* |
214 | * Class to make it easier to specify platform-dependent values | |
215 | */ | |
216 | ||
217 | wxArrayInt* wxPlatform::sm_customPlatforms = NULL; | |
218 | ||
4bfec179 | 219 | void wxPlatform::Copy(const wxPlatform& platform) |
230c9077 | 220 | { |
4bfec179 JS |
221 | m_longValue = platform.m_longValue; |
222 | m_doubleValue = platform.m_doubleValue; | |
223 | m_stringValue = platform.m_stringValue; | |
224 | } | |
225 | ||
226 | wxPlatform wxPlatform::If(int platform, long value) | |
227 | { | |
228 | if (Is(platform)) | |
229 | return wxPlatform(value); | |
230 | else | |
231 | return wxPlatform(); | |
232 | } | |
233 | ||
234 | wxPlatform wxPlatform::IfNot(int platform, long value) | |
235 | { | |
236 | if (!Is(platform)) | |
237 | return wxPlatform(value); | |
238 | else | |
239 | return wxPlatform(); | |
240 | } | |
241 | ||
242 | wxPlatform& wxPlatform::ElseIf(int platform, long value) | |
243 | { | |
244 | if (Is(platform)) | |
230c9077 JS |
245 | m_longValue = value; |
246 | return *this; | |
247 | } | |
248 | ||
4bfec179 | 249 | wxPlatform& wxPlatform::ElseIfNot(int platform, long value) |
230c9077 | 250 | { |
4bfec179 | 251 | if (!Is(platform)) |
230c9077 JS |
252 | m_longValue = value; |
253 | return *this; | |
254 | } | |
255 | ||
4bfec179 | 256 | wxPlatform wxPlatform::If(int platform, double value) |
230c9077 | 257 | { |
4bfec179 JS |
258 | if (Is(platform)) |
259 | return wxPlatform(value); | |
260 | else | |
261 | return wxPlatform(); | |
262 | } | |
263 | ||
264 | wxPlatform wxPlatform::IfNot(int platform, double value) | |
265 | { | |
266 | if (!Is(platform)) | |
267 | return wxPlatform(value); | |
268 | else | |
269 | return wxPlatform(); | |
270 | } | |
271 | ||
272 | wxPlatform& wxPlatform::ElseIf(int platform, double value) | |
273 | { | |
274 | if (Is(platform)) | |
230c9077 JS |
275 | m_doubleValue = value; |
276 | return *this; | |
277 | } | |
278 | ||
4bfec179 | 279 | wxPlatform& wxPlatform::ElseIfNot(int platform, double value) |
230c9077 | 280 | { |
4bfec179 | 281 | if (!Is(platform)) |
230c9077 JS |
282 | m_doubleValue = value; |
283 | return *this; | |
284 | } | |
285 | ||
4bfec179 JS |
286 | wxPlatform wxPlatform::If(int platform, const wxString& value) |
287 | { | |
288 | if (Is(platform)) | |
289 | return wxPlatform(value); | |
290 | else | |
291 | return wxPlatform(); | |
292 | } | |
293 | ||
294 | wxPlatform wxPlatform::IfNot(int platform, const wxString& value) | |
295 | { | |
296 | if (!Is(platform)) | |
297 | return wxPlatform(value); | |
298 | else | |
299 | return wxPlatform(); | |
300 | } | |
301 | ||
302 | wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value) | |
230c9077 | 303 | { |
4bfec179 | 304 | if (Is(platform)) |
230c9077 JS |
305 | m_stringValue = value; |
306 | return *this; | |
307 | } | |
308 | ||
4bfec179 | 309 | wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value) |
230c9077 | 310 | { |
4bfec179 | 311 | if (!Is(platform)) |
230c9077 JS |
312 | m_stringValue = value; |
313 | return *this; | |
314 | } | |
315 | ||
4bfec179 | 316 | wxPlatform& wxPlatform::Else(long value) |
230c9077 JS |
317 | { |
318 | m_longValue = value; | |
319 | return *this; | |
320 | } | |
321 | ||
4bfec179 | 322 | wxPlatform& wxPlatform::Else(double value) |
230c9077 JS |
323 | { |
324 | m_doubleValue = value; | |
325 | return *this; | |
326 | } | |
327 | ||
4bfec179 | 328 | wxPlatform& wxPlatform::Else(const wxString& value) |
230c9077 JS |
329 | { |
330 | m_stringValue = value; | |
331 | return *this; | |
332 | } | |
333 | ||
334 | void wxPlatform::AddPlatform(int platform) | |
335 | { | |
336 | if (!sm_customPlatforms) | |
337 | sm_customPlatforms = new wxArrayInt; | |
338 | sm_customPlatforms->Add(platform); | |
339 | } | |
340 | ||
341 | void wxPlatform::ClearPlatforms() | |
342 | { | |
343 | delete sm_customPlatforms; | |
344 | sm_customPlatforms = NULL; | |
345 | } | |
346 | ||
347 | /// Function for testing current platform | |
348 | ||
4bfec179 | 349 | bool wxPlatform::Is(int platform) |
230c9077 JS |
350 | { |
351 | #ifdef __WXMSW__ | |
216c3543 | 352 | if (platform == wxOS_WINDOWS) |
230c9077 JS |
353 | return true; |
354 | #endif | |
355 | #ifdef __WXWINCE__ | |
216c3543 | 356 | if (platform == wxOS_WINDOWS_CE) |
230c9077 JS |
357 | return true; |
358 | #endif | |
a6e8c584 WS |
359 | |
360 | #if 0 | |
361 | ||
362 | // FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols | |
363 | ||
230c9077 JS |
364 | #if defined(__WXWINCE__) && defined(__POCKETPC__) |
365 | if (platform == wxWinPocketPC) | |
366 | return true; | |
367 | #endif | |
368 | #if defined(__WXWINCE__) && defined(__SMARTPHONE__) | |
6aa68c25 | 369 | if (platform == wxWinSmartPhone) |
230c9077 JS |
370 | return true; |
371 | #endif | |
a6e8c584 WS |
372 | |
373 | #endif | |
374 | ||
230c9077 | 375 | #ifdef __WXGTK__ |
216c3543 | 376 | if (platform == wxPORT_GTK) |
230c9077 JS |
377 | return true; |
378 | #endif | |
379 | #ifdef __WXMAC__ | |
216c3543 | 380 | if (platform == wxPORT_MAC) |
230c9077 JS |
381 | return true; |
382 | #endif | |
383 | #ifdef __WXX11__ | |
216c3543 | 384 | if (platform == wxPORT_X11) |
230c9077 JS |
385 | return true; |
386 | #endif | |
387 | #ifdef __UNIX__ | |
216c3543 | 388 | if (platform == wxOS_UNIX) |
230c9077 JS |
389 | return true; |
390 | #endif | |
391 | #ifdef __WXMGL__ | |
216c3543 | 392 | if (platform == wxPORT_MGL) |
230c9077 JS |
393 | return true; |
394 | #endif | |
8ab09e65 SN |
395 | #ifdef __OS2__ |
396 | if (platform == wxOS_OS2) | |
397 | return true; | |
398 | #endif | |
399 | #ifdef __WXPM__ | |
400 | if (platform == wxPORT_PM) | |
230c9077 JS |
401 | return true; |
402 | #endif | |
55d452c6 | 403 | #ifdef __WXCOCOA__ |
216c3543 | 404 | if (platform == wxPORT_MAC) |
230c9077 JS |
405 | return true; |
406 | #endif | |
407 | ||
408 | if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND) | |
409 | return true; | |
410 | ||
411 | return false; | |
412 | } | |
413 | ||
e90c1d2a | 414 | // ---------------------------------------------------------------------------- |
7c072018 | 415 | // network and user id functions |
e90c1d2a | 416 | // ---------------------------------------------------------------------------- |
c801d85f | 417 | |
7c072018 VZ |
418 | // Get Full RFC822 style email address |
419 | bool wxGetEmailAddress(wxChar *address, int maxSize) | |
c801d85f | 420 | { |
7c072018 VZ |
421 | wxString email = wxGetEmailAddress(); |
422 | if ( !email ) | |
cb719f2e | 423 | return false; |
c801d85f | 424 | |
7c072018 VZ |
425 | wxStrncpy(address, email, maxSize - 1); |
426 | address[maxSize - 1] = wxT('\0'); | |
427 | ||
cb719f2e | 428 | return true; |
c801d85f KB |
429 | } |
430 | ||
7c072018 | 431 | wxString wxGetEmailAddress() |
47bc1060 | 432 | { |
7c072018 | 433 | wxString email; |
974e8d94 | 434 | |
7c072018 | 435 | wxString host = wxGetFullHostName(); |
4055ed82 | 436 | if ( !host.empty() ) |
1e6feb95 | 437 | { |
7c072018 | 438 | wxString user = wxGetUserId(); |
4055ed82 | 439 | if ( !user.empty() ) |
1e6feb95 | 440 | { |
7c072018 | 441 | email << user << wxT('@') << host; |
974e8d94 | 442 | } |
974e8d94 VZ |
443 | } |
444 | ||
7c072018 | 445 | return email; |
974e8d94 VZ |
446 | } |
447 | ||
7c072018 | 448 | wxString wxGetUserId() |
c801d85f | 449 | { |
7c072018 | 450 | static const int maxLoginLen = 256; // FIXME arbitrary number |
c801d85f | 451 | |
7c072018 | 452 | wxString buf; |
4c3ebca9 | 453 | bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen); |
c801d85f | 454 | |
7c072018 VZ |
455 | if ( !ok ) |
456 | buf.Empty(); | |
c801d85f | 457 | |
7c072018 | 458 | return buf; |
c801d85f KB |
459 | } |
460 | ||
7c072018 | 461 | wxString wxGetUserName() |
c801d85f | 462 | { |
7c072018 | 463 | static const int maxUserNameLen = 1024; // FIXME arbitrary number |
1e6feb95 | 464 | |
7c072018 | 465 | wxString buf; |
4c3ebca9 | 466 | bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen); |
7c072018 VZ |
467 | |
468 | if ( !ok ) | |
469 | buf.Empty(); | |
470 | ||
471 | return buf; | |
59a12e90 JS |
472 | } |
473 | ||
7c072018 | 474 | wxString wxGetHostName() |
59a12e90 | 475 | { |
7c072018 | 476 | static const size_t hostnameSize = 257; |
c67d6888 | 477 | |
7c072018 | 478 | wxString buf; |
4c3ebca9 | 479 | bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); |
59a12e90 | 480 | |
7c072018 VZ |
481 | if ( !ok ) |
482 | buf.Empty(); | |
59a12e90 | 483 | |
7c072018 | 484 | return buf; |
59a12e90 JS |
485 | } |
486 | ||
7c072018 | 487 | wxString wxGetFullHostName() |
59a12e90 | 488 | { |
7c072018 | 489 | static const size_t hostnameSize = 257; |
c801d85f | 490 | |
7c072018 | 491 | wxString buf; |
4c3ebca9 | 492 | bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); |
7c072018 VZ |
493 | |
494 | if ( !ok ) | |
495 | buf.Empty(); | |
c801d85f | 496 | |
7c072018 VZ |
497 | return buf; |
498 | } | |
c801d85f | 499 | |
7c072018 VZ |
500 | wxString wxGetHomeDir() |
501 | { | |
502 | wxString home; | |
503 | wxGetHomeDir(&home); | |
c801d85f | 504 | |
7c072018 VZ |
505 | return home; |
506 | } | |
c801d85f | 507 | |
c801d85f KB |
508 | #if 0 |
509 | ||
7c072018 | 510 | wxString wxGetCurrentDir() |
c801d85f | 511 | { |
7c072018 VZ |
512 | wxString dir; |
513 | size_t len = 1024; | |
514 | bool ok; | |
515 | do | |
516 | { | |
517 | ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL; | |
518 | dir.UngetWriteBuf(); | |
c801d85f | 519 | |
7c072018 VZ |
520 | if ( !ok ) |
521 | { | |
522 | if ( errno != ERANGE ) | |
523 | { | |
524 | wxLogSysError(_T("Failed to get current directory")); | |
c801d85f | 525 | |
7c072018 VZ |
526 | return wxEmptyString; |
527 | } | |
3f4a0c5b | 528 | else |
7c072018 VZ |
529 | { |
530 | // buffer was too small, retry with a larger one | |
531 | len *= 2; | |
532 | } | |
3f4a0c5b | 533 | } |
7c072018 VZ |
534 | //else: ok |
535 | } while ( !ok ); | |
c801d85f | 536 | |
7c072018 | 537 | return dir; |
c801d85f KB |
538 | } |
539 | ||
7c072018 | 540 | #endif // 0 |
e90c1d2a VZ |
541 | |
542 | // ---------------------------------------------------------------------------- | |
7c072018 | 543 | // wxExecute |
e90c1d2a | 544 | // ---------------------------------------------------------------------------- |
ead7ce10 | 545 | |
7c072018 VZ |
546 | // wxDoExecuteWithCapture() helper: reads an entire stream into one array |
547 | // | |
cb719f2e | 548 | // returns true if ok, false if error |
7c072018 VZ |
549 | #if wxUSE_STREAMS |
550 | static bool ReadAll(wxInputStream *is, wxArrayString& output) | |
dfad0599 | 551 | { |
cb719f2e | 552 | wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") ); |
dfad0599 | 553 | |
7c072018 VZ |
554 | // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state |
555 | is->Reset(); | |
1e6feb95 | 556 | |
7c072018 | 557 | wxTextInputStream tis(*is); |
1e6feb95 | 558 | |
cb719f2e | 559 | bool cont = true; |
7c072018 | 560 | while ( cont ) |
d2f50933 | 561 | { |
7c072018 VZ |
562 | wxString line = tis.ReadLine(); |
563 | if ( is->Eof() ) | |
564 | break; | |
565 | ||
566 | if ( !*is ) | |
567 | { | |
cb719f2e | 568 | cont = false; |
7c072018 VZ |
569 | } |
570 | else | |
571 | { | |
572 | output.Add(line); | |
573 | } | |
d2f50933 VZ |
574 | } |
575 | ||
7c072018 | 576 | return cont; |
dfad0599 | 577 | } |
7c072018 | 578 | #endif // wxUSE_STREAMS |
d2f50933 | 579 | |
7c072018 VZ |
580 | // this is a private function because it hasn't a clean interface: the first |
581 | // array is passed by reference, the second by pointer - instead we have 2 | |
582 | // public versions of wxExecute() below | |
583 | static long wxDoExecuteWithCapture(const wxString& command, | |
584 | wxArrayString& output, | |
4d172154 VZ |
585 | wxArrayString* error, |
586 | int flags) | |
d2f50933 | 587 | { |
7c072018 VZ |
588 | // create a wxProcess which will capture the output |
589 | wxProcess *process = new wxProcess; | |
590 | process->Redirect(); | |
dfad0599 | 591 | |
4d172154 | 592 | long rc = wxExecute(command, wxEXEC_SYNC | flags, process); |
1e6feb95 | 593 | |
7c072018 VZ |
594 | #if wxUSE_STREAMS |
595 | if ( rc != -1 ) | |
bf31fa26 | 596 | { |
7c072018 VZ |
597 | if ( !ReadAll(process->GetInputStream(), output) ) |
598 | rc = -1; | |
91b4c08d | 599 | |
7c072018 VZ |
600 | if ( error ) |
601 | { | |
602 | if ( !ReadAll(process->GetErrorStream(), *error) ) | |
603 | rc = -1; | |
604 | } | |
91b4c08d | 605 | |
7c072018 | 606 | } |
e70ba80d WS |
607 | #else |
608 | wxUnusedVar(output); | |
609 | wxUnusedVar(error); | |
610 | #endif // wxUSE_STREAMS/!wxUSE_STREAMS | |
91b4c08d | 611 | |
7c072018 | 612 | delete process; |
1e6feb95 | 613 | |
7c072018 | 614 | return rc; |
7c072018 | 615 | } |
bf31fa26 | 616 | |
4d172154 | 617 | long wxExecute(const wxString& command, wxArrayString& output, int flags) |
bf31fa26 | 618 | { |
4d172154 | 619 | return wxDoExecuteWithCapture(command, output, NULL, flags); |
7c072018 | 620 | } |
bf31fa26 | 621 | |
7c072018 VZ |
622 | long wxExecute(const wxString& command, |
623 | wxArrayString& output, | |
4d172154 VZ |
624 | wxArrayString& error, |
625 | int flags) | |
7c072018 | 626 | { |
4d172154 | 627 | return wxDoExecuteWithCapture(command, output, &error, flags); |
bf31fa26 VZ |
628 | } |
629 | ||
498a1eeb RN |
630 | // ---------------------------------------------------------------------------- |
631 | // Launch default browser | |
632 | // ---------------------------------------------------------------------------- | |
633 | ||
42d0df00 | 634 | bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags) |
498a1eeb | 635 | { |
42d0df00 VZ |
636 | wxUnusedVar(flags); |
637 | ||
7999124f | 638 | // set the scheme of url to http if it does not have one |
889fda0c | 639 | // RR: This doesn't work if the url is just a local path |
7999124f | 640 | wxString url(urlOrig); |
6f6dd276 VZ |
641 | wxURI uri(url); |
642 | if ( !uri.HasScheme() ) | |
7999124f | 643 | url.Prepend(wxT("http://")); |
889fda0c | 644 | |
532d575b | 645 | |
7999124f | 646 | #if defined(__WXMSW__) |
5ccb95f6 WS |
647 | |
648 | #if wxUSE_IPC | |
42d0df00 VZ |
649 | if ( flags & wxBROWSER_NEW_WINDOW ) |
650 | { | |
651 | // ShellExecuteEx() opens the URL in an existing window by default so | |
652 | // we can't use it if we need a new window | |
6f6dd276 VZ |
653 | wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open")); |
654 | if ( !key.Exists() ) | |
655 | { | |
656 | // try default browser, it must be registered at least for http URLs | |
657 | key.SetName(wxRegKey::HKCR, _T("http\\shell\\open")); | |
658 | } | |
659 | ||
42d0df00 VZ |
660 | if ( key.Exists() ) |
661 | { | |
662 | wxRegKey keyDDE(key, wxT("DDEExec")); | |
663 | if ( keyDDE.Exists() ) | |
664 | { | |
665 | const wxString ddeTopic = wxRegKey(keyDDE, wxT("topic")); | |
666 | ||
667 | // we only know the syntax of WWW_OpenURL DDE request for IE, | |
668 | // optimistically assume that all other browsers are compatible | |
669 | // with it | |
670 | wxString ddeCmd; | |
671 | bool ok = ddeTopic == wxT("WWW_OpenURL"); | |
672 | if ( ok ) | |
673 | { | |
588c80de | 674 | ddeCmd = keyDDE.QueryDefaultValue(); |
42d0df00 VZ |
675 | ok = !ddeCmd.empty(); |
676 | } | |
677 | ||
678 | if ( ok ) | |
679 | { | |
680 | // for WWW_OpenURL, the index of the window to open the URL | |
681 | // in is -1 (meaning "current") by default, replace it with | |
682 | // 0 which means "new" (see KB article 160957) | |
683 | ok = ddeCmd.Replace(wxT("-1"), wxT("0"), | |
684 | false /* only first occurence */) == 1; | |
685 | } | |
686 | ||
687 | if ( ok ) | |
688 | { | |
689 | // and also replace the parameters: the topic should | |
690 | // contain a placeholder for the URL | |
691 | ok = ddeCmd.Replace(wxT("%1"), url, false) == 1; | |
692 | } | |
693 | ||
694 | if ( ok ) | |
695 | { | |
696 | // try to send it the DDE request now but ignore the errors | |
697 | wxLogNull noLog; | |
698 | ||
699 | const wxString ddeServer = wxRegKey(keyDDE, wxT("application")); | |
700 | if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCmd) ) | |
701 | return true; | |
702 | ||
703 | // this is not necessarily an error: maybe browser is | |
704 | // simply not running, but no matter, in any case we're | |
705 | // going to launch it using ShellExecuteEx() below now and | |
706 | // we shouldn't try to open a new window if we open a new | |
707 | // browser anyhow | |
708 | } | |
709 | } | |
710 | } | |
711 | } | |
5ccb95f6 | 712 | #endif // wxUSE_IPC |
42d0df00 | 713 | |
7999124f VZ |
714 | WinStruct<SHELLEXECUTEINFO> sei; |
715 | sei.lpFile = url.c_str(); | |
716 | sei.lpVerb = _T("open"); | |
717 | sei.nShow = SW_SHOWNORMAL; | |
498a1eeb | 718 | |
7999124f | 719 | ::ShellExecuteEx(&sei); |
657a7545 | 720 | |
7999124f | 721 | const int nResult = (int) sei.hInstApp; |
498a1eeb | 722 | |
7999124f VZ |
723 | // Firefox returns file not found for some reason, so make an exception |
724 | // for it | |
725 | if ( nResult > 32 || nResult == SE_ERR_FNF ) | |
498a1eeb | 726 | { |
657a7545 | 727 | #ifdef __WXDEBUG__ |
498a1eeb | 728 | // Log something if SE_ERR_FNF happens |
7999124f VZ |
729 | if ( nResult == SE_ERR_FNF ) |
730 | wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?")); | |
731 | #endif // __WXDEBUG__ | |
732 | return true; | |
657a7545 | 733 | } |
f14d6dd1 JS |
734 | #elif defined(__WXMAC__) |
735 | OSStatus err; | |
736 | ICInstance inst; | |
fb743cab SC |
737 | long int startSel; |
738 | long int endSel; | |
f14d6dd1 JS |
739 | |
740 | err = ICStart(&inst, 'STKA'); // put your app creator code here | |
13a1e96f DS |
741 | if (err == noErr) |
742 | { | |
f14d6dd1 | 743 | #if !TARGET_CARBON |
13a1e96f | 744 | err = ICFindConfigFile(inst, 0, NULL); |
f14d6dd1 JS |
745 | #endif |
746 | if (err == noErr) | |
747 | { | |
748 | ConstStr255Param hint = 0; | |
749 | startSel = 0; | |
76b49cf4 | 750 | endSel = url.length(); |
f14d6dd1 JS |
751 | err = ICLaunchURL(inst, hint, url.fn_str(), endSel, &startSel, &endSel); |
752 | if (err != noErr) | |
753 | wxLogDebug(wxT("ICLaunchURL error %d"), (int) err); | |
754 | } | |
755 | ICStop(inst); | |
756 | return true; | |
757 | } | |
758 | else | |
759 | { | |
760 | wxLogDebug(wxT("ICStart error %d"), (int) err); | |
761 | return false; | |
762 | } | |
889fda0c RR |
763 | #else |
764 | // (non-Mac, non-MSW) | |
765 | ||
766 | #ifdef __UNIX__ | |
17ede0b1 RR |
767 | |
768 | wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment(); | |
769 | ||
770 | // GNOME and KDE desktops have some applications which should be always installed | |
771 | // together with their main parts, which give us the | |
772 | if (desktop == wxT("GNOME")) | |
889fda0c RR |
773 | { |
774 | wxArrayString errors; | |
775 | wxArrayString output; | |
17ede0b1 RR |
776 | |
777 | // gconf will tell us the path of the application to use as browser | |
778 | long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"), | |
779 | output, errors, wxEXEC_NODISABLE ); | |
889fda0c RR |
780 | if (res >= 0 && errors.GetCount() == 0) |
781 | { | |
782 | wxString cmd = output[0]; | |
783 | cmd << _T(' ') << url; | |
784 | if (wxExecute(cmd)) | |
785 | return true; | |
786 | } | |
787 | } | |
17ede0b1 RR |
788 | else if (desktop == wxT("KDE")) |
789 | { | |
790 | // kfmclient directly opens the given URL | |
791 | if (wxExecute(wxT("kfmclient openURL ") + url)) | |
792 | return true; | |
793 | } | |
889fda0c RR |
794 | #endif |
795 | ||
13a1e96f DS |
796 | bool ok = false; |
797 | wxString cmd; | |
798 | ||
1b1b5318 | 799 | #if wxUSE_MIMETYPE |
13a1e96f | 800 | wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html")); |
7999124f | 801 | if ( ft ) |
657a7545 | 802 | { |
7999124f VZ |
803 | wxString mt; |
804 | ft->GetMimeType(&mt); | |
498a1eeb | 805 | |
13a1e96f | 806 | ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url)); |
7999124f | 807 | delete ft; |
498a1eeb | 808 | } |
1b1b5318 | 809 | #endif // wxUSE_MIMETYPE |
13a1e96f DS |
810 | |
811 | if ( !ok || cmd.empty() ) | |
2830b4a4 | 812 | { |
13a1e96f DS |
813 | // fallback to checking for the BROWSER environment variable |
814 | cmd = wxGetenv(wxT("BROWSER")); | |
815 | if ( !cmd.empty() ) | |
816 | cmd << _T(' ') << url; | |
2830b4a4 | 817 | } |
13a1e96f DS |
818 | |
819 | ok = ( !cmd.empty() && wxExecute(cmd) ); | |
820 | if (ok) | |
821 | return ok; | |
822 | ||
823 | // no file type for HTML extension | |
824 | wxLogError(_T("No default application configured for HTML files.")); | |
825 | ||
7999124f | 826 | #endif // !wxUSE_MIMETYPE && !__WXMSW__ |
532d575b | 827 | |
7999124f VZ |
828 | wxLogSysError(_T("Failed to open URL \"%s\" in default browser."), |
829 | url.c_str()); | |
657a7545 | 830 | |
7999124f | 831 | return false; |
498a1eeb RN |
832 | } |
833 | ||
91b4c08d | 834 | // ---------------------------------------------------------------------------- |
7c072018 | 835 | // wxApp::Yield() wrappers for backwards compatibility |
91b4c08d VZ |
836 | // ---------------------------------------------------------------------------- |
837 | ||
7c072018 | 838 | bool wxYield() |
469e1e5c | 839 | { |
7c072018 | 840 | return wxTheApp && wxTheApp->Yield(); |
469e1e5c | 841 | } |
7c072018 VZ |
842 | |
843 | bool wxYieldIfNeeded() | |
469e1e5c | 844 | { |
cb719f2e | 845 | return wxTheApp && wxTheApp->Yield(true); |
469e1e5c | 846 | } |
7c072018 | 847 | |
4c3ebca9 MB |
848 | // Id generation |
849 | static long wxCurrentId = 100; | |
850 | ||
c838b68e | 851 | long wxNewId() |
4c3ebca9 | 852 | { |
c838b68e VS |
853 | // skip the part of IDs space that contains hard-coded values: |
854 | if (wxCurrentId == wxID_LOWEST) | |
855 | wxCurrentId = wxID_HIGHEST + 1; | |
856 | ||
857 | return wxCurrentId++; | |
4c3ebca9 MB |
858 | } |
859 | ||
860 | long | |
861 | wxGetCurrentId(void) { return wxCurrentId; } | |
862 | ||
863 | void | |
864 | wxRegisterId (long id) | |
865 | { | |
866 | if (id >= wxCurrentId) | |
867 | wxCurrentId = id + 1; | |
868 | } | |
869 | ||
c2ca375c VZ |
870 | #endif // wxUSE_BASE |
871 | ||
872 | // ============================================================================ | |
873 | // GUI-only functions from now on | |
874 | // ============================================================================ | |
875 | ||
876 | #if wxUSE_GUI | |
877 | ||
e90c1d2a | 878 | // ---------------------------------------------------------------------------- |
7c072018 | 879 | // Menu accelerators related functions |
e90c1d2a VZ |
880 | // ---------------------------------------------------------------------------- |
881 | ||
7c072018 | 882 | wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out) |
e90c1d2a | 883 | { |
9a6384ca | 884 | #if wxUSE_MENUS |
7c072018 | 885 | wxString s = wxMenuItem::GetLabelFromText(in); |
9a6384ca WS |
886 | #else |
887 | wxString str(in); | |
888 | wxString s = wxStripMenuCodes(str); | |
889 | #endif // wxUSE_MENUS | |
7c072018 VZ |
890 | if ( out ) |
891 | { | |
892 | // go smash their buffer if it's not big enough - I love char * params | |
893 | memcpy(out, s.c_str(), s.length() * sizeof(wxChar)); | |
894 | } | |
895 | else | |
896 | { | |
f526f752 MB |
897 | out = new wxChar[s.length() + 1]; |
898 | wxStrcpy(out, s.c_str()); | |
7c072018 VZ |
899 | } |
900 | ||
901 | return out; | |
e90c1d2a VZ |
902 | } |
903 | ||
74639764 | 904 | wxString wxStripMenuCodes(const wxString& in, int flags) |
e90c1d2a | 905 | { |
74639764 VZ |
906 | wxASSERT_MSG( flags, _T("this is useless to call without any flags") ); |
907 | ||
7c072018 | 908 | wxString out; |
79f585d9 | 909 | |
7c072018 VZ |
910 | size_t len = in.length(); |
911 | out.reserve(len); | |
79f585d9 | 912 | |
7c072018 VZ |
913 | for ( size_t n = 0; n < len; n++ ) |
914 | { | |
915 | wxChar ch = in[n]; | |
74639764 | 916 | if ( (flags & wxStrip_Mnemonics) && ch == _T('&') ) |
cd6ce4a9 | 917 | { |
7c072018 VZ |
918 | // skip it, it is used to introduce the accel char (or to quote |
919 | // itself in which case it should still be skipped): note that it | |
920 | // can't be the last character of the string | |
921 | if ( ++n == len ) | |
79f585d9 | 922 | { |
7c072018 VZ |
923 | wxLogDebug(_T("Invalid menu string '%s'"), in.c_str()); |
924 | } | |
925 | else | |
926 | { | |
927 | // use the next char instead | |
928 | ch = in[n]; | |
79f585d9 | 929 | } |
cd6ce4a9 | 930 | } |
74639764 | 931 | else if ( (flags & wxStrip_Accel) && ch == _T('\t') ) |
79f585d9 | 932 | { |
7c072018 VZ |
933 | // everything after TAB is accel string, exit the loop |
934 | break; | |
79f585d9 | 935 | } |
7c072018 VZ |
936 | |
937 | out += ch; | |
225fe9d6 VZ |
938 | } |
939 | ||
7c072018 | 940 | return out; |
cd6ce4a9 VZ |
941 | } |
942 | ||
cbc66a27 | 943 | // ---------------------------------------------------------------------------- |
7c072018 | 944 | // Window search functions |
cbc66a27 VZ |
945 | // ---------------------------------------------------------------------------- |
946 | ||
7c072018 VZ |
947 | /* |
948 | * If parent is non-NULL, look through children for a label or title | |
949 | * matching the specified string. If NULL, look through all top-level windows. | |
950 | * | |
951 | */ | |
e2a6f233 | 952 | |
7c072018 VZ |
953 | wxWindow * |
954 | wxFindWindowByLabel (const wxString& title, wxWindow * parent) | |
134677bd | 955 | { |
7c072018 VZ |
956 | return wxWindow::FindWindowByLabel( title, parent ); |
957 | } | |
b829bf55 | 958 | |
b829bf55 | 959 | |
7c072018 VZ |
960 | /* |
961 | * If parent is non-NULL, look through children for a name | |
962 | * matching the specified string. If NULL, look through all top-level windows. | |
963 | * | |
964 | */ | |
134677bd | 965 | |
7c072018 VZ |
966 | wxWindow * |
967 | wxFindWindowByName (const wxString& name, wxWindow * parent) | |
2c18f21d | 968 | { |
7c072018 | 969 | return wxWindow::FindWindowByName( name, parent ); |
2c18f21d VS |
970 | } |
971 | ||
cb719f2e | 972 | // Returns menu item id or wxNOT_FOUND if none. |
7c072018 VZ |
973 | int |
974 | wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString) | |
e2a6f233 | 975 | { |
7c072018 | 976 | #if wxUSE_MENUS |
9a6384ca WS |
977 | wxMenuBar *menuBar = frame->GetMenuBar (); |
978 | if ( menuBar ) | |
979 | return menuBar->FindMenuItem (menuString, itemString); | |
7c072018 | 980 | #endif // wxUSE_MENUS |
0fb67cd1 | 981 | |
9a6384ca | 982 | return wxNOT_FOUND; |
e2a6f233 JS |
983 | } |
984 | ||
7c072018 VZ |
985 | // Try to find the deepest child that contains 'pt'. |
986 | // We go backwards, to try to allow for controls that are spacially | |
987 | // within other controls, but are still siblings (e.g. buttons within | |
988 | // static boxes). Static boxes are likely to be created _before_ controls | |
989 | // that sit inside them. | |
990 | wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt) | |
e2a6f233 | 991 | { |
7c072018 VZ |
992 | if (!win->IsShown()) |
993 | return NULL; | |
0fb67cd1 | 994 | |
7c072018 VZ |
995 | // Hack for wxNotebook case: at least in wxGTK, all pages |
996 | // claim to be shown, so we must only deal with the selected one. | |
997 | #if wxUSE_NOTEBOOK | |
998 | if (win->IsKindOf(CLASSINFO(wxNotebook))) | |
e2a6f233 | 999 | { |
7c072018 VZ |
1000 | wxNotebook* nb = (wxNotebook*) win; |
1001 | int sel = nb->GetSelection(); | |
1002 | if (sel >= 0) | |
1003 | { | |
1004 | wxWindow* child = nb->GetPage(sel); | |
1005 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
1006 | if (foundWin) | |
1007 | return foundWin; | |
1008 | } | |
e2a6f233 | 1009 | } |
7c072018 | 1010 | #endif |
0fb67cd1 | 1011 | |
df5168c4 | 1012 | wxWindowList::compatibility_iterator node = win->GetChildren().GetLast(); |
7c072018 VZ |
1013 | while (node) |
1014 | { | |
1015 | wxWindow* child = node->GetData(); | |
1016 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
1017 | if (foundWin) | |
1018 | return foundWin; | |
1019 | node = node->GetPrevious(); | |
1020 | } | |
1021 | ||
1022 | wxPoint pos = win->GetPosition(); | |
1023 | wxSize sz = win->GetSize(); | |
7aa7d2d4 | 1024 | if ( !win->IsTopLevel() && win->GetParent() ) |
7c072018 VZ |
1025 | { |
1026 | pos = win->GetParent()->ClientToScreen(pos); | |
1027 | } | |
1028 | ||
1029 | wxRect rect(pos, sz); | |
22a35096 | 1030 | if (rect.Contains(pt)) |
7c072018 | 1031 | return win; |
622eb786 VZ |
1032 | |
1033 | return NULL; | |
0fb67cd1 VZ |
1034 | } |
1035 | ||
7c072018 | 1036 | wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt) |
0fb67cd1 | 1037 | { |
7c072018 VZ |
1038 | // Go backwards through the list since windows |
1039 | // on top are likely to have been appended most | |
1040 | // recently. | |
df5168c4 | 1041 | wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast(); |
7c072018 VZ |
1042 | while (node) |
1043 | { | |
1044 | wxWindow* win = node->GetData(); | |
1045 | wxWindow* found = wxFindWindowAtPoint(win, pt); | |
1046 | if (found) | |
1047 | return found; | |
1048 | node = node->GetPrevious(); | |
1049 | } | |
1050 | return NULL; | |
1051 | } | |
0fb67cd1 | 1052 | |
7c072018 VZ |
1053 | // ---------------------------------------------------------------------------- |
1054 | // GUI helpers | |
1055 | // ---------------------------------------------------------------------------- | |
0fb67cd1 | 1056 | |
7c072018 VZ |
1057 | /* |
1058 | * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp | |
1059 | * since otherwise the generic code may be pulled in unnecessarily. | |
1060 | */ | |
0fb67cd1 | 1061 | |
7c072018 | 1062 | #if wxUSE_MSGDLG |
0fb67cd1 | 1063 | |
7c072018 VZ |
1064 | int wxMessageBox(const wxString& message, const wxString& caption, long style, |
1065 | wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) ) | |
0fb67cd1 | 1066 | { |
53a6ac21 DS |
1067 | long decorated_style = style; |
1068 | ||
1069 | if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 ) | |
1070 | { | |
1071 | decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ; | |
1072 | } | |
1073 | ||
1074 | wxMessageDialog dialog(parent, message, caption, decorated_style); | |
0fb67cd1 | 1075 | |
7c072018 VZ |
1076 | int ans = dialog.ShowModal(); |
1077 | switch ( ans ) | |
1078 | { | |
1079 | case wxID_OK: | |
1080 | return wxOK; | |
1081 | case wxID_YES: | |
1082 | return wxYES; | |
1083 | case wxID_NO: | |
1084 | return wxNO; | |
1085 | case wxID_CANCEL: | |
1086 | return wxCANCEL; | |
1087 | } | |
0fb67cd1 | 1088 | |
7c072018 | 1089 | wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") ); |
0fb67cd1 | 1090 | |
7c072018 | 1091 | return wxCANCEL; |
e2a6f233 JS |
1092 | } |
1093 | ||
7c072018 | 1094 | #endif // wxUSE_MSGDLG |
518b5d2f | 1095 | |
7c072018 | 1096 | #if wxUSE_TEXTDLG |
518b5d2f | 1097 | |
7c072018 VZ |
1098 | wxString wxGetTextFromUser(const wxString& message, const wxString& caption, |
1099 | const wxString& defaultValue, wxWindow *parent, | |
13d13a9e | 1100 | wxCoord x, wxCoord y, bool centre ) |
7c072018 VZ |
1101 | { |
1102 | wxString str; | |
13d13a9e WS |
1103 | long style = wxTextEntryDialogStyle; |
1104 | ||
1105 | if (centre) | |
1106 | style |= wxCENTRE; | |
1107 | else | |
1108 | style &= ~wxCENTRE; | |
1109 | ||
1110 | wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y)); | |
1111 | ||
7c072018 VZ |
1112 | if (dialog.ShowModal() == wxID_OK) |
1113 | { | |
1114 | str = dialog.GetValue(); | |
1115 | } | |
0fb67cd1 | 1116 | |
7c072018 | 1117 | return str; |
518b5d2f VZ |
1118 | } |
1119 | ||
7c072018 VZ |
1120 | wxString wxGetPasswordFromUser(const wxString& message, |
1121 | const wxString& caption, | |
1122 | const wxString& defaultValue, | |
b3bb2a74 KH |
1123 | wxWindow *parent, |
1124 | wxCoord x, wxCoord y, bool centre ) | |
96c5bd7f | 1125 | { |
7c072018 | 1126 | wxString str; |
b3bb2a74 KH |
1127 | long style = wxTextEntryDialogStyle; |
1128 | ||
1129 | if (centre) | |
1130 | style |= wxCENTRE; | |
1131 | else | |
1132 | style &= ~wxCENTRE; | |
1133 | ||
12cfa304 KH |
1134 | wxPasswordEntryDialog dialog(parent, message, caption, defaultValue, |
1135 | style, wxPoint(x, y)); | |
7c072018 VZ |
1136 | if ( dialog.ShowModal() == wxID_OK ) |
1137 | { | |
1138 | str = dialog.GetValue(); | |
1139 | } | |
96c5bd7f | 1140 | |
7c072018 VZ |
1141 | return str; |
1142 | } | |
96c5bd7f | 1143 | |
7c072018 | 1144 | #endif // wxUSE_TEXTDLG |
96c5bd7f | 1145 | |
7c072018 | 1146 | #if wxUSE_COLOURDLG |
96c5bd7f | 1147 | |
f14d6dd1 | 1148 | wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit, const wxString& caption) |
c51deffc | 1149 | { |
7c072018 | 1150 | wxColourData data; |
cb719f2e | 1151 | data.SetChooseFull(true); |
7c072018 VZ |
1152 | if ( colInit.Ok() ) |
1153 | { | |
1154 | data.SetColour((wxColour &)colInit); // const_cast | |
1155 | } | |
c51deffc | 1156 | |
7c072018 VZ |
1157 | wxColour colRet; |
1158 | wxColourDialog dialog(parent, &data); | |
76b49cf4 | 1159 | if (!caption.empty()) |
f14d6dd1 | 1160 | dialog.SetTitle(caption); |
7c072018 VZ |
1161 | if ( dialog.ShowModal() == wxID_OK ) |
1162 | { | |
1163 | colRet = dialog.GetColourData().GetColour(); | |
1164 | } | |
1165 | //else: leave it invalid | |
1166 | ||
1167 | return colRet; | |
c51deffc | 1168 | } |
bc385ba9 | 1169 | |
7c072018 | 1170 | #endif // wxUSE_COLOURDLG |
bc385ba9 | 1171 | |
7c072018 VZ |
1172 | #if wxUSE_FONTDLG |
1173 | ||
f14d6dd1 | 1174 | wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption) |
bc385ba9 | 1175 | { |
7c072018 VZ |
1176 | wxFontData data; |
1177 | if ( fontInit.Ok() ) | |
bc385ba9 | 1178 | { |
7c072018 VZ |
1179 | data.SetInitialFont(fontInit); |
1180 | } | |
bc385ba9 | 1181 | |
7c072018 VZ |
1182 | wxFont fontRet; |
1183 | wxFontDialog dialog(parent, data); | |
76b49cf4 | 1184 | if (!caption.empty()) |
f14d6dd1 | 1185 | dialog.SetTitle(caption); |
7c072018 VZ |
1186 | if ( dialog.ShowModal() == wxID_OK ) |
1187 | { | |
1188 | fontRet = dialog.GetFontData().GetChosenFont(); | |
1189 | } | |
1190 | //else: leave it invalid | |
bc385ba9 | 1191 | |
7c072018 | 1192 | return fontRet; |
bc385ba9 VZ |
1193 | } |
1194 | ||
7c072018 | 1195 | #endif // wxUSE_FONTDLG |
2b5f62a0 | 1196 | |
7c072018 VZ |
1197 | // ---------------------------------------------------------------------------- |
1198 | // wxSafeYield and supporting functions | |
1199 | // ---------------------------------------------------------------------------- | |
2b5f62a0 | 1200 | |
7c072018 VZ |
1201 | void wxEnableTopLevelWindows(bool enable) |
1202 | { | |
df5168c4 | 1203 | wxWindowList::compatibility_iterator node; |
7c072018 VZ |
1204 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) |
1205 | node->GetData()->Enable(enable); | |
1206 | } | |
2b5f62a0 | 1207 | |
7c072018 VZ |
1208 | wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip) |
1209 | { | |
1210 | // remember the top level windows which were already disabled, so that we | |
1211 | // don't reenable them later | |
1212 | m_winDisabled = NULL; | |
1213 | ||
df5168c4 | 1214 | wxWindowList::compatibility_iterator node; |
7c072018 | 1215 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) |
2b5f62a0 | 1216 | { |
7c072018 VZ |
1217 | wxWindow *winTop = node->GetData(); |
1218 | if ( winTop == winToSkip ) | |
1219 | continue; | |
2b5f62a0 | 1220 | |
7c072018 VZ |
1221 | // we don't need to disable the hidden or already disabled windows |
1222 | if ( winTop->IsEnabled() && winTop->IsShown() ) | |
2b5f62a0 | 1223 | { |
7c072018 | 1224 | winTop->Disable(); |
2b5f62a0 VZ |
1225 | } |
1226 | else | |
1227 | { | |
7c072018 VZ |
1228 | if ( !m_winDisabled ) |
1229 | { | |
1230 | m_winDisabled = new wxWindowList; | |
1231 | } | |
1232 | ||
1233 | m_winDisabled->Append(winTop); | |
2b5f62a0 VZ |
1234 | } |
1235 | } | |
2b5f62a0 VZ |
1236 | } |
1237 | ||
7c072018 | 1238 | wxWindowDisabler::~wxWindowDisabler() |
cd6ce4a9 | 1239 | { |
df5168c4 | 1240 | wxWindowList::compatibility_iterator node; |
7c072018 | 1241 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) |
cd6ce4a9 | 1242 | { |
7c072018 VZ |
1243 | wxWindow *winTop = node->GetData(); |
1244 | if ( !m_winDisabled || !m_winDisabled->Find(winTop) ) | |
cd6ce4a9 | 1245 | { |
7c072018 | 1246 | winTop->Enable(); |
cd6ce4a9 | 1247 | } |
7c072018 | 1248 | //else: had been already disabled, don't reenable |
cd6ce4a9 | 1249 | } |
f6bcfd97 | 1250 | |
7c072018 | 1251 | delete m_winDisabled; |
f6bcfd97 BP |
1252 | } |
1253 | ||
7c072018 VZ |
1254 | // Yield to other apps/messages and disable user input to all windows except |
1255 | // the given one | |
1256 | bool wxSafeYield(wxWindow *win, bool onlyIfNeeded) | |
f6bcfd97 | 1257 | { |
7c072018 | 1258 | wxWindowDisabler wd(win); |
21709999 | 1259 | |
7c072018 VZ |
1260 | bool rc; |
1261 | if (onlyIfNeeded) | |
1262 | rc = wxYieldIfNeeded(); | |
1263 | else | |
1264 | rc = wxYield(); | |
8461e4c2 | 1265 | |
7c072018 | 1266 | return rc; |
8461e4c2 VZ |
1267 | } |
1268 | ||
7c072018 VZ |
1269 | // Don't synthesize KeyUp events holding down a key and producing KeyDown |
1270 | // events with autorepeat. On by default and always on in wxMSW. wxGTK version | |
1271 | // in utilsgtk.cpp. | |
1272 | #ifndef __WXGTK__ | |
1273 | bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) ) | |
8461e4c2 | 1274 | { |
cb719f2e | 1275 | return true; // detectable auto-repeat is the only mode MSW supports |
8461e4c2 | 1276 | } |
7c072018 VZ |
1277 | #endif // !wxGTK |
1278 | ||
1279 | #endif // wxUSE_GUI |