]> git.saurik.com Git - wxWidgets.git/blame - src/common/utilscmn.cpp
OpenVMS chokes on external templates
[wxWidgets.git] / src / common / utilscmn.cpp
CommitLineData
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
9b4da627 78#ifndef __WXPALMOS5__
1c193821 79#ifndef __WXWINCE__
c801d85f 80#include <time.h>
1c193821
JS
81#else
82#include "wx/msw/wince/time.h"
83#endif
9b4da627 84#endif // ! __WXPALMOS5__
e90c1d2a 85
f14d6dd1 86#ifdef __WXMAC__
c933e267 87#include "wx/osx/private.h"
f14d6dd1
JS
88#endif
89
9b4da627 90#ifndef __WXPALMOS5__
4676948b 91#if !defined(__MWERKS__) && !defined(__WXWINCE__)
e90c1d2a
VZ
92 #include <sys/types.h>
93 #include <sys/stat.h>
469e1e5c 94#endif
9b4da627 95#endif // ! __WXPALMOS5__
c801d85f 96
82ef81ed 97#if defined(__WXMSW__)
5e1febfa 98 #include "wx/msw/private.h"
3452f00b 99 #include "wx/msw/registry.h"
b21d68c6 100 #include <shellapi.h> // needed for SHELLEXECUTEINFO
c801d85f
KB
101#endif
102
6ed3db08
VZ
103#if wxUSE_GUI && defined(__WXGTK__)
104 #include <gtk/gtk.h> // for GTK_XXX_VERSION constants
105#endif
106
ec67cff1 107#if wxUSE_BASE
7c072018 108
73deed44
VZ
109// ----------------------------------------------------------------------------
110// common data
111// ----------------------------------------------------------------------------
112
e90c1d2a
VZ
113// ============================================================================
114// implementation
115// ============================================================================
c801d85f 116
c801d85f 117// Array used in DecToHex conversion routine.
223d09f6 118static wxChar hexArray[] = wxT("0123456789ABCDEF");
c801d85f
KB
119
120// Convert 2-digit hex number to decimal
fd71308f 121int wxHexToDec(const wxString& buf)
c801d85f 122{
657a7545 123 int firstDigit, secondDigit;
3f4a0c5b 124
657a7545
WS
125 if (buf.GetChar(0) >= wxT('A'))
126 firstDigit = buf.GetChar(0) - wxT('A') + 10;
127 else
128 firstDigit = buf.GetChar(0) - wxT('0');
c801d85f 129
657a7545
WS
130 if (buf.GetChar(1) >= wxT('A'))
131 secondDigit = buf.GetChar(1) - wxT('A') + 10;
132 else
133 secondDigit = buf.GetChar(1) - wxT('0');
3f4a0c5b 134
657a7545 135 return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
c801d85f
KB
136}
137
138// Convert decimal integer to 2-character hex string
84fff0b3 139void wxDecToHex(int dec, wxChar *buf)
c801d85f 140{
657a7545
WS
141 int firstDigit = (int)(dec/16.0);
142 int secondDigit = (int)(dec - (firstDigit*16.0));
143 buf[0] = hexArray[firstDigit];
144 buf[1] = hexArray[secondDigit];
145 buf[2] = 0;
c801d85f
KB
146}
147
f728025e
JS
148// Convert decimal integer to 2 characters
149void wxDecToHex(int dec, char* ch1, char* ch2)
150{
151 int firstDigit = (int)(dec/16.0);
152 int secondDigit = (int)(dec - (firstDigit*16.0));
153 (*ch1) = (char) hexArray[firstDigit];
154 (*ch2) = (char) hexArray[secondDigit];
155}
156
fd71308f
JS
157// Convert decimal integer to 2-character hex string
158wxString wxDecToHex(int dec)
159{
84fff0b3 160 wxChar buf[3];
fd71308f
JS
161 wxDecToHex(dec, buf);
162 return wxString(buf);
163}
164
7c072018
VZ
165// ----------------------------------------------------------------------------
166// misc functions
167// ----------------------------------------------------------------------------
c801d85f
KB
168
169// Return the current date/time
e90c1d2a 170wxString wxNow()
c801d85f 171{
4676948b
JS
172#ifdef __WXWINCE__
173#if wxUSE_DATETIME
174 wxDateTime now = wxDateTime::Now();
175 return now.Format();
176#else
177 return wxEmptyString;
178#endif
179#else
2b5f62a0
VZ
180 time_t now = time((time_t *) NULL);
181 char *date = ctime(&now);
182 date[24] = '\0';
183 return wxString::FromAscii(date);
4676948b 184#endif
c801d85f
KB
185}
186
08873d36
VZ
187void wxUsleep(unsigned long milliseconds)
188{
189 wxMilliSleep(milliseconds);
190}
191
7c072018
VZ
192const wxChar *wxGetInstallPrefix()
193{
194 wxString prefix;
195
196 if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
197 return prefix.c_str();
198
199#ifdef wxINSTALL_PREFIX
200 return wxT(wxINSTALL_PREFIX);
201#else
525d8583 202 return wxEmptyString;
7c072018
VZ
203#endif
204}
205
206wxString wxGetDataDir()
207{
10f206ad
RL
208 wxString dir = wxGetInstallPrefix();
209 dir << wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx");
7c072018
VZ
210 return dir;
211}
e90c1d2a 212
8bb6b2c0 213bool wxIsPlatformLittleEndian()
2739d4f0 214{
8bb6b2c0
VZ
215 // Are we little or big endian? This method is from Harbison & Steele.
216 union
217 {
218 long l;
219 char c[sizeof(long)];
220 } u;
221 u.l = 1;
222
223 return u.c[0] == 1;
2739d4f0 224}
1e6feb95 225
8bb6b2c0 226
230c9077
JS
227/*
228 * Class to make it easier to specify platform-dependent values
229 */
230
231wxArrayInt* wxPlatform::sm_customPlatforms = NULL;
232
4bfec179 233void wxPlatform::Copy(const wxPlatform& platform)
230c9077 234{
4bfec179
JS
235 m_longValue = platform.m_longValue;
236 m_doubleValue = platform.m_doubleValue;
237 m_stringValue = platform.m_stringValue;
238}
239
240wxPlatform wxPlatform::If(int platform, long value)
241{
242 if (Is(platform))
243 return wxPlatform(value);
244 else
245 return wxPlatform();
246}
247
248wxPlatform wxPlatform::IfNot(int platform, long value)
249{
250 if (!Is(platform))
251 return wxPlatform(value);
252 else
253 return wxPlatform();
254}
255
256wxPlatform& wxPlatform::ElseIf(int platform, long value)
257{
258 if (Is(platform))
230c9077
JS
259 m_longValue = value;
260 return *this;
261}
262
4bfec179 263wxPlatform& wxPlatform::ElseIfNot(int platform, long value)
230c9077 264{
4bfec179 265 if (!Is(platform))
230c9077
JS
266 m_longValue = value;
267 return *this;
268}
269
4bfec179 270wxPlatform wxPlatform::If(int platform, double value)
230c9077 271{
4bfec179
JS
272 if (Is(platform))
273 return wxPlatform(value);
274 else
275 return wxPlatform();
276}
277
278wxPlatform wxPlatform::IfNot(int platform, double value)
279{
280 if (!Is(platform))
281 return wxPlatform(value);
282 else
283 return wxPlatform();
284}
285
286wxPlatform& wxPlatform::ElseIf(int platform, double value)
287{
288 if (Is(platform))
230c9077
JS
289 m_doubleValue = value;
290 return *this;
291}
292
4bfec179 293wxPlatform& wxPlatform::ElseIfNot(int platform, double value)
230c9077 294{
4bfec179 295 if (!Is(platform))
230c9077
JS
296 m_doubleValue = value;
297 return *this;
298}
299
4bfec179
JS
300wxPlatform wxPlatform::If(int platform, const wxString& value)
301{
302 if (Is(platform))
303 return wxPlatform(value);
304 else
305 return wxPlatform();
306}
307
308wxPlatform wxPlatform::IfNot(int platform, const wxString& value)
309{
310 if (!Is(platform))
311 return wxPlatform(value);
312 else
313 return wxPlatform();
314}
315
316wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value)
230c9077 317{
4bfec179 318 if (Is(platform))
230c9077
JS
319 m_stringValue = value;
320 return *this;
321}
322
4bfec179 323wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value)
230c9077 324{
4bfec179 325 if (!Is(platform))
230c9077
JS
326 m_stringValue = value;
327 return *this;
328}
329
4bfec179 330wxPlatform& wxPlatform::Else(long value)
230c9077
JS
331{
332 m_longValue = value;
333 return *this;
334}
335
4bfec179 336wxPlatform& wxPlatform::Else(double value)
230c9077
JS
337{
338 m_doubleValue = value;
339 return *this;
340}
341
4bfec179 342wxPlatform& wxPlatform::Else(const wxString& value)
230c9077
JS
343{
344 m_stringValue = value;
345 return *this;
346}
347
348void wxPlatform::AddPlatform(int platform)
349{
350 if (!sm_customPlatforms)
351 sm_customPlatforms = new wxArrayInt;
352 sm_customPlatforms->Add(platform);
353}
354
355void wxPlatform::ClearPlatforms()
356{
357 delete sm_customPlatforms;
358 sm_customPlatforms = NULL;
359}
360
361/// Function for testing current platform
362
4bfec179 363bool wxPlatform::Is(int platform)
230c9077
JS
364{
365#ifdef __WXMSW__
216c3543 366 if (platform == wxOS_WINDOWS)
230c9077
JS
367 return true;
368#endif
369#ifdef __WXWINCE__
216c3543 370 if (platform == wxOS_WINDOWS_CE)
230c9077
JS
371 return true;
372#endif
a6e8c584
WS
373
374#if 0
375
376// FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
377
230c9077
JS
378#if defined(__WXWINCE__) && defined(__POCKETPC__)
379 if (platform == wxWinPocketPC)
380 return true;
381#endif
382#if defined(__WXWINCE__) && defined(__SMARTPHONE__)
6aa68c25 383 if (platform == wxWinSmartPhone)
230c9077
JS
384 return true;
385#endif
a6e8c584
WS
386
387#endif
388
230c9077 389#ifdef __WXGTK__
216c3543 390 if (platform == wxPORT_GTK)
230c9077
JS
391 return true;
392#endif
393#ifdef __WXMAC__
216c3543 394 if (platform == wxPORT_MAC)
230c9077
JS
395 return true;
396#endif
397#ifdef __WXX11__
216c3543 398 if (platform == wxPORT_X11)
230c9077
JS
399 return true;
400#endif
401#ifdef __UNIX__
216c3543 402 if (platform == wxOS_UNIX)
230c9077
JS
403 return true;
404#endif
405#ifdef __WXMGL__
216c3543 406 if (platform == wxPORT_MGL)
230c9077
JS
407 return true;
408#endif
8ab09e65
SN
409#ifdef __OS2__
410 if (platform == wxOS_OS2)
411 return true;
412#endif
413#ifdef __WXPM__
414 if (platform == wxPORT_PM)
230c9077
JS
415 return true;
416#endif
55d452c6 417#ifdef __WXCOCOA__
216c3543 418 if (platform == wxPORT_MAC)
230c9077
JS
419 return true;
420#endif
421
422 if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND)
423 return true;
424
425 return false;
426}
427
e90c1d2a 428// ----------------------------------------------------------------------------
7c072018 429// network and user id functions
e90c1d2a 430// ----------------------------------------------------------------------------
c801d85f 431
7c072018
VZ
432// Get Full RFC822 style email address
433bool wxGetEmailAddress(wxChar *address, int maxSize)
c801d85f 434{
7c072018
VZ
435 wxString email = wxGetEmailAddress();
436 if ( !email )
cb719f2e 437 return false;
c801d85f 438
7c072018
VZ
439 wxStrncpy(address, email, maxSize - 1);
440 address[maxSize - 1] = wxT('\0');
441
cb719f2e 442 return true;
c801d85f
KB
443}
444
7c072018 445wxString wxGetEmailAddress()
47bc1060 446{
7c072018 447 wxString email;
974e8d94 448
7c072018 449 wxString host = wxGetFullHostName();
4055ed82 450 if ( !host.empty() )
1e6feb95 451 {
7c072018 452 wxString user = wxGetUserId();
4055ed82 453 if ( !user.empty() )
1e6feb95 454 {
7c072018 455 email << user << wxT('@') << host;
974e8d94 456 }
974e8d94
VZ
457 }
458
7c072018 459 return email;
974e8d94
VZ
460}
461
7c072018 462wxString wxGetUserId()
c801d85f 463{
7c072018 464 static const int maxLoginLen = 256; // FIXME arbitrary number
c801d85f 465
7c072018 466 wxString buf;
4c3ebca9 467 bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
c801d85f 468
7c072018
VZ
469 if ( !ok )
470 buf.Empty();
c801d85f 471
7c072018 472 return buf;
c801d85f
KB
473}
474
7c072018 475wxString wxGetUserName()
c801d85f 476{
7c072018 477 static const int maxUserNameLen = 1024; // FIXME arbitrary number
1e6feb95 478
7c072018 479 wxString buf;
4c3ebca9 480 bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
7c072018
VZ
481
482 if ( !ok )
483 buf.Empty();
484
485 return buf;
59a12e90
JS
486}
487
7c072018 488wxString wxGetHostName()
59a12e90 489{
7c072018 490 static const size_t hostnameSize = 257;
c67d6888 491
7c072018 492 wxString buf;
4c3ebca9 493 bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
59a12e90 494
7c072018
VZ
495 if ( !ok )
496 buf.Empty();
59a12e90 497
7c072018 498 return buf;
59a12e90
JS
499}
500
7c072018 501wxString wxGetFullHostName()
59a12e90 502{
7c072018 503 static const size_t hostnameSize = 257;
c801d85f 504
7c072018 505 wxString buf;
4c3ebca9 506 bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
7c072018
VZ
507
508 if ( !ok )
509 buf.Empty();
c801d85f 510
7c072018
VZ
511 return buf;
512}
c801d85f 513
7c072018
VZ
514wxString wxGetHomeDir()
515{
516 wxString home;
517 wxGetHomeDir(&home);
c801d85f 518
7c072018
VZ
519 return home;
520}
c801d85f 521
c801d85f
KB
522#if 0
523
7c072018 524wxString wxGetCurrentDir()
c801d85f 525{
7c072018
VZ
526 wxString dir;
527 size_t len = 1024;
528 bool ok;
529 do
530 {
531 ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
532 dir.UngetWriteBuf();
c801d85f 533
7c072018
VZ
534 if ( !ok )
535 {
536 if ( errno != ERANGE )
537 {
538 wxLogSysError(_T("Failed to get current directory"));
c801d85f 539
7c072018
VZ
540 return wxEmptyString;
541 }
3f4a0c5b 542 else
7c072018
VZ
543 {
544 // buffer was too small, retry with a larger one
545 len *= 2;
546 }
3f4a0c5b 547 }
7c072018
VZ
548 //else: ok
549 } while ( !ok );
c801d85f 550
7c072018 551 return dir;
c801d85f
KB
552}
553
7c072018 554#endif // 0
e90c1d2a
VZ
555
556// ----------------------------------------------------------------------------
7c072018 557// wxExecute
e90c1d2a 558// ----------------------------------------------------------------------------
ead7ce10 559
7c072018
VZ
560// wxDoExecuteWithCapture() helper: reads an entire stream into one array
561//
cb719f2e 562// returns true if ok, false if error
7c072018
VZ
563#if wxUSE_STREAMS
564static bool ReadAll(wxInputStream *is, wxArrayString& output)
dfad0599 565{
cb719f2e 566 wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") );
dfad0599 567
7c072018
VZ
568 // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
569 is->Reset();
1e6feb95 570
7c072018 571 wxTextInputStream tis(*is);
1e6feb95 572
8bdc8a9c 573 for ( ;; )
d2f50933 574 {
7c072018 575 wxString line = tis.ReadLine();
8bdc8a9c
VZ
576
577 // check for EOF before other errors as it's not really an error
7c072018 578 if ( is->Eof() )
8bdc8a9c
VZ
579 {
580 // add the last, possibly incomplete, line
581 if ( !line.empty() )
582 output.Add(line);
7c072018 583 break;
8bdc8a9c 584 }
7c072018 585
8bdc8a9c 586 // any other error is fatal
7c072018 587 if ( !*is )
8bdc8a9c
VZ
588 return false;
589
590 output.Add(line);
d2f50933
VZ
591 }
592
8bdc8a9c 593 return true;
dfad0599 594}
7c072018 595#endif // wxUSE_STREAMS
d2f50933 596
7c072018
VZ
597// this is a private function because it hasn't a clean interface: the first
598// array is passed by reference, the second by pointer - instead we have 2
599// public versions of wxExecute() below
600static long wxDoExecuteWithCapture(const wxString& command,
601 wxArrayString& output,
4d172154
VZ
602 wxArrayString* error,
603 int flags)
d2f50933 604{
7c072018
VZ
605 // create a wxProcess which will capture the output
606 wxProcess *process = new wxProcess;
607 process->Redirect();
dfad0599 608
4d172154 609 long rc = wxExecute(command, wxEXEC_SYNC | flags, process);
1e6feb95 610
7c072018
VZ
611#if wxUSE_STREAMS
612 if ( rc != -1 )
bf31fa26 613 {
7c072018
VZ
614 if ( !ReadAll(process->GetInputStream(), output) )
615 rc = -1;
91b4c08d 616
7c072018
VZ
617 if ( error )
618 {
619 if ( !ReadAll(process->GetErrorStream(), *error) )
620 rc = -1;
621 }
91b4c08d 622
7c072018 623 }
e70ba80d
WS
624#else
625 wxUnusedVar(output);
626 wxUnusedVar(error);
627#endif // wxUSE_STREAMS/!wxUSE_STREAMS
91b4c08d 628
7c072018 629 delete process;
1e6feb95 630
7c072018 631 return rc;
7c072018 632}
bf31fa26 633
4d172154 634long wxExecute(const wxString& command, wxArrayString& output, int flags)
bf31fa26 635{
4d172154 636 return wxDoExecuteWithCapture(command, output, NULL, flags);
7c072018 637}
bf31fa26 638
7c072018
VZ
639long wxExecute(const wxString& command,
640 wxArrayString& output,
4d172154
VZ
641 wxArrayString& error,
642 int flags)
7c072018 643{
4d172154 644 return wxDoExecuteWithCapture(command, output, &error, flags);
bf31fa26
VZ
645}
646
c5f0d1f9
DE
647// ----------------------------------------------------------------------------
648// wxApp::Yield() wrappers for backwards compatibility
649// ----------------------------------------------------------------------------
650
651bool wxYield()
652{
653 return wxTheApp && wxTheApp->Yield();
654}
655
656bool wxYieldIfNeeded()
657{
658 return wxTheApp && wxTheApp->Yield(true);
659}
660
661// Id generation
662static long wxCurrentId = 100;
663
664long wxNewId()
665{
666 // skip the part of IDs space that contains hard-coded values:
667 if (wxCurrentId == wxID_LOWEST)
668 wxCurrentId = wxID_HIGHEST + 1;
669
670 return wxCurrentId++;
671}
672
673long
674wxGetCurrentId(void) { return wxCurrentId; }
675
676void
677wxRegisterId (long id)
678{
679 if (id >= wxCurrentId)
680 wxCurrentId = id + 1;
681}
682
fe5f448f
RR
683// ----------------------------------------------------------------------------
684// wxQsort, adapted by RR to allow user_data
685// ----------------------------------------------------------------------------
686
687/* This file is part of the GNU C Library.
688 Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
11fe6505 689
fe5f448f
RR
690 Douglas Schmidt kindly gave permission to relicence the
691 code under the wxWindows licence:
11fe6505 692
fe5f448f
RR
693From: "Douglas C. Schmidt" <schmidt@dre.vanderbilt.edu>
694To: Robert Roebling <robert.roebling@uni-ulm.de>
11fe6505 695Subject: Re: qsort licence
fe5f448f
RR
696Date: Mon, 23 Jul 2007 03:44:25 -0500
697Sender: schmidt@dre.vanderbilt.edu
698Message-Id: <20070723084426.64F511000A8@tango.dre.vanderbilt.edu>
699
700Hi Robert,
701
702> [...] I'm asking if you'd be willing to relicence your code
703> under the wxWindows licence. [...]
704
705That's fine with me [...]
706
707Thanks,
708
709 Doug */
710
711
712/* Byte-wise swap two items of size SIZE. */
11fe6505
VZ
713#define SWAP(a, b, size) \
714 do \
715 { \
716 register size_t __size = (size); \
717 register char *__a = (a), *__b = (b); \
718 do \
719 { \
720 char __tmp = *__a; \
721 *__a++ = *__b; \
722 *__b++ = __tmp; \
723 } while (--__size > 0); \
fe5f448f
RR
724 } while (0)
725
726/* Discontinue quicksort algorithm when partition gets below this size.
727 This particular magic number was chosen to work best on a Sun 4/260. */
728#define MAX_THRESH 4
729
730/* Stack node declarations used to store unfulfilled partition obligations. */
731typedef struct
732 {
733 char *lo;
734 char *hi;
735 } stack_node;
736
737/* The next 4 #defines implement a very fast in-line stack abstraction. */
11fe6505 738#define STACK_SIZE (8 * sizeof(unsigned long int))
e71bf8b2
VZ
739#define PUSH(low, high) ((void) ((top->lo = (low)), (top->hi = (high)), ++top))
740#define POP(low, high) ((void) (--top, (low = top->lo), (high = top->hi)))
741#define STACK_NOT_EMPTY (stack < top)
fe5f448f
RR
742
743
744/* Order size using quicksort. This implementation incorporates
745 four optimizations discussed in Sedgewick:
746
747 1. Non-recursive, using an explicit stack of pointer that store the
748 next array partition to sort. To save time, this maximum amount
749 of space required to store an array of MAX_INT is allocated on the
750 stack. Assuming a 32-bit integer, this needs only 32 *
751 sizeof(stack_node) == 136 bits. Pretty cheap, actually.
752
753 2. Chose the pivot element using a median-of-three decision tree.
754 This reduces the probability of selecting a bad pivot value and
755 eliminates certain extraneous comparisons.
756
757 3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
758 insertion sort to order the MAX_THRESH items within each partition.
759 This is a big win, since insertion sort is faster for small, mostly
760 sorted array segments.
761
762 4. The larger of the two sub-partitions is always pushed onto the
763 stack first, with the algorithm then concentrating on the
764 smaller partition. This *guarantees* no more than log (n)
765 stack size is needed (actually O(1) in this case)! */
766
767void wxQsort(void *const pbase, size_t total_elems,
11fe6505 768 size_t size, CMPFUNCDATA cmp, const void* user_data)
fe5f448f
RR
769{
770 register char *base_ptr = (char *) pbase;
771 const size_t max_thresh = MAX_THRESH * size;
772
773 if (total_elems == 0)
774 /* Avoid lossage with unsigned arithmetic below. */
775 return;
776
777 if (total_elems > MAX_THRESH)
778 {
779 char *lo = base_ptr;
780 char *hi = &lo[size * (total_elems - 1)];
781 stack_node stack[STACK_SIZE];
782 stack_node *top = stack;
783
784 PUSH (NULL, NULL);
785
786 while (STACK_NOT_EMPTY)
787 {
788 char *left_ptr;
789 char *right_ptr;
790
11fe6505
VZ
791 /* Select median value from among LO, MID, and HI. Rearrange
792 LO and HI so the three values are sorted. This lowers the
793 probability of picking a pathological pivot value and
794 skips a comparison for both the LEFT_PTR and RIGHT_PTR. */
795
796 char *mid = lo + size * ((hi - lo) / size >> 1);
797
798 if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
799 SWAP (mid, lo, size);
800 if ((*cmp) ((void *) hi, (void *) mid, user_data) < 0)
801 SWAP (mid, hi, size);
802 else
803 goto jump_over;
804 if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
805 SWAP (mid, lo, size);
806 jump_over:;
807 left_ptr = lo + size;
808 right_ptr = hi - size;
809
810 /* Here's the famous ``collapse the walls'' section of quicksort.
811 Gotta like those tight inner loops! They are the main reason
812 that this algorithm runs much faster than others. */
813 do
814 {
815 while ((*cmp) ((void *) left_ptr, (void *) mid, user_data) < 0)
816 left_ptr += size;
817
818 while ((*cmp) ((void *) mid, (void *) right_ptr, user_data) < 0)
819 right_ptr -= size;
820
821 if (left_ptr < right_ptr)
822 {
823 SWAP (left_ptr, right_ptr, size);
824 if (mid == left_ptr)
825 mid = right_ptr;
826 else if (mid == right_ptr)
827 mid = left_ptr;
828 left_ptr += size;
829 right_ptr -= size;
830 }
831 else if (left_ptr == right_ptr)
832 {
833 left_ptr += size;
834 right_ptr -= size;
835 break;
836 }
837 }
838 while (left_ptr <= right_ptr);
fe5f448f
RR
839
840 /* Set up pointers for next iteration. First determine whether
841 left and right partitions are below the threshold size. If so,
842 ignore one or both. Otherwise, push the larger partition's
843 bounds on the stack and continue sorting the smaller one. */
844
845 if ((size_t) (right_ptr - lo) <= max_thresh)
846 {
847 if ((size_t) (hi - left_ptr) <= max_thresh)
11fe6505 848 /* Ignore both small partitions. */
fe5f448f
RR
849 POP (lo, hi);
850 else
11fe6505 851 /* Ignore small left partition. */
fe5f448f
RR
852 lo = left_ptr;
853 }
854 else if ((size_t) (hi - left_ptr) <= max_thresh)
11fe6505 855 /* Ignore small right partition. */
fe5f448f
RR
856 hi = right_ptr;
857 else if ((right_ptr - lo) > (hi - left_ptr))
858 {
11fe6505 859 /* Push larger left partition indices. */
fe5f448f
RR
860 PUSH (lo, right_ptr);
861 lo = left_ptr;
862 }
863 else
864 {
11fe6505 865 /* Push larger right partition indices. */
fe5f448f
RR
866 PUSH (left_ptr, hi);
867 hi = right_ptr;
868 }
869 }
870 }
871
872 /* Once the BASE_PTR array is partially sorted by quicksort the rest
873 is completely sorted using insertion sort, since this is efficient
874 for partitions below MAX_THRESH size. BASE_PTR points to the beginning
875 of the array to sort, and END_PTR points at the very last element in
876 the array (*not* one beyond it!). */
877
fe5f448f
RR
878 {
879 char *const end_ptr = &base_ptr[size * (total_elems - 1)];
880 char *tmp_ptr = base_ptr;
e71bf8b2
VZ
881 char *thresh = base_ptr + max_thresh;
882 if ( thresh > end_ptr )
883 thresh = end_ptr;
fe5f448f
RR
884 register char *run_ptr;
885
886 /* Find smallest element in first threshold and place it at the
887 array's beginning. This is the smallest array element,
888 and the operation speeds up insertion sort's inner loop. */
889
890 for (run_ptr = tmp_ptr + size; run_ptr <= thresh; run_ptr += size)
891 if ((*cmp) ((void *) run_ptr, (void *) tmp_ptr, user_data) < 0)
892 tmp_ptr = run_ptr;
893
894 if (tmp_ptr != base_ptr)
895 SWAP (tmp_ptr, base_ptr, size);
896
897 /* Insertion sort, running from left-hand-side up to right-hand-side. */
898
899 run_ptr = base_ptr + size;
900 while ((run_ptr += size) <= end_ptr)
901 {
11fe6505
VZ
902 tmp_ptr = run_ptr - size;
903 while ((*cmp) ((void *) run_ptr, (void *) tmp_ptr, user_data) < 0)
904 tmp_ptr -= size;
fe5f448f 905
11fe6505 906 tmp_ptr += size;
fe5f448f
RR
907 if (tmp_ptr != run_ptr)
908 {
909 char *trav;
910
11fe6505
VZ
911 trav = run_ptr + size;
912 while (--trav >= run_ptr)
fe5f448f
RR
913 {
914 char c = *trav;
915 char *hi, *lo;
916
917 for (hi = lo = trav; (lo -= size) >= tmp_ptr; hi = lo)
918 *hi = *lo;
919 *hi = c;
920 }
921 }
922 }
923 }
924}
925
926
927
c5f0d1f9
DE
928#endif // wxUSE_BASE
929
930// ============================================================================
931// GUI-only functions from now on
932// ============================================================================
933
934#if wxUSE_GUI
935
1dea1566
RR
936// ----------------------------------------------------------------------------
937// Launch document with default app
938// ----------------------------------------------------------------------------
939
f06832c1 940bool wxLaunchDefaultApplication(const wxString& document, int flags)
1dea1566
RR
941{
942 wxUnusedVar(flags);
f75e0c15 943
979a7347
VZ
944#ifdef __WXMAC__
945 static const char * const OPEN_CMD = "/usr/bin/open";
65751a0e
VZ
946 if ( wxFileExists(OPEN_CMD) &&
947 wxExecute(wxString(OPEN_CMD) + " " + document) )
979a7347
VZ
948 return true;
949#elif defined(__UNIX__)
1dea1566
RR
950 // Our best best is to use xdg-open from freedesktop.org cross-desktop
951 // compatibility suite xdg-utils
952 // (see http://portland.freedesktop.org/wiki/) -- this is installed on
953 // most modern distributions and may be tweaked by them to handle
954 // distribution specifics.
955 wxString path, xdg_open;
956 if ( wxGetEnv("PATH", &path) &&
957 wxFindFileInPath(&xdg_open, path, "xdg-open") )
958 {
959 if ( wxExecute(xdg_open + " " + document) )
960 return true;
961 }
f06832c1
VZ
962#elif defined(__WXMSW__)
963 const INT_PTR result = (INT_PTR)::ShellExecute
964 (
965 NULL, // parent window
966 _T("open"),
af39599d 967 document.wx_str(),
f06832c1
VZ
968 NULL, // parameters
969 NULL, // working directory
970 SW_SHOWDEFAULT
971 );
972 if ( result > 32 )
973 return true;
1dea1566
RR
974#endif
975
f06832c1 976 return false;
1dea1566
RR
977}
978
498a1eeb
RN
979// ----------------------------------------------------------------------------
980// Launch default browser
981// ----------------------------------------------------------------------------
982
4263bab0
DE
983#ifdef __WXCOCOA__
984// Private method in Objective-C++ source file.
985bool wxCocoaLaunchDefaultBrowser(const wxString& url, int flags);
986#endif
987
f75e0c15 988static bool DoLaunchDefaultBrowser(const wxString& urlOrig, int flags)
498a1eeb 989{
42d0df00
VZ
990 wxUnusedVar(flags);
991
7999124f 992 // set the scheme of url to http if it does not have one
889fda0c 993 // RR: This doesn't work if the url is just a local path
7999124f 994 wxString url(urlOrig);
6f6dd276
VZ
995 wxURI uri(url);
996 if ( !uri.HasScheme() )
d545f803
RR
997 {
998 if (wxFileExists(urlOrig))
999 url.Prepend( wxT("file://") );
1000 else
1001 url.Prepend(wxT("http://"));
1002 }
889fda0c 1003
532d575b 1004
7999124f 1005#if defined(__WXMSW__)
5ccb95f6
WS
1006
1007#if wxUSE_IPC
42d0df00
VZ
1008 if ( flags & wxBROWSER_NEW_WINDOW )
1009 {
1010 // ShellExecuteEx() opens the URL in an existing window by default so
1011 // we can't use it if we need a new window
6f6dd276
VZ
1012 wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open"));
1013 if ( !key.Exists() )
1014 {
1015 // try default browser, it must be registered at least for http URLs
1016 key.SetName(wxRegKey::HKCR, _T("http\\shell\\open"));
1017 }
1018
42d0df00
VZ
1019 if ( key.Exists() )
1020 {
1021 wxRegKey keyDDE(key, wxT("DDEExec"));
1022 if ( keyDDE.Exists() )
1023 {
1024 const wxString ddeTopic = wxRegKey(keyDDE, wxT("topic"));
1025
1026 // we only know the syntax of WWW_OpenURL DDE request for IE,
1027 // optimistically assume that all other browsers are compatible
1028 // with it
1029 wxString ddeCmd;
1030 bool ok = ddeTopic == wxT("WWW_OpenURL");
1031 if ( ok )
1032 {
588c80de 1033 ddeCmd = keyDDE.QueryDefaultValue();
42d0df00
VZ
1034 ok = !ddeCmd.empty();
1035 }
1036
1037 if ( ok )
1038 {
1039 // for WWW_OpenURL, the index of the window to open the URL
1040 // in is -1 (meaning "current") by default, replace it with
1041 // 0 which means "new" (see KB article 160957)
1042 ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
1043 false /* only first occurence */) == 1;
1044 }
1045
1046 if ( ok )
1047 {
1048 // and also replace the parameters: the topic should
1049 // contain a placeholder for the URL
1050 ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
1051 }
1052
1053 if ( ok )
1054 {
1055 // try to send it the DDE request now but ignore the errors
1056 wxLogNull noLog;
1057
1058 const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
1059 if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCmd) )
1060 return true;
1061
1062 // this is not necessarily an error: maybe browser is
1063 // simply not running, but no matter, in any case we're
1064 // going to launch it using ShellExecuteEx() below now and
1065 // we shouldn't try to open a new window if we open a new
1066 // browser anyhow
1067 }
1068 }
1069 }
1070 }
5ccb95f6 1071#endif // wxUSE_IPC
42d0df00 1072
7999124f
VZ
1073 WinStruct<SHELLEXECUTEINFO> sei;
1074 sei.lpFile = url.c_str();
1075 sei.lpVerb = _T("open");
1076 sei.nShow = SW_SHOWNORMAL;
498a1eeb 1077
7999124f 1078 ::ShellExecuteEx(&sei);
657a7545 1079
dca0f651 1080 const INT_PTR nResult = (INT_PTR)sei.hInstApp;
498a1eeb 1081
7999124f
VZ
1082 // Firefox returns file not found for some reason, so make an exception
1083 // for it
1084 if ( nResult > 32 || nResult == SE_ERR_FNF )
498a1eeb 1085 {
657a7545 1086#ifdef __WXDEBUG__
498a1eeb 1087 // Log something if SE_ERR_FNF happens
7999124f
VZ
1088 if ( nResult == SE_ERR_FNF )
1089 wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?"));
1090#endif // __WXDEBUG__
1091 return true;
657a7545 1092 }
4263bab0
DE
1093#elif defined(__WXCOCOA__)
1094 // NOTE: We need to call the real implementation from src/cocoa/utils.mm
1095 // because the code must use Objective-C features.
1096 return wxCocoaLaunchDefaultBrowser(url, flags);
c933e267 1097#elif defined(__WXMAC__) && !defined(__WXOSX_IPHONE__)
5d713a75
SC
1098 wxCFRef< CFURLRef > curl( CFURLCreateWithString( kCFAllocatorDefault,
1099 wxCFStringRef( url ), NULL ) );
1100 OSStatus err = LSOpenCFURLRef( curl , NULL );
f14d6dd1 1101
13a1e96f
DS
1102 if (err == noErr)
1103 {
f14d6dd1
JS
1104 return true;
1105 }
1106 else
1107 {
5d713a75 1108 wxLogDebug(wxT("Browser Launch error %d"), (int) err);
f14d6dd1
JS
1109 return false;
1110 }
f728025e 1111#else
889fda0c
RR
1112 // (non-Mac, non-MSW)
1113
1114#ifdef __UNIX__
17ede0b1 1115
ae46a7fd
VS
1116 // Our best best is to use xdg-open from freedesktop.org cross-desktop
1117 // compatibility suite xdg-utils
1118 // (see http://portland.freedesktop.org/wiki/) -- this is installed on
1119 // most modern distributions and may be tweaked by them to handle
1120 // distribution specifics. Only if that fails, try to find the right
1121 // browser ourselves.
1122 wxString path, xdg_open;
1123 if ( wxGetEnv("PATH", &path) &&
1124 wxFindFileInPath(&xdg_open, path, "xdg-open") )
1125 {
1126 if ( wxExecute(xdg_open + " " + url) )
1127 return true;
1128 }
1129
17ede0b1
RR
1130 wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment();
1131
1132 // GNOME and KDE desktops have some applications which should be always installed
1133 // together with their main parts, which give us the
1134 if (desktop == wxT("GNOME"))
889fda0c
RR
1135 {
1136 wxArrayString errors;
1137 wxArrayString output;
17ede0b1
RR
1138
1139 // gconf will tell us the path of the application to use as browser
1140 long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"),
1141 output, errors, wxEXEC_NODISABLE );
889fda0c
RR
1142 if (res >= 0 && errors.GetCount() == 0)
1143 {
1144 wxString cmd = output[0];
1145 cmd << _T(' ') << url;
1146 if (wxExecute(cmd))
1147 return true;
1148 }
1149 }
17ede0b1
RR
1150 else if (desktop == wxT("KDE"))
1151 {
1152 // kfmclient directly opens the given URL
1153 if (wxExecute(wxT("kfmclient openURL ") + url))
1154 return true;
1155 }
889fda0c
RR
1156#endif
1157
13a1e96f
DS
1158 bool ok = false;
1159 wxString cmd;
1160
1b1b5318 1161#if wxUSE_MIMETYPE
13a1e96f 1162 wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
7999124f 1163 if ( ft )
657a7545 1164 {
7999124f
VZ
1165 wxString mt;
1166 ft->GetMimeType(&mt);
498a1eeb 1167
13a1e96f 1168 ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
7999124f 1169 delete ft;
498a1eeb 1170 }
1b1b5318 1171#endif // wxUSE_MIMETYPE
13a1e96f
DS
1172
1173 if ( !ok || cmd.empty() )
2830b4a4 1174 {
13a1e96f
DS
1175 // fallback to checking for the BROWSER environment variable
1176 cmd = wxGetenv(wxT("BROWSER"));
1177 if ( !cmd.empty() )
1178 cmd << _T(' ') << url;
2830b4a4 1179 }
13a1e96f
DS
1180
1181 ok = ( !cmd.empty() && wxExecute(cmd) );
1182 if (ok)
1183 return ok;
1184
1185 // no file type for HTML extension
5519074c 1186 wxLogError(_("No default application configured for HTML files."));
13a1e96f 1187
7999124f 1188#endif // !wxUSE_MIMETYPE && !__WXMSW__
532d575b 1189
5519074c 1190 wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
7999124f 1191 url.c_str());
657a7545 1192
7999124f 1193 return false;
498a1eeb
RN
1194}
1195
f75e0c15
VZ
1196bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1197{
1198 if ( flags & wxBROWSER_NOBUSYCURSOR )
1199 return DoLaunchDefaultBrowser(url, flags);
1200
1201 wxBusyCursor bc;
1202 return DoLaunchDefaultBrowser(url, flags);
1203}
1204
e90c1d2a 1205// ----------------------------------------------------------------------------
7c072018 1206// Menu accelerators related functions
e90c1d2a
VZ
1207// ----------------------------------------------------------------------------
1208
7c072018 1209wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
e90c1d2a 1210{
9a6384ca 1211#if wxUSE_MENUS
52af3158 1212 wxString s = wxMenuItem::GetLabelText(in);
9a6384ca
WS
1213#else
1214 wxString str(in);
1215 wxString s = wxStripMenuCodes(str);
1216#endif // wxUSE_MENUS
7c072018
VZ
1217 if ( out )
1218 {
1219 // go smash their buffer if it's not big enough - I love char * params
1220 memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1221 }
1222 else
1223 {
f526f752
MB
1224 out = new wxChar[s.length() + 1];
1225 wxStrcpy(out, s.c_str());
7c072018
VZ
1226 }
1227
1228 return out;
e90c1d2a
VZ
1229}
1230
74639764 1231wxString wxStripMenuCodes(const wxString& in, int flags)
e90c1d2a 1232{
74639764
VZ
1233 wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
1234
7c072018 1235 wxString out;
79f585d9 1236
7c072018
VZ
1237 size_t len = in.length();
1238 out.reserve(len);
79f585d9 1239
7c072018
VZ
1240 for ( size_t n = 0; n < len; n++ )
1241 {
1242 wxChar ch = in[n];
74639764 1243 if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
cd6ce4a9 1244 {
7c072018
VZ
1245 // skip it, it is used to introduce the accel char (or to quote
1246 // itself in which case it should still be skipped): note that it
1247 // can't be the last character of the string
1248 if ( ++n == len )
79f585d9 1249 {
7c072018
VZ
1250 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1251 }
1252 else
1253 {
1254 // use the next char instead
1255 ch = in[n];
79f585d9 1256 }
cd6ce4a9 1257 }
74639764 1258 else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
79f585d9 1259 {
7c072018
VZ
1260 // everything after TAB is accel string, exit the loop
1261 break;
79f585d9 1262 }
7c072018
VZ
1263
1264 out += ch;
225fe9d6
VZ
1265 }
1266
7c072018 1267 return out;
cd6ce4a9
VZ
1268}
1269
cbc66a27 1270// ----------------------------------------------------------------------------
7c072018 1271// Window search functions
cbc66a27
VZ
1272// ----------------------------------------------------------------------------
1273
7c072018
VZ
1274/*
1275 * If parent is non-NULL, look through children for a label or title
1276 * matching the specified string. If NULL, look through all top-level windows.
1277 *
1278 */
e2a6f233 1279
7c072018
VZ
1280wxWindow *
1281wxFindWindowByLabel (const wxString& title, wxWindow * parent)
134677bd 1282{
7c072018
VZ
1283 return wxWindow::FindWindowByLabel( title, parent );
1284}
b829bf55 1285
b829bf55 1286
7c072018
VZ
1287/*
1288 * If parent is non-NULL, look through children for a name
1289 * matching the specified string. If NULL, look through all top-level windows.
1290 *
1291 */
134677bd 1292
7c072018
VZ
1293wxWindow *
1294wxFindWindowByName (const wxString& name, wxWindow * parent)
2c18f21d 1295{
7c072018 1296 return wxWindow::FindWindowByName( name, parent );
2c18f21d
VS
1297}
1298
cb719f2e 1299// Returns menu item id or wxNOT_FOUND if none.
7c072018 1300int
8d22935d
VZ
1301wxFindMenuItemId(wxFrame *frame,
1302 const wxString& menuString,
1303 const wxString& itemString)
e2a6f233 1304{
7c072018 1305#if wxUSE_MENUS
9a6384ca
WS
1306 wxMenuBar *menuBar = frame->GetMenuBar ();
1307 if ( menuBar )
1308 return menuBar->FindMenuItem (menuString, itemString);
8d22935d
VZ
1309#else // !wxUSE_MENUS
1310 wxUnusedVar(frame);
1311 wxUnusedVar(menuString);
1312 wxUnusedVar(itemString);
1313#endif // wxUSE_MENUS/!wxUSE_MENUS
0fb67cd1 1314
9a6384ca 1315 return wxNOT_FOUND;
e2a6f233
JS
1316}
1317
7c072018
VZ
1318// Try to find the deepest child that contains 'pt'.
1319// We go backwards, to try to allow for controls that are spacially
1320// within other controls, but are still siblings (e.g. buttons within
1321// static boxes). Static boxes are likely to be created _before_ controls
1322// that sit inside them.
1323wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
e2a6f233 1324{
7c072018
VZ
1325 if (!win->IsShown())
1326 return NULL;
0fb67cd1 1327
7c072018
VZ
1328 // Hack for wxNotebook case: at least in wxGTK, all pages
1329 // claim to be shown, so we must only deal with the selected one.
1330#if wxUSE_NOTEBOOK
1331 if (win->IsKindOf(CLASSINFO(wxNotebook)))
e2a6f233 1332 {
7c072018
VZ
1333 wxNotebook* nb = (wxNotebook*) win;
1334 int sel = nb->GetSelection();
1335 if (sel >= 0)
1336 {
1337 wxWindow* child = nb->GetPage(sel);
1338 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1339 if (foundWin)
1340 return foundWin;
1341 }
e2a6f233 1342 }
7c072018 1343#endif
0fb67cd1 1344
df5168c4 1345 wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
7c072018
VZ
1346 while (node)
1347 {
1348 wxWindow* child = node->GetData();
1349 wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1350 if (foundWin)
1351 return foundWin;
1352 node = node->GetPrevious();
1353 }
1354
1355 wxPoint pos = win->GetPosition();
1356 wxSize sz = win->GetSize();
7aa7d2d4 1357 if ( !win->IsTopLevel() && win->GetParent() )
7c072018
VZ
1358 {
1359 pos = win->GetParent()->ClientToScreen(pos);
1360 }
1361
1362 wxRect rect(pos, sz);
22a35096 1363 if (rect.Contains(pt))
7c072018 1364 return win;
622eb786
VZ
1365
1366 return NULL;
0fb67cd1
VZ
1367}
1368
7c072018 1369wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
0fb67cd1 1370{
7c072018
VZ
1371 // Go backwards through the list since windows
1372 // on top are likely to have been appended most
1373 // recently.
df5168c4 1374 wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
7c072018
VZ
1375 while (node)
1376 {
1377 wxWindow* win = node->GetData();
1378 wxWindow* found = wxFindWindowAtPoint(win, pt);
1379 if (found)
1380 return found;
1381 node = node->GetPrevious();
1382 }
1383 return NULL;
1384}
0fb67cd1 1385
7c072018
VZ
1386// ----------------------------------------------------------------------------
1387// GUI helpers
1388// ----------------------------------------------------------------------------
0fb67cd1 1389
7c072018
VZ
1390/*
1391 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1392 * since otherwise the generic code may be pulled in unnecessarily.
1393 */
0fb67cd1 1394
7c072018 1395#if wxUSE_MSGDLG
0fb67cd1 1396
7c072018
VZ
1397int wxMessageBox(const wxString& message, const wxString& caption, long style,
1398 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
0fb67cd1 1399{
53a6ac21
DS
1400 long decorated_style = style;
1401
1402 if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1403 {
1404 decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1405 }
1406
1407 wxMessageDialog dialog(parent, message, caption, decorated_style);
0fb67cd1 1408
7c072018
VZ
1409 int ans = dialog.ShowModal();
1410 switch ( ans )
1411 {
1412 case wxID_OK:
1413 return wxOK;
1414 case wxID_YES:
1415 return wxYES;
1416 case wxID_NO:
1417 return wxNO;
1418 case wxID_CANCEL:
1419 return wxCANCEL;
1420 }
0fb67cd1 1421
7c072018 1422 wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
0fb67cd1 1423
7c072018 1424 return wxCANCEL;
e2a6f233
JS
1425}
1426
8cf304f8
VZ
1427void wxInfoMessageBox(wxWindow* parent)
1428{
1429 // don't translate these strings, they're for diagnostics purposes only
1430 wxString msg;
1431 msg.Printf(_T("wxWidgets Library (%s port)\n")
1432 _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
1433 _T("Runtime version of toolkit used is %d.%d.%s\n")
dbe44db1 1434 _T("Copyright (c) 1995-2008 wxWidgets team"),
8cf304f8
VZ
1435 wxPlatformInfo::Get().GetPortIdName().c_str(),
1436 wxMAJOR_VERSION,
1437 wxMINOR_VERSION,
1438 wxRELEASE_NUMBER,
1439#if wxUSE_UNICODE
1440 L" (Unicode)",
1441#else
1442 wxEmptyString,
1443#endif
1444#ifdef __WXDEBUG__
1445 _T(" Debug build"),
1446#else
1447 wxEmptyString,
1448#endif
1449 __TDATE__,
1450 __TTIME__,
1451 wxPlatformInfo::Get().GetToolkitMajorVersion(),
1452 wxPlatformInfo::Get().GetToolkitMinorVersion(),
1453#ifdef __WXGTK__
6ed3db08
VZ
1454 wxString::Format("\nThe compile-time GTK+ version is %d.%d.%d.",
1455 GTK_MAJOR_VERSION,
1456 GTK_MINOR_VERSION,
1457 GTK_MICRO_VERSION).c_str()
8cf304f8
VZ
1458#else
1459 wxEmptyString
1460#endif
1461 );
1462 wxMessageBox(msg, _T("wxWidgets information"),
1463 wxICON_INFORMATION | wxOK,
1464 parent);
1465}
1466
7c072018 1467#endif // wxUSE_MSGDLG
518b5d2f 1468
7c072018 1469#if wxUSE_TEXTDLG
518b5d2f 1470
7c072018
VZ
1471wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1472 const wxString& defaultValue, wxWindow *parent,
13d13a9e 1473 wxCoord x, wxCoord y, bool centre )
7c072018
VZ
1474{
1475 wxString str;
13d13a9e
WS
1476 long style = wxTextEntryDialogStyle;
1477
1478 if (centre)
1479 style |= wxCENTRE;
1480 else
1481 style &= ~wxCENTRE;
1482
1483 wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1484
7c072018
VZ
1485 if (dialog.ShowModal() == wxID_OK)
1486 {
1487 str = dialog.GetValue();
1488 }
0fb67cd1 1489
7c072018 1490 return str;
518b5d2f
VZ
1491}
1492
7c072018
VZ
1493wxString wxGetPasswordFromUser(const wxString& message,
1494 const wxString& caption,
1495 const wxString& defaultValue,
b3bb2a74
KH
1496 wxWindow *parent,
1497 wxCoord x, wxCoord y, bool centre )
96c5bd7f 1498{
7c072018 1499 wxString str;
b3bb2a74
KH
1500 long style = wxTextEntryDialogStyle;
1501
1502 if (centre)
1503 style |= wxCENTRE;
1504 else
1505 style &= ~wxCENTRE;
1506
12cfa304
KH
1507 wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1508 style, wxPoint(x, y));
7c072018
VZ
1509 if ( dialog.ShowModal() == wxID_OK )
1510 {
1511 str = dialog.GetValue();
1512 }
96c5bd7f 1513
7c072018
VZ
1514 return str;
1515}
96c5bd7f 1516
7c072018 1517#endif // wxUSE_TEXTDLG
96c5bd7f 1518
7c072018 1519#if wxUSE_COLOURDLG
96c5bd7f 1520
f75e0c15
VZ
1521wxColour wxGetColourFromUser(wxWindow *parent,
1522 const wxColour& colInit,
e6ef9ea4
VZ
1523 const wxString& caption,
1524 wxColourData *ptrData)
c51deffc 1525{
e6ef9ea4
VZ
1526 // contains serialized representation of wxColourData used the last time
1527 // the dialog was shown: we want to reuse it the next time in order to show
1528 // the same custom colours to the user (and we can't just have static
1529 // wxColourData itself because it's a GUI object and so should be destroyed
1530 // before GUI shutdown and doing it during static cleanup is too late)
1531 static wxString s_strColourData;
1532
7c072018 1533 wxColourData data;
e6ef9ea4 1534 if ( !ptrData )
7c072018 1535 {
e6ef9ea4
VZ
1536 ptrData = &data;
1537 if ( !s_strColourData.empty() )
1538 {
1539 if ( !data.FromString(s_strColourData) )
1540 {
1541 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1542 }
1543
1544#ifdef __WXMSW__
1545 // we don't get back the "choose full" flag value from the native
1546 // dialog and so we can't preserve it between runs, so we decide to
1547 // always use it as it seems better than not using it (user can
1548 // just ignore the extra controls in the dialog but having to click
1549 // a button each time to show them would be very annoying
1550 data.SetChooseFull(true);
1551#endif // __WXMSW__
1552 }
1553 }
1554
1555 if ( colInit.IsOk() )
1556 {
1557 ptrData->SetColour(colInit);
7c072018 1558 }
c51deffc 1559
7c072018 1560 wxColour colRet;
e6ef9ea4 1561 wxColourDialog dialog(parent, ptrData);
76b49cf4 1562 if (!caption.empty())
f14d6dd1 1563 dialog.SetTitle(caption);
7c072018
VZ
1564 if ( dialog.ShowModal() == wxID_OK )
1565 {
e6ef9ea4
VZ
1566 *ptrData = dialog.GetColourData();
1567 colRet = ptrData->GetColour();
1568 s_strColourData = ptrData->ToString();
7c072018 1569 }
e6ef9ea4 1570 //else: leave colRet invalid
7c072018
VZ
1571
1572 return colRet;
c51deffc 1573}
bc385ba9 1574
7c072018 1575#endif // wxUSE_COLOURDLG
bc385ba9 1576
7c072018
VZ
1577#if wxUSE_FONTDLG
1578
f14d6dd1 1579wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
bc385ba9 1580{
7c072018
VZ
1581 wxFontData data;
1582 if ( fontInit.Ok() )
bc385ba9 1583 {
7c072018
VZ
1584 data.SetInitialFont(fontInit);
1585 }
bc385ba9 1586
7c072018
VZ
1587 wxFont fontRet;
1588 wxFontDialog dialog(parent, data);
76b49cf4 1589 if (!caption.empty())
f14d6dd1 1590 dialog.SetTitle(caption);
7c072018
VZ
1591 if ( dialog.ShowModal() == wxID_OK )
1592 {
1593 fontRet = dialog.GetFontData().GetChosenFont();
1594 }
1595 //else: leave it invalid
bc385ba9 1596
7c072018 1597 return fontRet;
bc385ba9
VZ
1598}
1599
7c072018 1600#endif // wxUSE_FONTDLG
2b5f62a0 1601
7c072018
VZ
1602// ----------------------------------------------------------------------------
1603// wxSafeYield and supporting functions
1604// ----------------------------------------------------------------------------
2b5f62a0 1605
7c072018
VZ
1606void wxEnableTopLevelWindows(bool enable)
1607{
df5168c4 1608 wxWindowList::compatibility_iterator node;
7c072018
VZ
1609 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1610 node->GetData()->Enable(enable);
1611}
2b5f62a0 1612
2ecd1756
VZ
1613wxWindowDisabler::wxWindowDisabler(bool disable)
1614{
1615 m_disabled = disable;
1616 if ( disable )
1617 DoDisable();
1618}
1619
7c072018 1620wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
2ecd1756
VZ
1621{
1622 m_disabled = true;
1623 DoDisable(winToSkip);
1624}
1625
1626void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
7c072018
VZ
1627{
1628 // remember the top level windows which were already disabled, so that we
1629 // don't reenable them later
1630 m_winDisabled = NULL;
1631
df5168c4 1632 wxWindowList::compatibility_iterator node;
7c072018 1633 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
2b5f62a0 1634 {
7c072018
VZ
1635 wxWindow *winTop = node->GetData();
1636 if ( winTop == winToSkip )
1637 continue;
2b5f62a0 1638
7c072018
VZ
1639 // we don't need to disable the hidden or already disabled windows
1640 if ( winTop->IsEnabled() && winTop->IsShown() )
2b5f62a0 1641 {
7c072018 1642 winTop->Disable();
2b5f62a0
VZ
1643 }
1644 else
1645 {
7c072018
VZ
1646 if ( !m_winDisabled )
1647 {
1648 m_winDisabled = new wxWindowList;
1649 }
1650
1651 m_winDisabled->Append(winTop);
2b5f62a0
VZ
1652 }
1653 }
2b5f62a0
VZ
1654}
1655
7c072018 1656wxWindowDisabler::~wxWindowDisabler()
cd6ce4a9 1657{
2ecd1756
VZ
1658 if ( !m_disabled )
1659 return;
1660
df5168c4 1661 wxWindowList::compatibility_iterator node;
7c072018 1662 for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
cd6ce4a9 1663 {
7c072018
VZ
1664 wxWindow *winTop = node->GetData();
1665 if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
cd6ce4a9 1666 {
7c072018 1667 winTop->Enable();
cd6ce4a9 1668 }
7c072018 1669 //else: had been already disabled, don't reenable
cd6ce4a9 1670 }
f6bcfd97 1671
7c072018 1672 delete m_winDisabled;
f6bcfd97
BP
1673}
1674
7c072018
VZ
1675// Yield to other apps/messages and disable user input to all windows except
1676// the given one
1677bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
f6bcfd97 1678{
7c072018 1679 wxWindowDisabler wd(win);
21709999 1680
7c072018
VZ
1681 bool rc;
1682 if (onlyIfNeeded)
1683 rc = wxYieldIfNeeded();
1684 else
1685 rc = wxYield();
8461e4c2 1686
7c072018 1687 return rc;
8461e4c2
VZ
1688}
1689
7c072018
VZ
1690// Don't synthesize KeyUp events holding down a key and producing KeyDown
1691// events with autorepeat. On by default and always on in wxMSW. wxGTK version
1692// in utilsgtk.cpp.
1693#ifndef __WXGTK__
1694bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
8461e4c2 1695{
cb719f2e 1696 return true; // detectable auto-repeat is the only mode MSW supports
8461e4c2 1697}
7c072018
VZ
1698#endif // !wxGTK
1699
1700#endif // wxUSE_GUI