src/common/utilscmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/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 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/app.h"
  29     #include "wx/string.h"
  30     #include "wx/utils.h"
  31     #include "wx/intl.h"
  32     #include "wx/log.h"
  33
  34     #if wxUSE_GUI
  35         #include "wx/window.h"
  36         #include "wx/frame.h"
  37         #include "wx/menu.h"
  38         #include "wx/msgdlg.h"
  39         #include "wx/textdlg.h"
  40         #include "wx/textctrl.h"    // for wxTE_PASSWORD
  41         #if wxUSE_ACCEL
  42             #include "wx/menuitem.h"
  43             #include "wx/accel.h"
  44         #endif // wxUSE_ACCEL
  45     #endif // wxUSE_GUI
  46 #endif // WX_PRECOMP
  47
  48 #include "wx/apptrait.h"
  49
  50 #include "wx/process.h"
  51 #include "wx/txtstrm.h"
  52 #include "wx/uri.h"
  53 #include "wx/mimetype.h"
  54 #include "wx/config.h"
  55 #include "wx/versioninfo.h"
  56
  57 #if defined(__WXWINCE__) && wxUSE_DATETIME
  58     #include "wx/datetime.h"
  59 #endif
  60
  61 #include <ctype.h>
  62 #include <stdio.h>
  63 #include <stdlib.h>
  64 #include <string.h>
  65
  66 #if !wxONLY_WATCOM_EARLIER_THAN(1,4)
  67     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
  68         #include <errno.h>
  69     #endif
  70 #endif
  71
  72 #if wxUSE_GUI
  73     #include "wx/notebook.h"
  74     #include "wx/statusbr.h"
  75 #endif // wxUSE_GUI
  76
  77 #ifndef __WXWINCE__
  78     #include <time.h>
  79 #else
  80     #include "wx/msw/wince/time.h"
  81 #endif
  82
  83 #ifdef __WXMAC__
  84     #include "wx/osx/private.h"
  85 #endif
  86
  87 #if !defined(__WXWINCE__)
  88     #include <sys/types.h>
  89     #include <sys/stat.h>
  90 #endif
  91
  92 #if defined(__WINDOWS__)
  93     #include "wx/msw/private.h"
  94     #include "wx/filesys.h"
  95 #endif
  96
  97 #if wxUSE_GUI && defined(__WXGTK__)
  98     #include <gtk/gtk.h>    // for GTK_XXX_VERSION constants
  99 #endif
 100
 101 #if wxUSE_BASE
 102
 103 // ============================================================================
 104 // implementation
 105 // ============================================================================
 106
 107 // Array used in DecToHex conversion routine.
 108 static const wxChar hexArray[] = wxT("0123456789ABCDEF");
 109
 110 // Convert 2-digit hex number to decimal
 111 int wxHexToDec(const wxString& str)
 112 {
 113     char buf[2];
 114     buf[0] = str.GetChar(0);
 115     buf[1] = str.GetChar(1);
 116     return wxHexToDec((const char*) buf);
 117 }
 118
 119 // Convert decimal integer to 2-character hex string
 120 void wxDecToHex(int dec, wxChar *buf)
 121 {
 122     int firstDigit = (int)(dec/16.0);
 123     int secondDigit = (int)(dec - (firstDigit*16.0));
 124     buf[0] = hexArray[firstDigit];
 125     buf[1] = hexArray[secondDigit];
 126     buf[2] = 0;
 127 }
 128
 129 // Convert decimal integer to 2 characters
 130 void wxDecToHex(int dec, char* ch1, char* ch2)
 131 {
 132     int firstDigit = (int)(dec/16.0);
 133     int secondDigit = (int)(dec - (firstDigit*16.0));
 134     (*ch1) = (char) hexArray[firstDigit];
 135     (*ch2) = (char) hexArray[secondDigit];
 136 }
 137
 138 // Convert decimal integer to 2-character hex string
 139 wxString wxDecToHex(int dec)
 140 {
 141     wxChar buf[3];
 142     wxDecToHex(dec, buf);
 143     return wxString(buf);
 144 }
 145
 146 // ----------------------------------------------------------------------------
 147 // misc functions
 148 // ----------------------------------------------------------------------------
 149
 150 // Return the current date/time
 151 wxString wxNow()
 152 {
 153 #ifdef __WXWINCE__
 154 #if wxUSE_DATETIME
 155     wxDateTime now = wxDateTime::Now();
 156     return now.Format();
 157 #else
 158     return wxEmptyString;
 159 #endif
 160 #else
 161     time_t now = time(NULL);
 162     char *date = ctime(&now);
 163     date[24] = '\0';
 164     return wxString::FromAscii(date);
 165 #endif
 166 }
 167
 168 #if WXWIN_COMPATIBILITY_2_8
 169 void wxUsleep(unsigned long milliseconds)
 170 {
 171     wxMilliSleep(milliseconds);
 172 }
 173 #endif
 174
 175 const wxChar *wxGetInstallPrefix()
 176 {
 177     wxString prefix;
 178
 179     if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
 180         return prefix.c_str();
 181
 182 #ifdef wxINSTALL_PREFIX
 183     return wxT(wxINSTALL_PREFIX);
 184 #else
 185     return wxEmptyString;
 186 #endif
 187 }
 188
 189 wxString wxGetDataDir()
 190 {
 191     wxString dir = wxGetInstallPrefix();
 192     dir <<  wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx");
 193     return dir;
 194 }
 195
 196 bool wxIsPlatformLittleEndian()
 197 {
 198     // Are we little or big endian? This method is from Harbison & Steele.
 199     union
 200     {
 201         long l;
 202         char c[sizeof(long)];
 203     } u;
 204     u.l = 1;
 205
 206     return u.c[0] == 1;
 207 }
 208
 209
 210 // ----------------------------------------------------------------------------
 211 // wxPlatform
 212 // ----------------------------------------------------------------------------
 213
 214 /*
 215  * Class to make it easier to specify platform-dependent values
 216  */
 217
 218 wxArrayInt*  wxPlatform::sm_customPlatforms = NULL;
 219
 220 void wxPlatform::Copy(const wxPlatform& platform)
 221 {
 222     m_longValue = platform.m_longValue;
 223     m_doubleValue = platform.m_doubleValue;
 224     m_stringValue = platform.m_stringValue;
 225 }
 226
 227 wxPlatform wxPlatform::If(int platform, long value)
 228 {
 229     if (Is(platform))
 230         return wxPlatform(value);
 231     else
 232         return wxPlatform();
 233 }
 234
 235 wxPlatform wxPlatform::IfNot(int platform, long value)
 236 {
 237     if (!Is(platform))
 238         return wxPlatform(value);
 239     else
 240         return wxPlatform();
 241 }
 242
 243 wxPlatform& wxPlatform::ElseIf(int platform, long value)
 244 {
 245     if (Is(platform))
 246         m_longValue = value;
 247     return *this;
 248 }
 249
 250 wxPlatform& wxPlatform::ElseIfNot(int platform, long value)
 251 {
 252     if (!Is(platform))
 253         m_longValue = value;
 254     return *this;
 255 }
 256
 257 wxPlatform wxPlatform::If(int platform, double value)
 258 {
 259     if (Is(platform))
 260         return wxPlatform(value);
 261     else
 262         return wxPlatform();
 263 }
 264
 265 wxPlatform wxPlatform::IfNot(int platform, double value)
 266 {
 267     if (!Is(platform))
 268         return wxPlatform(value);
 269     else
 270         return wxPlatform();
 271 }
 272
 273 wxPlatform& wxPlatform::ElseIf(int platform, double value)
 274 {
 275     if (Is(platform))
 276         m_doubleValue = value;
 277     return *this;
 278 }
 279
 280 wxPlatform& wxPlatform::ElseIfNot(int platform, double value)
 281 {
 282     if (!Is(platform))
 283         m_doubleValue = value;
 284     return *this;
 285 }
 286
 287 wxPlatform wxPlatform::If(int platform, const wxString& value)
 288 {
 289     if (Is(platform))
 290         return wxPlatform(value);
 291     else
 292         return wxPlatform();
 293 }
 294
 295 wxPlatform wxPlatform::IfNot(int platform, const wxString& value)
 296 {
 297     if (!Is(platform))
 298         return wxPlatform(value);
 299     else
 300         return wxPlatform();
 301 }
 302
 303 wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value)
 304 {
 305     if (Is(platform))
 306         m_stringValue = value;
 307     return *this;
 308 }
 309
 310 wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value)
 311 {
 312     if (!Is(platform))
 313         m_stringValue = value;
 314     return *this;
 315 }
 316
 317 wxPlatform& wxPlatform::Else(long value)
 318 {
 319     m_longValue = value;
 320     return *this;
 321 }
 322
 323 wxPlatform& wxPlatform::Else(double value)
 324 {
 325     m_doubleValue = value;
 326     return *this;
 327 }
 328
 329 wxPlatform& wxPlatform::Else(const wxString& value)
 330 {
 331     m_stringValue = value;
 332     return *this;
 333 }
 334
 335 void wxPlatform::AddPlatform(int platform)
 336 {
 337     if (!sm_customPlatforms)
 338         sm_customPlatforms = new wxArrayInt;
 339     sm_customPlatforms->Add(platform);
 340 }
 341
 342 void wxPlatform::ClearPlatforms()
 343 {
 344     wxDELETE(sm_customPlatforms);
 345 }
 346
 347 /// Function for testing current platform
 348
 349 bool wxPlatform::Is(int platform)
 350 {
 351 #ifdef __WINDOWS__
 352     if (platform == wxOS_WINDOWS)
 353         return true;
 354 #endif
 355 #ifdef __WXWINCE__
 356     if (platform == wxOS_WINDOWS_CE)
 357         return true;
 358 #endif
 359
 360 #if 0
 361
 362 // FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
 363
 364 #if defined(__WXWINCE__) && defined(__POCKETPC__)
 365     if (platform == wxWinPocketPC)
 366         return true;
 367 #endif
 368 #if defined(__WXWINCE__) && defined(__SMARTPHONE__)
 369     if (platform == wxWinSmartPhone)
 370         return true;
 371 #endif
 372
 373 #endif
 374
 375 #ifdef __WXGTK__
 376     if (platform == wxPORT_GTK)
 377         return true;
 378 #endif
 379 #ifdef __WXMAC__
 380     if (platform == wxPORT_MAC)
 381         return true;
 382 #endif
 383 #ifdef __WXX11__
 384     if (platform == wxPORT_X11)
 385         return true;
 386 #endif
 387 #ifdef __UNIX__
 388     if (platform == wxOS_UNIX)
 389         return true;
 390 #endif
 391 #ifdef __OS2__
 392     if (platform == wxOS_OS2)
 393         return true;
 394 #endif
 395 #ifdef __WXPM__
 396     if (platform == wxPORT_PM)
 397         return true;
 398 #endif
 399 #ifdef __WXCOCOA__
 400     if (platform == wxPORT_MAC)
 401         return true;
 402 #endif
 403
 404     if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND)
 405         return true;
 406
 407     return false;
 408 }
 409
 410 // ----------------------------------------------------------------------------
 411 // network and user id functions
 412 // ----------------------------------------------------------------------------
 413
 414 // Get Full RFC822 style email address
 415 bool wxGetEmailAddress(wxChar *address, int maxSize)
 416 {
 417     wxString email = wxGetEmailAddress();
 418     if ( !email )
 419         return false;
 420
 421     wxStrlcpy(address, email.t_str(), maxSize);
 422
 423     return true;
 424 }
 425
 426 wxString wxGetEmailAddress()
 427 {
 428     wxString email;
 429
 430     wxString host = wxGetFullHostName();
 431     if ( !host.empty() )
 432     {
 433         wxString user = wxGetUserId();
 434         if ( !user.empty() )
 435         {
 436             email << user << wxT('@') << host;
 437         }
 438     }
 439
 440     return email;
 441 }
 442
 443 wxString wxGetUserId()
 444 {
 445     static const int maxLoginLen = 256; // FIXME arbitrary number
 446
 447     wxString buf;
 448     bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
 449
 450     if ( !ok )
 451         buf.Empty();
 452
 453     return buf;
 454 }
 455
 456 wxString wxGetUserName()
 457 {
 458     static const int maxUserNameLen = 1024; // FIXME arbitrary number
 459
 460     wxString buf;
 461     bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
 462
 463     if ( !ok )
 464         buf.Empty();
 465
 466     return buf;
 467 }
 468
 469 wxString wxGetHostName()
 470 {
 471     static const size_t hostnameSize = 257;
 472
 473     wxString buf;
 474     bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
 475
 476     if ( !ok )
 477         buf.Empty();
 478
 479     return buf;
 480 }
 481
 482 wxString wxGetFullHostName()
 483 {
 484     static const size_t hostnameSize = 257;
 485
 486     wxString buf;
 487     bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
 488
 489     if ( !ok )
 490         buf.Empty();
 491
 492     return buf;
 493 }
 494
 495 wxString wxGetHomeDir()
 496 {
 497     wxString home;
 498     wxGetHomeDir(&home);
 499
 500     return home;
 501 }
 502
 503 #if 0
 504
 505 wxString wxGetCurrentDir()
 506 {
 507     wxString dir;
 508     size_t len = 1024;
 509     bool ok;
 510     do
 511     {
 512         ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
 513         dir.UngetWriteBuf();
 514
 515         if ( !ok )
 516         {
 517             if ( errno != ERANGE )
 518             {
 519                 wxLogSysError(wxT("Failed to get current directory"));
 520
 521                 return wxEmptyString;
 522             }
 523             else
 524             {
 525                 // buffer was too small, retry with a larger one
 526                 len *= 2;
 527             }
 528         }
 529         //else: ok
 530     } while ( !ok );
 531
 532     return dir;
 533 }
 534
 535 #endif // 0
 536
 537 // ----------------------------------------------------------------------------
 538 // Environment
 539 // ----------------------------------------------------------------------------
 540
 541 #ifdef __WXOSX__
 542 #if wxOSX_USE_COCOA_OR_CARBON
 543     #include <crt_externs.h>
 544 #endif
 545 #endif
 546
 547 bool wxGetEnvMap(wxEnvVariableHashMap *map)
 548 {
 549     wxCHECK_MSG( map, false, wxS("output pointer can't be NULL") );
 550
 551 #if defined(__VISUALC__)
 552     // This variable only exists to force the CRT to fill the wide char array,
 553     // it might only have it in narrow char version until now as we use main()
 554     // (and not _wmain()) as our entry point.
 555     static wxChar* s_dummyEnvVar = _tgetenv(wxT("TEMP"));
 556
 557     wxChar **env = _tenviron;
 558 #elif defined(__VMS)
 559    // Now this routine wil give false for OpenVMS
 560    // TODO : should we do something with logicals?
 561     char **env=NULL;
 562 #elif defined(__DARWIN__)
 563 #if wxOSX_USE_COCOA_OR_CARBON
 564     // Under Mac shared libraries don't have access to the global environ
 565     // variable so use this Mac-specific function instead as advised by
 566     // environ(7) under Darwin
 567     char ***penv = _NSGetEnviron();
 568     if ( !penv )
 569         return false;
 570     char **env = *penv;
 571 #else
 572     char **env=NULL;
 573     // todo translate NSProcessInfo environment into map
 574 #endif
 575 #else // non-MSVC non-Mac
 576     // Not sure if other compilers have _tenviron so use the (more standard)
 577     // ANSI version only for them.
 578
 579     // Both POSIX and Single UNIX Specification say that this variable must
 580     // exist but not that it must be declared anywhere and, indeed, it's not
 581     // declared in several common systems (some BSDs, Solaris with native CC)
 582     // so we (re)declare it ourselves to deal with these cases. However we do
 583     // not do this under MSW where there can be DLL-related complications, i.e.
 584     // the variable might be DLL-imported or not. Luckily we don't have to
 585     // worry about this as all MSW compilers do seem to define it in their
 586     // standard headers anyhow so we can just rely on already having the
 587     // correct declaration. And if this turns out to be wrong, we can always
 588     // add a configure test checking whether it is declared later.
 589 #ifndef __WINDOWS__
 590     extern char **environ;
 591 #endif // !__WINDOWS__
 592
 593     char **env = environ;
 594 #endif
 595
 596     if ( env )
 597     {
 598         wxString name,
 599                  value;
 600         while ( *env )
 601         {
 602             const wxString var(*env);
 603
 604             name = var.BeforeFirst(wxS('='), &value);
 605
 606             (*map)[name] = value;
 607
 608             env++;
 609         }
 610
 611         return true;
 612     }
 613
 614     return false;
 615 }
 616
 617 // ----------------------------------------------------------------------------
 618 // wxExecute
 619 // ----------------------------------------------------------------------------
 620
 621 // wxDoExecuteWithCapture() helper: reads an entire stream into one array
 622 //
 623 // returns true if ok, false if error
 624 #if wxUSE_STREAMS
 625 static bool ReadAll(wxInputStream *is, wxArrayString& output)
 626 {
 627     wxCHECK_MSG( is, false, wxT("NULL stream in wxExecute()?") );
 628
 629     // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
 630     is->Reset();
 631
 632     wxTextInputStream tis(*is);
 633
 634     for ( ;; )
 635     {
 636         wxString line = tis.ReadLine();
 637
 638         // check for EOF before other errors as it's not really an error
 639         if ( is->Eof() )
 640         {
 641             // add the last, possibly incomplete, line
 642             if ( !line.empty() )
 643                 output.Add(line);
 644             break;
 645         }
 646
 647         // any other error is fatal
 648         if ( !*is )
 649             return false;
 650
 651         output.Add(line);
 652     }
 653
 654     return true;
 655 }
 656 #endif // wxUSE_STREAMS
 657
 658 // this is a private function because it hasn't a clean interface: the first
 659 // array is passed by reference, the second by pointer - instead we have 2
 660 // public versions of wxExecute() below
 661 static long wxDoExecuteWithCapture(const wxString& command,
 662                                    wxArrayString& output,
 663                                    wxArrayString* error,
 664                                    int flags,
 665                                    const wxExecuteEnv *env)
 666 {
 667     // create a wxProcess which will capture the output
 668     wxProcess *process = new wxProcess;
 669     process->Redirect();
 670
 671     long rc = wxExecute(command, wxEXEC_SYNC | flags, process, env);
 672
 673 #if wxUSE_STREAMS
 674     if ( rc != -1 )
 675     {
 676         if ( !ReadAll(process->GetInputStream(), output) )
 677             rc = -1;
 678
 679         if ( error )
 680         {
 681             if ( !ReadAll(process->GetErrorStream(), *error) )
 682                 rc = -1;
 683         }
 684
 685     }
 686 #else
 687     wxUnusedVar(output);
 688     wxUnusedVar(error);
 689 #endif // wxUSE_STREAMS/!wxUSE_STREAMS
 690
 691     delete process;
 692
 693     return rc;
 694 }
 695
 696 long wxExecute(const wxString& command, wxArrayString& output, int flags,
 697                const wxExecuteEnv *env)
 698 {
 699     return wxDoExecuteWithCapture(command, output, NULL, flags, env);
 700 }
 701
 702 long wxExecute(const wxString& command,
 703                wxArrayString& output,
 704                wxArrayString& error,
 705                int flags,
 706                const wxExecuteEnv *env)
 707 {
 708     return wxDoExecuteWithCapture(command, output, &error, flags, env);
 709 }
 710
 711 // ----------------------------------------------------------------------------
 712 // Id functions
 713 // ----------------------------------------------------------------------------
 714
 715 // Id generation
 716 static long wxCurrentId = 100;
 717
 718 long wxNewId()
 719 {
 720     // skip the part of IDs space that contains hard-coded values:
 721     if (wxCurrentId == wxID_LOWEST)
 722         wxCurrentId = wxID_HIGHEST + 1;
 723
 724     return wxCurrentId++;
 725 }
 726
 727 long
 728 wxGetCurrentId(void) { return wxCurrentId; }
 729
 730 void
 731 wxRegisterId (long id)
 732 {
 733   if (id >= wxCurrentId)
 734     wxCurrentId = id + 1;
 735 }
 736
 737 // ----------------------------------------------------------------------------
 738 // wxQsort, adapted by RR to allow user_data
 739 // ----------------------------------------------------------------------------
 740
 741 /* This file is part of the GNU C Library.
 742    Written by Douglas C. Schmidt (schmidt@ics.uci.edu).
 743
 744    Douglas Schmidt kindly gave permission to relicence the
 745    code under the wxWindows licence:
 746
 747 From: "Douglas C. Schmidt" <schmidt@dre.vanderbilt.edu>
 748 To: Robert Roebling <robert.roebling@uni-ulm.de>
 749 Subject: Re: qsort licence
 750 Date: Mon, 23 Jul 2007 03:44:25 -0500
 751 Sender: schmidt@dre.vanderbilt.edu
 752 Message-Id: <20070723084426.64F511000A8@tango.dre.vanderbilt.edu>
 753
 754 Hi Robert,
 755
 756 > [...] I'm asking if you'd be willing to relicence your code
 757 > under the wxWindows licence. [...]
 758
 759 That's fine with me [...]
 760
 761 Thanks,
 762
 763      Doug */
 764
 765
 766 /* Byte-wise swap two items of size SIZE. */
 767 #define SWAP(a, b, size)                                                      \
 768   do                                                                          \
 769     {                                                                         \
 770       register size_t __size = (size);                                        \
 771       register char *__a = (a), *__b = (b);                                   \
 772       do                                                                      \
 773         {                                                                     \
 774           char __tmp = *__a;                                                  \
 775           *__a++ = *__b;                                                      \
 776           *__b++ = __tmp;                                                     \
 777         } while (--__size > 0);                                               \
 778     } while (0)
 779
 780 /* Discontinue quicksort algorithm when partition gets below this size.
 781    This particular magic number was chosen to work best on a Sun 4/260. */
 782 #define MAX_THRESH 4
 783
 784 /* Stack node declarations used to store unfulfilled partition obligations. */
 785 typedef struct
 786   {
 787     char *lo;
 788     char *hi;
 789   } stack_node;
 790
 791 /* The next 4 #defines implement a very fast in-line stack abstraction. */
 792 #define STACK_SIZE        (8 * sizeof(unsigned long int))
 793 #define PUSH(low, high)   ((void) ((top->lo = (low)), (top->hi = (high)), ++top))
 794 #define POP(low, high)    ((void) (--top, (low = top->lo), (high = top->hi)))
 795 #define STACK_NOT_EMPTY   (stack < top)
 796
 797
 798 /* Order size using quicksort.  This implementation incorporates
 799    four optimizations discussed in Sedgewick:
 800
 801    1. Non-recursive, using an explicit stack of pointer that store the
 802       next array partition to sort.  To save time, this maximum amount
 803       of space required to store an array of MAX_INT is allocated on the
 804       stack.  Assuming a 32-bit integer, this needs only 32 *
 805       sizeof(stack_node) == 136 bits.  Pretty cheap, actually.
 806
 807    2. Chose the pivot element using a median-of-three decision tree.
 808       This reduces the probability of selecting a bad pivot value and
 809       eliminates certain extraneous comparisons.
 810
 811    3. Only quicksorts TOTAL_ELEMS / MAX_THRESH partitions, leaving
 812       insertion sort to order the MAX_THRESH items within each partition.
 813       This is a big win, since insertion sort is faster for small, mostly
 814       sorted array segments.
 815
 816    4. The larger of the two sub-partitions is always pushed onto the
 817       stack first, with the algorithm then concentrating on the
 818       smaller partition.  This *guarantees* no more than log (n)
 819       stack size is needed (actually O(1) in this case)!  */
 820
 821 void wxQsort(void* pbase, size_t total_elems,
 822              size_t size, wxSortCallback cmp, const void* user_data)
 823 {
 824   register char *base_ptr = (char *) pbase;
 825   const size_t max_thresh = MAX_THRESH * size;
 826
 827   if (total_elems == 0)
 828     /* Avoid lossage with unsigned arithmetic below.  */
 829     return;
 830
 831   if (total_elems > MAX_THRESH)
 832     {
 833       char *lo = base_ptr;
 834       char *hi = &lo[size * (total_elems - 1)];
 835       stack_node stack[STACK_SIZE];
 836       stack_node *top = stack;
 837
 838       PUSH (NULL, NULL);
 839
 840       while (STACK_NOT_EMPTY)
 841         {
 842           char *left_ptr;
 843           char *right_ptr;
 844
 845           /* Select median value from among LO, MID, and HI. Rearrange
 846              LO and HI so the three values are sorted. This lowers the
 847              probability of picking a pathological pivot value and
 848              skips a comparison for both the LEFT_PTR and RIGHT_PTR. */
 849
 850           char *mid = lo + size * ((hi - lo) / size >> 1);
 851
 852           if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
 853             SWAP (mid, lo, size);
 854           if ((*cmp) ((void *) hi, (void *) mid, user_data) < 0)
 855             SWAP (mid, hi, size);
 856           else
 857             goto jump_over;
 858           if ((*cmp) ((void *) mid, (void *) lo, user_data) < 0)
 859             SWAP (mid, lo, size);
 860         jump_over:;
 861           left_ptr  = lo + size;
 862           right_ptr = hi - size;
 863
 864           /* Here's the famous ``collapse the walls'' section of quicksort.
 865              Gotta like those tight inner loops!  They are the main reason
 866              that this algorithm runs much faster than others. */
 867           do
 868             {
 869               while ((*cmp) ((void *) left_ptr, (void *) mid, user_data) < 0)
 870                 left_ptr += size;
 871
 872               while ((*cmp) ((void *) mid, (void *) right_ptr, user_data) < 0)
 873                 right_ptr -= size;
 874
 875               if (left_ptr < right_ptr)
 876                 {
 877                   SWAP (left_ptr, right_ptr, size);
 878                   if (mid == left_ptr)
 879                     mid = right_ptr;
 880                   else if (mid == right_ptr)
 881                     mid = left_ptr;
 882                   left_ptr += size;
 883                   right_ptr -= size;
 884                 }
 885               else if (left_ptr == right_ptr)
 886                 {
 887                   left_ptr += size;
 888                   right_ptr -= size;
 889                   break;
 890                 }
 891             }
 892           while (left_ptr <= right_ptr);
 893
 894           /* Set up pointers for next iteration.  First determine whether
 895              left and right partitions are below the threshold size.  If so,
 896              ignore one or both.  Otherwise, push the larger partition's
 897              bounds on the stack and continue sorting the smaller one. */
 898
 899           if ((size_t) (right_ptr - lo) <= max_thresh)
 900             {
 901               if ((size_t) (hi - left_ptr) <= max_thresh)
 902                 /* Ignore both small partitions. */
 903                 POP (lo, hi);
 904               else
 905                 /* Ignore small left partition. */
 906                 lo = left_ptr;
 907             }
 908           else if ((size_t) (hi - left_ptr) <= max_thresh)
 909             /* Ignore small right partition. */
 910             hi = right_ptr;
 911           else if ((right_ptr - lo) > (hi - left_ptr))
 912             {
 913               /* Push larger left partition indices. */
 914               PUSH (lo, right_ptr);
 915               lo = left_ptr;
 916             }
 917           else
 918             {
 919               /* Push larger right partition indices. */
 920               PUSH (left_ptr, hi);
 921               hi = right_ptr;
 922             }
 923         }
 924     }
 925
 926   /* Once the BASE_PTR array is partially sorted by quicksort the rest
 927      is completely sorted using insertion sort, since this is efficient
 928      for partitions below MAX_THRESH size. BASE_PTR points to the beginning
 929      of the array to sort, and END_PTR points at the very last element in
 930      the array (*not* one beyond it!). */
 931
 932   {
 933     char *const end_ptr = &base_ptr[size * (total_elems - 1)];
 934     char *tmp_ptr = base_ptr;
 935     char *thresh = base_ptr + max_thresh;
 936     if ( thresh > end_ptr )
 937         thresh = end_ptr;
 938     register char *run_ptr;
 939
 940     /* Find smallest element in first threshold and place it at the
 941        array's beginning.  This is the smallest array element,
 942        and the operation speeds up insertion sort's inner loop. */
 943
 944     for (run_ptr = tmp_ptr + size; run_ptr <= thresh; run_ptr += size)
 945       if ((*cmp) ((void *) run_ptr, (void *) tmp_ptr, user_data) < 0)
 946         tmp_ptr = run_ptr;
 947
 948     if (tmp_ptr != base_ptr)
 949       SWAP (tmp_ptr, base_ptr, size);
 950
 951     /* Insertion sort, running from left-hand-side up to right-hand-side.  */
 952
 953     run_ptr = base_ptr + size;
 954     while ((run_ptr += size) <= end_ptr)
 955       {
 956         tmp_ptr = run_ptr - size;
 957         while ((*cmp) ((void *) run_ptr, (void *) tmp_ptr, user_data) < 0)
 958           tmp_ptr -= size;
 959
 960         tmp_ptr += size;
 961         if (tmp_ptr != run_ptr)
 962           {
 963             char *trav;
 964
 965             trav = run_ptr + size;
 966             while (--trav >= run_ptr)
 967               {
 968                 char c = *trav;
 969                 char *hi, *lo;
 970
 971                 for (hi = lo = trav; (lo -= size) >= tmp_ptr; hi = lo)
 972                   *hi = *lo;
 973                 *hi = c;
 974               }
 975           }
 976       }
 977   }
 978 }
 979
 980 #endif // wxUSE_BASE
 981
 982
 983
 984 // ============================================================================
 985 // GUI-only functions from now on
 986 // ============================================================================
 987
 988 #if wxUSE_GUI
 989
 990 // this function is only really implemented for X11-based ports, including GTK1
 991 // (GTK2 sets detectable auto-repeat automatically anyhow)
 992 #if !(defined(__WXX11__) || defined(__WXMOTIF__) || \
 993         (defined(__WXGTK__) && !defined(__WXGTK20__)))
 994 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
 995 {
 996     return true;
 997 }
 998 #endif // !X11-based port
 999
