]>
Commit | Line | Data |
---|---|---|
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 | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && !defined(__EMX__) | |
21 | // Some older compilers (such as EMX) cannot handle | |
22 | // #pragma interface/implementation correctly, iff | |
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. | |
28 | #pragma implementation "utils.h" | |
29 | #endif | |
30 | ||
31 | // For compilers that support precompilation, includes "wx.h". | |
32 | #include "wx/wxprec.h" | |
33 | ||
34 | #ifdef __BORLANDC__ | |
35 | #pragma hdrstop | |
36 | #endif | |
37 | ||
38 | #ifndef WX_PRECOMP | |
39 | #include "wx/app.h" | |
40 | #include "wx/string.h" | |
41 | #include "wx/utils.h" | |
42 | #include "wx/intl.h" | |
43 | #include "wx/log.h" | |
44 | ||
45 | #if wxUSE_GUI | |
46 | #include "wx/window.h" | |
47 | #include "wx/frame.h" | |
48 | #include "wx/menu.h" | |
49 | #include "wx/msgdlg.h" | |
50 | #include "wx/textdlg.h" | |
51 | #include "wx/textctrl.h" // for wxTE_PASSWORD | |
52 | #if wxUSE_ACCEL | |
53 | #include "wx/menuitem.h" | |
54 | #include "wx/accel.h" | |
55 | #endif // wxUSE_ACCEL | |
56 | #endif // wxUSE_GUI | |
57 | #endif // WX_PRECOMP | |
58 | ||
59 | #include "wx/apptrait.h" | |
60 | ||
61 | #include "wx/process.h" | |
62 | #include "wx/txtstrm.h" | |
63 | ||
64 | #if defined(__WXWINCE__) && wxUSE_DATETIME | |
65 | #include "wx/datetime.h" | |
66 | #endif | |
67 | ||
68 | #include <ctype.h> | |
69 | #include <stdio.h> | |
70 | #include <stdlib.h> | |
71 | #include <string.h> | |
72 | ||
73 | #if !defined(__WATCOMC__) | |
74 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) | |
75 | #include <errno.h> | |
76 | #endif | |
77 | #endif | |
78 | ||
79 | #if wxUSE_GUI | |
80 | #include "wx/colordlg.h" | |
81 | #include "wx/fontdlg.h" | |
82 | #include "wx/notebook.h" | |
83 | #include "wx/frame.h" | |
84 | #include "wx/statusbr.h" | |
85 | #endif // wxUSE_GUI | |
86 | ||
87 | #ifndef __WXWINCE__ | |
88 | #include <time.h> | |
89 | #else | |
90 | #include "wx/msw/wince/time.h" | |
91 | #endif | |
92 | ||
93 | #if !defined(__MWERKS__) && !defined(__WXWINCE__) | |
94 | #include <sys/types.h> | |
95 | #include <sys/stat.h> | |
96 | #endif | |
97 | ||
98 | #ifdef __WXMSW__ | |
99 | #include "wx/msw/private.h" | |
100 | #endif | |
101 | ||
102 | #if wxUSE_BASE | |
103 | ||
104 | // ---------------------------------------------------------------------------- | |
105 | // common data | |
106 | // ---------------------------------------------------------------------------- | |
107 | ||
108 | #if WXWIN_COMPATIBILITY_2_2 | |
109 | const wxChar *wxInternalErrorStr = wxT("wxWidgets Internal Error"); | |
110 | const wxChar *wxFatalErrorStr = wxT("wxWidgets Fatal Error"); | |
111 | #endif // WXWIN_COMPATIBILITY_2_2 | |
112 | ||
113 | // ============================================================================ | |
114 | // implementation | |
115 | // ============================================================================ | |
116 | ||
117 | #if WXWIN_COMPATIBILITY_2_4 | |
118 | ||
119 | wxChar * | |
120 | copystring (const wxChar *s) | |
121 | { | |
122 | if (s == NULL) s = wxT(""); | |
123 | size_t len = wxStrlen (s) + 1; | |
124 | ||
125 | wxChar *news = new wxChar[len]; | |
126 | memcpy (news, s, len * sizeof(wxChar)); // Should be the fastest | |
127 | ||
128 | return news; | |
129 | } | |
130 | ||
131 | #endif // WXWIN_COMPATIBILITY_2_4 | |
132 | ||
133 | // ---------------------------------------------------------------------------- | |
134 | // String <-> Number conversions (deprecated) | |
135 | // ---------------------------------------------------------------------------- | |
136 | ||
137 | #if WXWIN_COMPATIBILITY_2_4 | |
138 | ||
139 | WXDLLIMPEXP_DATA_BASE(const wxChar *) wxFloatToStringStr = wxT("%.2f"); | |
140 | WXDLLIMPEXP_DATA_BASE(const wxChar *) wxDoubleToStringStr = wxT("%.2f"); | |
141 | ||
142 | void | |
143 | StringToFloat (const wxChar *s, float *number) | |
144 | { | |
145 | if (s && *s && number) | |
146 | *number = (float) wxStrtod (s, (wxChar **) NULL); | |
147 | } | |
148 | ||
149 | void | |
150 | StringToDouble (const wxChar *s, double *number) | |
151 | { | |
152 | if (s && *s && number) | |
153 | *number = wxStrtod (s, (wxChar **) NULL); | |
154 | } | |
155 | ||
156 | wxChar * | |
157 | FloatToString (float number, const wxChar *fmt) | |
158 | { | |
159 | static wxChar buf[256]; | |
160 | ||
161 | wxSprintf (buf, fmt, number); | |
162 | return buf; | |
163 | } | |
164 | ||
165 | wxChar * | |
166 | DoubleToString (double number, const wxChar *fmt) | |
167 | { | |
168 | static wxChar buf[256]; | |
169 | ||
170 | wxSprintf (buf, fmt, number); | |
171 | return buf; | |
172 | } | |
173 | ||
174 | void | |
175 | StringToInt (const wxChar *s, int *number) | |
176 | { | |
177 | if (s && *s && number) | |
178 | *number = (int) wxStrtol (s, (wxChar **) NULL, 10); | |
179 | } | |
180 | ||
181 | void | |
182 | StringToLong (const wxChar *s, long *number) | |
183 | { | |
184 | if (s && *s && number) | |
185 | *number = wxStrtol (s, (wxChar **) NULL, 10); | |
186 | } | |
187 | ||
188 | wxChar * | |
189 | IntToString (int number) | |
190 | { | |
191 | static wxChar buf[20]; | |
192 | ||
193 | wxSprintf (buf, wxT("%d"), number); | |
194 | return buf; | |
195 | } | |
196 | ||
197 | wxChar * | |
198 | LongToString (long number) | |
199 | { | |
200 | static wxChar buf[20]; | |
201 | ||
202 | wxSprintf (buf, wxT("%ld"), number); | |
203 | return buf; | |
204 | } | |
205 | ||
206 | #endif // WXWIN_COMPATIBILITY_2_4 | |
207 | ||
208 | // Array used in DecToHex conversion routine. | |
209 | static wxChar hexArray[] = wxT("0123456789ABCDEF"); | |
210 | ||
211 | // Convert 2-digit hex number to decimal | |
212 | int wxHexToDec(const wxString& buf) | |
213 | { | |
214 | int firstDigit, secondDigit; | |
215 | ||
216 | if (buf.GetChar(0) >= wxT('A')) | |
217 | firstDigit = buf.GetChar(0) - wxT('A') + 10; | |
218 | else | |
219 | firstDigit = buf.GetChar(0) - wxT('0'); | |
220 | ||
221 | if (buf.GetChar(1) >= wxT('A')) | |
222 | secondDigit = buf.GetChar(1) - wxT('A') + 10; | |
223 | else | |
224 | secondDigit = buf.GetChar(1) - wxT('0'); | |
225 | ||
226 | return (firstDigit & 0xF) * 16 + (secondDigit & 0xF ); | |
227 | } | |
228 | ||
229 | // Convert decimal integer to 2-character hex string | |
230 | void wxDecToHex(int dec, wxChar *buf) | |
231 | { | |
232 | int firstDigit = (int)(dec/16.0); | |
233 | int secondDigit = (int)(dec - (firstDigit*16.0)); | |
234 | buf[0] = hexArray[firstDigit]; | |
235 | buf[1] = hexArray[secondDigit]; | |
236 | buf[2] = 0; | |
237 | } | |
238 | ||
239 | // Convert decimal integer to 2-character hex string | |
240 | wxString wxDecToHex(int dec) | |
241 | { | |
242 | wxChar buf[3]; | |
243 | wxDecToHex(dec, buf); | |
244 | return wxString(buf); | |
245 | } | |
246 | ||
247 | // ---------------------------------------------------------------------------- | |
248 | // misc functions | |
249 | // ---------------------------------------------------------------------------- | |
250 | ||
251 | // Return the current date/time | |
252 | wxString wxNow() | |
253 | { | |
254 | #ifdef __WXWINCE__ | |
255 | #if wxUSE_DATETIME | |
256 | wxDateTime now = wxDateTime::Now(); | |
257 | return now.Format(); | |
258 | #else | |
259 | return wxEmptyString; | |
260 | #endif | |
261 | #else | |
262 | time_t now = time((time_t *) NULL); | |
263 | char *date = ctime(&now); | |
264 | date[24] = '\0'; | |
265 | return wxString::FromAscii(date); | |
266 | #endif | |
267 | } | |
268 | ||
269 | void wxUsleep(unsigned long milliseconds) | |
270 | { | |
271 | wxMilliSleep(milliseconds); | |
272 | } | |
273 | ||
274 | const wxChar *wxGetInstallPrefix() | |
275 | { | |
276 | wxString prefix; | |
277 | ||
278 | if ( wxGetEnv(wxT("WXPREFIX"), &prefix) ) | |
279 | return prefix.c_str(); | |
280 | ||
281 | #ifdef wxINSTALL_PREFIX | |
282 | return wxT(wxINSTALL_PREFIX); | |
283 | #else | |
284 | return wxT(""); | |
285 | #endif | |
286 | } | |
287 | ||
288 | wxString wxGetDataDir() | |
289 | { | |
290 | wxString dir = wxGetInstallPrefix(); | |
291 | dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx"); | |
292 | return dir; | |
293 | } | |
294 | ||
295 | int wxGetOsVersion(int *verMaj, int *verMin) | |
296 | { | |
297 | // we want this function to work even if there is no wxApp | |
298 | wxConsoleAppTraits traitsConsole; | |
299 | wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; | |
300 | if ( ! traits ) | |
301 | traits = &traitsConsole; | |
302 | ||
303 | wxToolkitInfo& info = traits->GetToolkitInfo(); | |
304 | if ( verMaj ) | |
305 | *verMaj = info.versionMajor; | |
306 | if ( verMin ) | |
307 | *verMin = info.versionMinor; | |
308 | return info.os; | |
309 | } | |
310 | ||
311 | // ---------------------------------------------------------------------------- | |
312 | // network and user id functions | |
313 | // ---------------------------------------------------------------------------- | |
314 | ||
315 | // Get Full RFC822 style email address | |
316 | bool wxGetEmailAddress(wxChar *address, int maxSize) | |
317 | { | |
318 | wxString email = wxGetEmailAddress(); | |
319 | if ( !email ) | |
320 | return false; | |
321 | ||
322 | wxStrncpy(address, email, maxSize - 1); | |
323 | address[maxSize - 1] = wxT('\0'); | |
324 | ||
325 | return true; | |
326 | } | |
327 | ||
328 | wxString wxGetEmailAddress() | |
329 | { | |
330 | wxString email; | |
331 | ||
332 | wxString host = wxGetFullHostName(); | |
333 | if ( !host.IsEmpty() ) | |
334 | { | |
335 | wxString user = wxGetUserId(); | |
336 | if ( !user.IsEmpty() ) | |
337 | { | |
338 | email << user << wxT('@') << host; | |
339 | } | |
340 | } | |
341 | ||
342 | return email; | |
343 | } | |
344 | ||
345 | wxString wxGetUserId() | |
346 | { | |
347 | static const int maxLoginLen = 256; // FIXME arbitrary number | |
348 | ||
349 | wxString buf; | |
350 | bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen); | |
351 | ||
352 | if ( !ok ) | |
353 | buf.Empty(); | |
354 | ||
355 | return buf; | |
356 | } | |
357 | ||
358 | wxString wxGetUserName() | |
359 | { | |
360 | static const int maxUserNameLen = 1024; // FIXME arbitrary number | |
361 | ||
362 | wxString buf; | |
363 | bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen); | |
364 | ||
365 | if ( !ok ) | |
366 | buf.Empty(); | |
367 | ||
368 | return buf; | |
369 | } | |
370 | ||
371 | wxString wxGetHostName() | |
372 | { | |
373 | static const size_t hostnameSize = 257; | |
374 | ||
375 | wxString buf; | |
376 | bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); | |
377 | ||
378 | if ( !ok ) | |
379 | buf.Empty(); | |
380 | ||
381 | return buf; | |
382 | } | |
383 | ||
384 | wxString wxGetFullHostName() | |
385 | { | |
386 | static const size_t hostnameSize = 257; | |
387 | ||
388 | wxString buf; | |
389 | bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize); | |
390 | ||
391 | if ( !ok ) | |
392 | buf.Empty(); | |
393 | ||
394 | return buf; | |
395 | } | |
396 | ||
397 | wxString wxGetHomeDir() | |
398 | { | |
399 | wxString home; | |
400 | wxGetHomeDir(&home); | |
401 | ||
402 | return home; | |
403 | } | |
404 | ||
405 | #if 0 | |
406 | ||
407 | wxString wxGetCurrentDir() | |
408 | { | |
409 | wxString dir; | |
410 | size_t len = 1024; | |
411 | bool ok; | |
412 | do | |
413 | { | |
414 | ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL; | |
415 | dir.UngetWriteBuf(); | |
416 | ||
417 | if ( !ok ) | |
418 | { | |
419 | if ( errno != ERANGE ) | |
420 | { | |
421 | wxLogSysError(_T("Failed to get current directory")); | |
422 | ||
423 | return wxEmptyString; | |
424 | } | |
425 | else | |
426 | { | |
427 | // buffer was too small, retry with a larger one | |
428 | len *= 2; | |
429 | } | |
430 | } | |
431 | //else: ok | |
432 | } while ( !ok ); | |
433 | ||
434 | return dir; | |
435 | } | |
436 | ||
437 | #endif // 0 | |
438 | ||
439 | // ---------------------------------------------------------------------------- | |
440 | // wxExecute | |
441 | // ---------------------------------------------------------------------------- | |
442 | ||
443 | // wxDoExecuteWithCapture() helper: reads an entire stream into one array | |
444 | // | |
445 | // returns true if ok, false if error | |
446 | #if wxUSE_STREAMS | |
447 | static bool ReadAll(wxInputStream *is, wxArrayString& output) | |
448 | { | |
449 | wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") ); | |
450 | ||
451 | // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state | |
452 | is->Reset(); | |
453 | ||
454 | wxTextInputStream tis(*is); | |
455 | ||
456 | bool cont = true; | |
457 | while ( cont ) | |
458 | { | |
459 | wxString line = tis.ReadLine(); | |
460 | if ( is->Eof() ) | |
461 | break; | |
462 | ||
463 | if ( !*is ) | |
464 | { | |
465 | cont = false; | |
466 | } | |
467 | else | |
468 | { | |
469 | output.Add(line); | |
470 | } | |
471 | } | |
472 | ||
473 | return cont; | |
474 | } | |
475 | #endif // wxUSE_STREAMS | |
476 | ||
477 | // this is a private function because it hasn't a clean interface: the first | |
478 | // array is passed by reference, the second by pointer - instead we have 2 | |
479 | // public versions of wxExecute() below | |
480 | static long wxDoExecuteWithCapture(const wxString& command, | |
481 | wxArrayString& output, | |
482 | wxArrayString* error) | |
483 | { | |
484 | // create a wxProcess which will capture the output | |
485 | wxProcess *process = new wxProcess; | |
486 | process->Redirect(); | |
487 | ||
488 | long rc = wxExecute(command, wxEXEC_SYNC, process); | |
489 | ||
490 | #if wxUSE_STREAMS | |
491 | if ( rc != -1 ) | |
492 | { | |
493 | if ( !ReadAll(process->GetInputStream(), output) ) | |
494 | rc = -1; | |
495 | ||
496 | if ( error ) | |
497 | { | |
498 | if ( !ReadAll(process->GetErrorStream(), *error) ) | |
499 | rc = -1; | |
500 | } | |
501 | ||
502 | } | |
503 | #else | |
504 | wxUnusedVar(output); | |
505 | wxUnusedVar(error); | |
506 | #endif // wxUSE_STREAMS/!wxUSE_STREAMS | |
507 | ||
508 | delete process; | |
509 | ||
510 | return rc; | |
511 | } | |
512 | ||
513 | long wxExecute(const wxString& command, wxArrayString& output) | |
514 | { | |
515 | return wxDoExecuteWithCapture(command, output, NULL); | |
516 | } | |
517 | ||
518 | long wxExecute(const wxString& command, | |
519 | wxArrayString& output, | |
520 | wxArrayString& error) | |
521 | { | |
522 | return wxDoExecuteWithCapture(command, output, &error); | |
523 | } | |
524 | ||
525 | // ---------------------------------------------------------------------------- | |
526 | // wxApp::Yield() wrappers for backwards compatibility | |
527 | // ---------------------------------------------------------------------------- | |
528 | ||
529 | bool wxYield() | |
530 | { | |
531 | return wxTheApp && wxTheApp->Yield(); | |
532 | } | |
533 | ||
534 | bool wxYieldIfNeeded() | |
535 | { | |
536 | return wxTheApp && wxTheApp->Yield(true); | |
537 | } | |
538 | ||
539 | #endif // wxUSE_BASE | |
540 | ||
541 | // ============================================================================ | |
542 | // GUI-only functions from now on | |
543 | // ============================================================================ | |
544 | ||
545 | #if wxUSE_GUI | |
546 | ||
547 | // Id generation | |
548 | static long wxCurrentId = 100; | |
549 | ||
550 | long | |
551 | wxNewId (void) | |
552 | { | |
553 | return wxCurrentId++; | |
554 | } | |
555 | ||
556 | long | |
557 | wxGetCurrentId(void) { return wxCurrentId; } | |
558 | ||
559 | void | |
560 | wxRegisterId (long id) | |
561 | { | |
562 | if (id >= wxCurrentId) | |
563 | wxCurrentId = id + 1; | |
564 | } | |
565 | ||
566 | #if wxUSE_MENUS | |
567 | ||
568 | // ---------------------------------------------------------------------------- | |
569 | // Menu accelerators related functions | |
570 | // ---------------------------------------------------------------------------- | |
571 | ||
572 | wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out) | |
573 | { | |
574 | wxString s = wxMenuItem::GetLabelFromText(in); | |
575 | if ( out ) | |
576 | { | |
577 | // go smash their buffer if it's not big enough - I love char * params | |
578 | memcpy(out, s.c_str(), s.length() * sizeof(wxChar)); | |
579 | } | |
580 | else | |
581 | { | |
582 | // MYcopystring - for easier search... | |
583 | out = new wxChar[s.length() + 1]; | |
584 | wxStrcpy(out, s.c_str()); | |
585 | } | |
586 | ||
587 | return out; | |
588 | } | |
589 | ||
590 | wxString wxStripMenuCodes(const wxString& in) | |
591 | { | |
592 | wxString out; | |
593 | ||
594 | size_t len = in.length(); | |
595 | out.reserve(len); | |
596 | ||
597 | for ( size_t n = 0; n < len; n++ ) | |
598 | { | |
599 | wxChar ch = in[n]; | |
600 | if ( ch == _T('&') ) | |
601 | { | |
602 | // skip it, it is used to introduce the accel char (or to quote | |
603 | // itself in which case it should still be skipped): note that it | |
604 | // can't be the last character of the string | |
605 | if ( ++n == len ) | |
606 | { | |
607 | wxLogDebug(_T("Invalid menu string '%s'"), in.c_str()); | |
608 | } | |
609 | else | |
610 | { | |
611 | // use the next char instead | |
612 | ch = in[n]; | |
613 | } | |
614 | } | |
615 | else if ( ch == _T('\t') ) | |
616 | { | |
617 | // everything after TAB is accel string, exit the loop | |
618 | break; | |
619 | } | |
620 | ||
621 | out += ch; | |
622 | } | |
623 | ||
624 | return out; | |
625 | } | |
626 | ||
627 | #endif // wxUSE_MENUS | |
628 | ||
629 | // ---------------------------------------------------------------------------- | |
630 | // Window search functions | |
631 | // ---------------------------------------------------------------------------- | |
632 | ||
633 | /* | |
634 | * If parent is non-NULL, look through children for a label or title | |
635 | * matching the specified string. If NULL, look through all top-level windows. | |
636 | * | |
637 | */ | |
638 | ||
639 | wxWindow * | |
640 | wxFindWindowByLabel (const wxString& title, wxWindow * parent) | |
641 | { | |
642 | return wxWindow::FindWindowByLabel( title, parent ); | |
643 | } | |
644 | ||
645 | ||
646 | /* | |
647 | * If parent is non-NULL, look through children for a name | |
648 | * matching the specified string. If NULL, look through all top-level windows. | |
649 | * | |
650 | */ | |
651 | ||
652 | wxWindow * | |
653 | wxFindWindowByName (const wxString& name, wxWindow * parent) | |
654 | { | |
655 | return wxWindow::FindWindowByName( name, parent ); | |
656 | } | |
657 | ||
658 | // Returns menu item id or wxNOT_FOUND if none. | |
659 | int | |
660 | wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString) | |
661 | { | |
662 | #if wxUSE_MENUS | |
663 | wxMenuBar *menuBar = frame->GetMenuBar (); | |
664 | if ( menuBar ) | |
665 | return menuBar->FindMenuItem (menuString, itemString); | |
666 | #endif // wxUSE_MENUS | |
667 | ||
668 | return wxNOT_FOUND; | |
669 | } | |
670 | ||
671 | // Try to find the deepest child that contains 'pt'. | |
672 | // We go backwards, to try to allow for controls that are spacially | |
673 | // within other controls, but are still siblings (e.g. buttons within | |
674 | // static boxes). Static boxes are likely to be created _before_ controls | |
675 | // that sit inside them. | |
676 | wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt) | |
677 | { | |
678 | if (!win->IsShown()) | |
679 | return NULL; | |
680 | ||
681 | // Hack for wxNotebook case: at least in wxGTK, all pages | |
682 | // claim to be shown, so we must only deal with the selected one. | |
683 | #if wxUSE_NOTEBOOK | |
684 | if (win->IsKindOf(CLASSINFO(wxNotebook))) | |
685 | { | |
686 | wxNotebook* nb = (wxNotebook*) win; | |
687 | int sel = nb->GetSelection(); | |
688 | if (sel >= 0) | |
689 | { | |
690 | wxWindow* child = nb->GetPage(sel); | |
691 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
692 | if (foundWin) | |
693 | return foundWin; | |
694 | } | |
695 | } | |
696 | #endif | |
697 | ||
698 | wxWindowList::compatibility_iterator node = win->GetChildren().GetLast(); | |
699 | while (node) | |
700 | { | |
701 | wxWindow* child = node->GetData(); | |
702 | wxWindow* foundWin = wxFindWindowAtPoint(child, pt); | |
703 | if (foundWin) | |
704 | return foundWin; | |
705 | node = node->GetPrevious(); | |
706 | } | |
707 | ||
708 | wxPoint pos = win->GetPosition(); | |
709 | wxSize sz = win->GetSize(); | |
710 | if (win->GetParent()) | |
711 | { | |
712 | pos = win->GetParent()->ClientToScreen(pos); | |
713 | } | |
714 | ||
715 | wxRect rect(pos, sz); | |
716 | if (rect.Inside(pt)) | |
717 | return win; | |
718 | else | |
719 | return NULL; | |
720 | } | |
721 | ||
722 | wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt) | |
723 | { | |
724 | // Go backwards through the list since windows | |
725 | // on top are likely to have been appended most | |
726 | // recently. | |
727 | wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast(); | |
728 | while (node) | |
729 | { | |
730 | wxWindow* win = node->GetData(); | |
731 | wxWindow* found = wxFindWindowAtPoint(win, pt); | |
732 | if (found) | |
733 | return found; | |
734 | node = node->GetPrevious(); | |
735 | } | |
736 | return NULL; | |
737 | } | |
738 | ||
739 | // ---------------------------------------------------------------------------- | |
740 | // GUI helpers | |
741 | // ---------------------------------------------------------------------------- | |
742 | ||
743 | /* | |
744 | * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp | |
745 | * since otherwise the generic code may be pulled in unnecessarily. | |
746 | */ | |
747 | ||
748 | #if wxUSE_MSGDLG | |
749 | ||
750 | int wxMessageBox(const wxString& message, const wxString& caption, long style, | |
751 | wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) ) | |
752 | { | |
753 | long decorated_style = style; | |
754 | ||
755 | if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 ) | |
756 | { | |
757 | decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ; | |
758 | } | |
759 | ||
760 | wxMessageDialog dialog(parent, message, caption, decorated_style); | |
761 | ||
762 | int ans = dialog.ShowModal(); | |
763 | switch ( ans ) | |
764 | { | |
765 | case wxID_OK: | |
766 | return wxOK; | |
767 | case wxID_YES: | |
768 | return wxYES; | |
769 | case wxID_NO: | |
770 | return wxNO; | |
771 | case wxID_CANCEL: | |
772 | return wxCANCEL; | |
773 | } | |
774 | ||
775 | wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") ); | |
776 | ||
777 | return wxCANCEL; | |
778 | } | |
779 | ||
780 | #endif // wxUSE_MSGDLG | |
781 | ||
782 | #if wxUSE_TEXTDLG | |
783 | ||
784 | wxString wxGetTextFromUser(const wxString& message, const wxString& caption, | |
785 | const wxString& defaultValue, wxWindow *parent, | |
786 | wxCoord x, wxCoord y, bool centre ) | |
787 | { | |
788 | wxString str; | |
789 | long style = wxTextEntryDialogStyle; | |
790 | ||
791 | if (centre) | |
792 | style |= wxCENTRE; | |
793 | else | |
794 | style &= ~wxCENTRE; | |
795 | ||
796 | wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y)); | |
797 | ||
798 | if (dialog.ShowModal() == wxID_OK) | |
799 | { | |
800 | str = dialog.GetValue(); | |
801 | } | |
802 | ||
803 | return str; | |
804 | } | |
805 | ||
806 | wxString wxGetPasswordFromUser(const wxString& message, | |
807 | const wxString& caption, | |
808 | const wxString& defaultValue, | |
809 | wxWindow *parent) | |
810 | { | |
811 | wxString str; | |
812 | wxTextEntryDialog dialog(parent, message, caption, defaultValue, | |
813 | wxOK | wxCANCEL | wxTE_PASSWORD); | |
814 | if ( dialog.ShowModal() == wxID_OK ) | |
815 | { | |
816 | str = dialog.GetValue(); | |
817 | } | |
818 | ||
819 | return str; | |
820 | } | |
821 | ||
822 | #endif // wxUSE_TEXTDLG | |
823 | ||
824 | #if wxUSE_COLOURDLG | |
825 | ||
826 | wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit) | |
827 | { | |
828 | wxColourData data; | |
829 | data.SetChooseFull(true); | |
830 | if ( colInit.Ok() ) | |
831 | { | |
832 | data.SetColour((wxColour &)colInit); // const_cast | |
833 | } | |
834 | ||
835 | wxColour colRet; | |
836 | wxColourDialog dialog(parent, &data); | |
837 | if ( dialog.ShowModal() == wxID_OK ) | |
838 | { | |
839 | colRet = dialog.GetColourData().GetColour(); | |
840 | } | |
841 | //else: leave it invalid | |
842 | ||
843 | return colRet; | |
844 | } | |
845 | ||
846 | #endif // wxUSE_COLOURDLG | |
847 | ||
848 | #if wxUSE_FONTDLG | |
849 | ||
850 | wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit) | |
851 | { | |
852 | wxFontData data; | |
853 | if ( fontInit.Ok() ) | |
854 | { | |
855 | data.SetInitialFont(fontInit); | |
856 | } | |
857 | ||
858 | wxFont fontRet; | |
859 | wxFontDialog dialog(parent, data); | |
860 | if ( dialog.ShowModal() == wxID_OK ) | |
861 | { | |
862 | fontRet = dialog.GetFontData().GetChosenFont(); | |
863 | } | |
864 | //else: leave it invalid | |
865 | ||
866 | return fontRet; | |
867 | } | |
868 | ||
869 | #endif // wxUSE_FONTDLG | |
870 | ||
871 | // ---------------------------------------------------------------------------- | |
872 | // wxSafeYield and supporting functions | |
873 | // ---------------------------------------------------------------------------- | |
874 | ||
875 | void wxEnableTopLevelWindows(bool enable) | |
876 | { | |
877 | wxWindowList::compatibility_iterator node; | |
878 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
879 | node->GetData()->Enable(enable); | |
880 | } | |
881 | ||
882 | wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip) | |
883 | { | |
884 | // remember the top level windows which were already disabled, so that we | |
885 | // don't reenable them later | |
886 | m_winDisabled = NULL; | |
887 | ||
888 | wxWindowList::compatibility_iterator node; | |
889 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
890 | { | |
891 | wxWindow *winTop = node->GetData(); | |
892 | if ( winTop == winToSkip ) | |
893 | continue; | |
894 | ||
895 | // we don't need to disable the hidden or already disabled windows | |
896 | if ( winTop->IsEnabled() && winTop->IsShown() ) | |
897 | { | |
898 | winTop->Disable(); | |
899 | } | |
900 | else | |
901 | { | |
902 | if ( !m_winDisabled ) | |
903 | { | |
904 | m_winDisabled = new wxWindowList; | |
905 | } | |
906 | ||
907 | m_winDisabled->Append(winTop); | |
908 | } | |
909 | } | |
910 | } | |
911 | ||
912 | wxWindowDisabler::~wxWindowDisabler() | |
913 | { | |
914 | wxWindowList::compatibility_iterator node; | |
915 | for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) | |
916 | { | |
917 | wxWindow *winTop = node->GetData(); | |
918 | if ( !m_winDisabled || !m_winDisabled->Find(winTop) ) | |
919 | { | |
920 | winTop->Enable(); | |
921 | } | |
922 | //else: had been already disabled, don't reenable | |
923 | } | |
924 | ||
925 | delete m_winDisabled; | |
926 | } | |
927 | ||
928 | // Yield to other apps/messages and disable user input to all windows except | |
929 | // the given one | |
930 | bool wxSafeYield(wxWindow *win, bool onlyIfNeeded) | |
931 | { | |
932 | wxWindowDisabler wd(win); | |
933 | ||
934 | bool rc; | |
935 | if (onlyIfNeeded) | |
936 | rc = wxYieldIfNeeded(); | |
937 | else | |
938 | rc = wxYield(); | |
939 | ||
940 | return rc; | |
941 | } | |
942 | ||
943 | // Don't synthesize KeyUp events holding down a key and producing KeyDown | |
944 | // events with autorepeat. On by default and always on in wxMSW. wxGTK version | |
945 | // in utilsgtk.cpp. | |
946 | #ifndef __WXGTK__ | |
947 | bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) ) | |
948 | { | |
949 | return true; // detectable auto-repeat is the only mode MSW supports | |
950 | } | |
951 | #endif // !wxGTK | |
952 | ||
953 | #endif // wxUSE_GUI | |
954 |