1000 // ----------------------------------------------------------------------------
1001 // Launch default browser
1002 // ----------------------------------------------------------------------------
1003
1004 #if defined(__WINDOWS__)
1005
1006 // implemented in a port-specific utils source file:
1007 bool wxDoLaunchDefaultBrowser(const wxString& url, const wxString& scheme, int flags);
1008
1009 #elif defined(__WXX11__) || defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXCOCOA__) || \
1010       (defined(__WXOSX__) )
1011
1012 // implemented in a port-specific utils source file:
1013 bool wxDoLaunchDefaultBrowser(const wxString& url, int flags);
1014
1015 #else
1016
1017 // a "generic" implementation:
1018 bool wxDoLaunchDefaultBrowser(const wxString& url, int flags)
1019 {
1020     // on other platforms try to use mime types or wxExecute...
1021
1022     bool ok = false;
1023     wxString cmd;
1024
1025 #if wxUSE_MIMETYPE
1026     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(wxT("html"));
1027     if ( ft )
1028     {
1029         wxString mt;
1030         ft->GetMimeType(&mt);
1031
1032         ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
1033         delete ft;
1034     }
1035 #endif // wxUSE_MIMETYPE
1036
1037     if ( !ok || cmd.empty() )
1038     {
1039         // fallback to checking for the BROWSER environment variable
1040         if ( !wxGetEnv(wxT("BROWSER"), &cmd) || cmd.empty() )
1041             cmd << wxT(' ') << url;
1042     }
1043
1044     ok = ( !cmd.empty() && wxExecute(cmd) );
1045     if (ok)
1046         return ok;
1047
1048     // no file type for HTML extension
1049     wxLogError(_("No default application configured for HTML files."));
1050
1051     return false;
1052 }
1053 #endif
1054
1055 static bool DoLaunchDefaultBrowserHelper(const wxString& urlOrig, int flags)
1056 {
1057     // NOTE: we don't have to care about the wxBROWSER_NOBUSYCURSOR flag
1058     //       as it was already handled by wxLaunchDefaultBrowser
1059
1060     wxUnusedVar(flags);
1061
1062     wxString url(urlOrig), scheme;
1063     wxURI uri(url);
1064
1065     // this check is useful to avoid that wxURI recognizes as scheme parts of
1066     // the filename, in case urlOrig is a local filename
1067     // (e.g. "C:\\test.txt" when parsed by wxURI reports a scheme == "C")
1068     bool hasValidScheme = uri.HasScheme() && uri.GetScheme().length() > 1;
1069
1070 #if defined(__WINDOWS__)
1071
1072     // NOTE: when testing wxMSW's wxLaunchDefaultBrowser all possible forms
1073     //       of the URL/flags should be tested; e.g.:
1074     //
1075     // for (int i=0; i<2; i++)
1076     // {
1077     //   // test arguments without a valid URL scheme:
1078     //   wxLaunchDefaultBrowser("C:\\test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1079     //   wxLaunchDefaultBrowser("wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1080     //
1081     //   // test arguments with different valid schemes:
1082     //   wxLaunchDefaultBrowser("file:/C%3A/test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1083     //   wxLaunchDefaultBrowser("http://wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1084     //   wxLaunchDefaultBrowser("mailto:user@host.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1085     // }
1086     // (assuming you have a C:\test.txt file)
1087
1088     if ( !hasValidScheme )
1089     {
1090         if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
1091         {
1092             scheme = "file";
1093             // do not prepend the file scheme to the URL as ShellExecuteEx() doesn't like it
1094         }
1095         else
1096         {
1097             url.Prepend(wxS("http://"));
1098             scheme = "http";
1099         }
1100     }
1101     else if ( hasValidScheme )
1102     {
1103         scheme = uri.GetScheme();
1104
1105         if ( uri.GetScheme() == "file" )
1106         {
1107             // TODO: extract URLToFileName() to some always compiled in
1108             //       function
1109 #if wxUSE_FILESYSTEM
1110             // ShellExecuteEx() doesn't like the "file" scheme when opening local files;
1111             // remove it
1112             url = wxFileSystem::URLToFileName(url).GetFullPath();
1113 #endif // wxUSE_FILESYSTEM
1114         }
1115     }
1116
1117     if (wxDoLaunchDefaultBrowser(url, scheme, flags))
1118         return true;
1119     //else: call wxLogSysError
1120 #else
1121     if ( !hasValidScheme )
1122     {
1123         // set the scheme of url to "http" or "file" if it does not have one
1124         if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
1125             url.Prepend(wxS("file://"));
1126         else
1127             url.Prepend(wxS("http://"));
1128     }
1129
1130     if (wxDoLaunchDefaultBrowser(url, flags))
1131         return true;
1132     //else: call wxLogSysError
1133 #endif
1134
1135     wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1136                   url.c_str());
1137
1138     return false;
1139 }
1140
1141 bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1142 {
1143     // NOTE: as documented, "url" may be both a real well-formed URL
1144     //       and a local file name
1145
1146     if ( flags & wxBROWSER_NOBUSYCURSOR )
1147         return DoLaunchDefaultBrowserHelper(url, flags);
1148
1149     wxBusyCursor bc;
1150     return DoLaunchDefaultBrowserHelper(url, flags);
1151 }
1152
1153 // ----------------------------------------------------------------------------
1154 // Menu accelerators related functions
1155 // ----------------------------------------------------------------------------
1156
1157 #if WXWIN_COMPATIBILITY_2_6
1158 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
1159 {
1160 #if wxUSE_MENUS
1161     wxString s = wxMenuItem::GetLabelText(in);
1162 #else
1163     wxString str(in);
1164     wxString s = wxStripMenuCodes(str);
1165 #endif // wxUSE_MENUS
1166     if ( out )
1167     {
1168         // go smash their buffer if it's not big enough - I love char * params
1169         memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1170     }
1171     else
1172     {
1173         out = new wxChar[s.length() + 1];
1174         wxStrcpy(out, s.c_str());
1175     }
1176
1177     return out;
1178 }
1179 #endif
1180
1181 wxString wxStripMenuCodes(const wxString& in, int flags)
1182 {
1183     wxASSERT_MSG( flags, wxT("this is useless to call without any flags") );
1184
1185     wxString out;
1186
1187     size_t len = in.length();
1188     out.reserve(len);
1189
1190     for ( wxString::const_iterator it = in.begin(); it != in.end(); ++it )
1191     {
1192         wxChar ch = *it;
1193         if ( (flags & wxStrip_Mnemonics) && ch == wxT('&') )
1194         {
1195             // skip it, it is used to introduce the accel char (or to quote
1196             // itself in which case it should still be skipped): note that it
1197             // can't be the last character of the string
1198             if ( ++it == in.end() )
1199             {
1200                 wxLogDebug(wxT("Invalid menu string '%s'"), in.c_str());
1201             }
1202             else
1203             {
1204                 // use the next char instead
1205                 ch = *it;
1206             }
1207         }
1208         else if ( (flags & wxStrip_Accel) && ch == wxT('\t') )
1209         {
1210             // everything after TAB is accel string, exit the loop
1211             break;
1212         }
1213
1214         out += ch;
1215     }
1216
1217     return out;
1218 }
1219
1220 // ----------------------------------------------------------------------------
1221 // Window search functions
1222 // ----------------------------------------------------------------------------
1223
1224 /*
1225  * If parent is non-NULL, look through children for a label or title
1226  * matching the specified string. If NULL, look through all top-level windows.
1227  *
1228  */
1229
1230 wxWindow *
1231 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1232 {
1233     return wxWindow::FindWindowByLabel( title, parent );
1234 }
1235
1236
1237 /*
1238  * If parent is non-NULL, look through children for a name
1239  * matching the specified string. If NULL, look through all top-level windows.
1240  *
1241  */
1242
1243 wxWindow *
1244 wxFindWindowByName (const wxString& name, wxWindow * parent)
1245 {
1246     return wxWindow::FindWindowByName( name, parent );
1247 }
1248
1249 // Returns menu item id or wxNOT_FOUND if none.
1250 int
1251 wxFindMenuItemId(wxFrame *frame,
1252                  const wxString& menuString,
1253                  const wxString& itemString)
1254 {
1255 #if wxUSE_MENUS
1256     wxMenuBar *menuBar = frame->GetMenuBar ();
1257     if ( menuBar )
1258         return menuBar->FindMenuItem (menuString, itemString);
1259 #else // !wxUSE_MENUS
1260     wxUnusedVar(frame);
1261     wxUnusedVar(menuString);
1262     wxUnusedVar(itemString);
1263 #endif // wxUSE_MENUS/!wxUSE_MENUS
1264
1265     return wxNOT_FOUND;
1266 }
1267
1268 // Try to find the deepest child that contains 'pt'.
1269 // We go backwards, to try to allow for controls that are spacially
1270 // within other controls, but are still siblings (e.g. buttons within
1271 // static boxes). Static boxes are likely to be created _before_ controls
1272 // that sit inside them.
1273 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1274 {
1275     if (!win->IsShown())
1276         return NULL;
1277
1278     // Hack for wxNotebook case: at least in wxGTK, all pages
1279     // claim to be shown, so we must only deal with the selected one.
1280 #if wxUSE_NOTEBOOK
1281     if (wxDynamicCast(win, wxNotebook))
1282     {
1283       wxNotebook* nb = (wxNotebook*) win;
1284       int sel = nb->GetSelection();
1285       if (sel >= 0)
1286       {
1287         wxWindow* child = nb->GetPage(sel);
1288         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1289         if (foundWin)
1290            return foundWin;
1291       }
1292     }
1293 #endif
1294
1295     wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1296     while (node)
1297     {
1298         wxWindow* child = node->GetData();
1299         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1300         if (foundWin)
1301           return foundWin;
1302         node = node->GetPrevious();
1303     }
1304
1305     wxPoint pos = win->GetPosition();
1306     wxSize sz = win->GetSize();
1307     if ( !win->IsTopLevel() && win->GetParent() )
1308     {
1309         pos = win->GetParent()->ClientToScreen(pos);
1310     }
1311
1312     wxRect rect(pos, sz);
1313     if (rect.Contains(pt))
1314         return win;
1315
1316     return NULL;
1317 }
1318
1319 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1320 {
1321     // Go backwards through the list since windows
1322     // on top are likely to have been appended most
1323     // recently.
1324     wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1325     while (node)
1326     {
1327         wxWindow* win = node->GetData();
1328         wxWindow* found = wxFindWindowAtPoint(win, pt);
1329         if (found)
1330             return found;
1331         node = node->GetPrevious();
1332     }
1333     return NULL;
1334 }
1335
1336 // ----------------------------------------------------------------------------
1337 // GUI helpers
1338 // ----------------------------------------------------------------------------
1339
1340 /*
1341  * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1342  * since otherwise the generic code may be pulled in unnecessarily.
1343  */
1344
1345 #if wxUSE_MSGDLG
1346
1347 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1348                  wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1349 {
1350     // add the appropriate icon unless this was explicitly disabled by use of
1351     // wxICON_NONE
1352     if ( !(style & wxICON_NONE) && !(style & wxICON_MASK) )
1353     {
1354         style |= style & wxYES ? wxICON_QUESTION : wxICON_INFORMATION;
1355     }
1356
1357     wxMessageDialog dialog(parent, message, caption, style);
1358
1359     int ans = dialog.ShowModal();
1360     switch ( ans )
1361     {
1362         case wxID_OK:
1363             return wxOK;
1364         case wxID_YES:
1365             return wxYES;
1366         case wxID_NO:
1367             return wxNO;
1368         case wxID_CANCEL:
1369             return wxCANCEL;
1370         case wxID_HELP:
1371             return wxHELP;
1372     }
1373
1374     wxFAIL_MSG( wxT("unexpected return code from wxMessageDialog") );
1375
1376     return wxCANCEL;
1377 }
1378
1379 wxVersionInfo wxGetLibraryVersionInfo()
1380 {
1381     // don't translate these strings, they're for diagnostics purposes only
1382     wxString msg;
1383     msg.Printf(wxS("wxWidgets Library (%s port)\n")
1384                wxS("Version %d.%d.%d (Unicode: %s, debug level: %d),\n")
1385                wxS("compiled at %s %s\n\n")
1386                wxS("Runtime version of toolkit used is %d.%d.\n"),
1387                wxPlatformInfo::Get().GetPortIdName(),
1388                wxMAJOR_VERSION,
1389                wxMINOR_VERSION,
1390                wxRELEASE_NUMBER,
1391 #if wxUSE_UNICODE_UTF8
1392                "UTF-8",
1393 #elif wxUSE_UNICODE
1394                "wchar_t",
1395 #else
1396                "none",
1397 #endif
1398                wxDEBUG_LEVEL,
1399                __TDATE__,
1400                __TTIME__,
1401                wxPlatformInfo::Get().GetToolkitMajorVersion(),
1402                wxPlatformInfo::Get().GetToolkitMinorVersion()
1403               );
1404
1405 #ifdef __WXGTK__
1406     msg += wxString::Format("Compile-time GTK+ version is %d.%d.%d.\n",
1407                             GTK_MAJOR_VERSION,
1408                             GTK_MINOR_VERSION,
1409                             GTK_MICRO_VERSION);
1410 #endif // __WXGTK__
1411
1412     return wxVersionInfo(wxS("wxWidgets"),
1413                          wxMAJOR_VERSION,
1414                          wxMINOR_VERSION,
1415                          wxRELEASE_NUMBER,
1416                          msg,
1417                          wxS("Copyright (c) 1995-2011 wxWidgets team"));
1418 }
1419
1420 void wxInfoMessageBox(wxWindow* parent)
1421 {
1422     wxVersionInfo info = wxGetLibraryVersionInfo();
1423     wxString msg = info.ToString();
1424
1425     msg << wxS("\n") << info.GetCopyright();
1426
1427     wxMessageBox(msg, wxT("wxWidgets information"),
1428                  wxICON_INFORMATION | wxOK,
1429                  parent);
1430 }
1431
1432 #endif // wxUSE_MSGDLG
1433
1434 #if wxUSE_TEXTDLG
1435
1436 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1437                         const wxString& defaultValue, wxWindow *parent,
1438                         wxCoord x, wxCoord y, bool centre )
1439 {
1440     wxString str;
1441     long style = wxTextEntryDialogStyle;
1442
1443     if (centre)
1444         style |= wxCENTRE;
1445     else
1446         style &= ~wxCENTRE;
1447
1448     wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1449
1450     if (dialog.ShowModal() == wxID_OK)
1451     {
1452         str = dialog.GetValue();
1453     }
1454
1455     return str;
1456 }
1457
1458 wxString wxGetPasswordFromUser(const wxString& message,
1459                                const wxString& caption,
1460                                const wxString& defaultValue,
1461                                wxWindow *parent,
1462                                wxCoord x, wxCoord y, bool centre )
1463 {
1464     wxString str;
1465     long style = wxTextEntryDialogStyle;
1466
1467     if (centre)
1468         style |= wxCENTRE;
1469     else
1470         style &= ~wxCENTRE;
1471
1472     wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1473                              style, wxPoint(x, y));
1474     if ( dialog.ShowModal() == wxID_OK )
1475     {
1476         str = dialog.GetValue();
1477     }
1478
1479     return str;
1480 }
1481
1482 #endif // wxUSE_TEXTDLG
1483
1484 // ----------------------------------------------------------------------------
1485 // wxSafeYield and supporting functions
1486 // ----------------------------------------------------------------------------
1487
1488 void wxEnableTopLevelWindows(bool enable)
1489 {
1490     wxWindowList::compatibility_iterator node;
1491     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1492         node->GetData()->Enable(enable);
1493 }
1494
1495 #if defined(__WXOSX__) && wxOSX_USE_COCOA
1496
1497 // defined in evtloop.mm
1498
1499 #else
1500
1501 wxWindowDisabler::wxWindowDisabler(bool disable)
1502 {
1503     m_disabled = disable;
1504     if ( disable )
1505         DoDisable();
1506 }
1507
1508 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1509 {
1510     m_disabled = true;
1511     DoDisable(winToSkip);
1512 }
1513
1514 void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
1515 {
1516     // remember the top level windows which were already disabled, so that we
1517     // don't reenable them later
1518     m_winDisabled = NULL;
1519
1520     wxWindowList::compatibility_iterator node;
1521     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1522     {
1523         wxWindow *winTop = node->GetData();
1524         if ( winTop == winToSkip )
1525             continue;
1526
1527         // we don't need to disable the hidden or already disabled windows
1528         if ( winTop->IsEnabled() && winTop->IsShown() )
1529         {
1530             winTop->Disable();
1531         }
1532         else
1533         {
1534             if ( !m_winDisabled )
1535             {
1536                 m_winDisabled = new wxWindowList;
1537             }
1538
1539             m_winDisabled->Append(winTop);
1540         }
1541     }
1542 }
1543
1544 wxWindowDisabler::~wxWindowDisabler()
1545 {
1546     if ( !m_disabled )
1547         return;
1548
1549     wxWindowList::compatibility_iterator node;
1550     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1551     {
1552         wxWindow *winTop = node->GetData();
1553         if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1554         {
1555             winTop->Enable();
1556         }
1557         //else: had been already disabled, don't reenable
1558     }
1559
1560     delete m_winDisabled;
1561 }
1562
1563 #endif
1564
1565 // Yield to other apps/messages and disable user input to all windows except
1566 // the given one
1567 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1568 {
1569     wxWindowDisabler wd(win);
1570
1571     bool rc;
1572     if (onlyIfNeeded)
1573         rc = wxYieldIfNeeded();
1574     else
1575         rc = wxYield();
1576
1577     return rc;
1578 }
1579
1580 // ----------------------------------------------------------------------------
1581 // wxApp::Yield() wrappers for backwards compatibility
1582 // ----------------------------------------------------------------------------
1583
1584 bool wxYield()
1585 {
1586     return wxTheApp && wxTheApp->Yield();
1587 }
1588
1589 bool wxYieldIfNeeded()
1590 {
1591     return wxTheApp && wxTheApp->Yield(true);
1592 }
1593
1594 #endif // wxUSE_GUI