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
  56 #if defined(__WXWINCE__) && wxUSE_DATETIME
  57     #include "wx/datetime.h"
  58 #endif
  59
  60 #include <ctype.h>
  61 #include <stdio.h>
  62 #include <stdlib.h>
  63 #include <string.h>
  64
  65 #if !wxONLY_WATCOM_EARLIER_THAN(1,4)
  66     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
  67         #include <errno.h>
  68     #endif
  69 #endif
  70
  71 #if wxUSE_GUI
  72     #include "wx/colordlg.h"
  73     #include "wx/fontdlg.h"
  74     #include "wx/notebook.h"
  75     #include "wx/statusbr.h"
  76 #endif // wxUSE_GUI
  77
  78 #ifndef __WXPALMOS5__
  79 #ifndef __WXWINCE__
  80     #include <time.h>
  81 #else
  82     #include "wx/msw/wince/time.h"
  83 #endif
  84 #endif // ! __WXPALMOS5__
  85
  86 #ifdef __WXMAC__
  87     #include "wx/osx/private.h"
  88 #endif
  89
  90 #ifndef __WXPALMOS5__
  91 #if !defined(__MWERKS__) && !defined(__WXWINCE__)
  92     #include <sys/types.h>
  93     #include <sys/stat.h>
  94 #endif
  95 #endif // ! __WXPALMOS5__
  96
  97 #if defined(__WXMSW__)
  98     #include "wx/msw/private.h"
  99     #include "wx/filesys.h"
 100 #endif
 101
 102 #if wxUSE_GUI && defined(__WXGTK__)
 103     #include <gtk/gtk.h>    // for GTK_XXX_VERSION constants
 104 #endif
 105
 106 #if wxUSE_BASE
 107
 108 // ============================================================================
 109 // implementation
 110 // ============================================================================
 111
 112 // Array used in DecToHex conversion routine.
 113 static wxChar hexArray[] = wxT("0123456789ABCDEF");
 114
 115 // Convert 2-digit hex number to decimal
 116 int wxHexToDec(const wxString& buf)
 117 {
 118     int firstDigit, secondDigit;
 119
 120     if (buf.GetChar(0) >= wxT('A'))
 121         firstDigit = buf.GetChar(0) - wxT('A') + 10;
 122     else
 123         firstDigit = buf.GetChar(0) - wxT('0');
 124
 125     if (buf.GetChar(1) >= wxT('A'))
 126         secondDigit = buf.GetChar(1) - wxT('A') + 10;
 127     else
 128         secondDigit = buf.GetChar(1) - wxT('0');
 129
 130     return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
 131 }
 132
 133 // Convert decimal integer to 2-character hex string
 134 void wxDecToHex(int dec, wxChar *buf)
 135 {
 136     int firstDigit = (int)(dec/16.0);
 137     int secondDigit = (int)(dec - (firstDigit*16.0));
 138     buf[0] = hexArray[firstDigit];
 139     buf[1] = hexArray[secondDigit];
 140     buf[2] = 0;
 141 }
 142
 143 // Convert decimal integer to 2 characters
 144 void wxDecToHex(int dec, char* ch1, char* ch2)
 145 {
 146     int firstDigit = (int)(dec/16.0);
 147     int secondDigit = (int)(dec - (firstDigit*16.0));
 148     (*ch1) = (char) hexArray[firstDigit];
 149     (*ch2) = (char) hexArray[secondDigit];
 150 }
 151
 152 // Convert decimal integer to 2-character hex string
 153 wxString wxDecToHex(int dec)
 154 {
 155     wxChar buf[3];
 156     wxDecToHex(dec, buf);
 157     return wxString(buf);
 158 }
 159
 160 // ----------------------------------------------------------------------------
 161 // misc functions
 162 // ----------------------------------------------------------------------------
 163
 164 // Don't synthesize KeyUp events holding down a key and producing KeyDown
 165 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
 166 // in utilsgtk.cpp.
 167 #ifndef __WXGTK__
 168 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
 169 {
 170     return true;    // detectable auto-repeat is the only mode MSW supports
 171 }
 172 #endif // !wxGTK
 173
 174 // Return the current date/time
 175 wxString wxNow()
 176 {
 177 #ifdef __WXWINCE__
 178 #if wxUSE_DATETIME
 179     wxDateTime now = wxDateTime::Now();
 180     return now.Format();
 181 #else
 182     return wxEmptyString;
 183 #endif
 184 #else
 185     time_t now = time((time_t *) NULL);
 186     char *date = ctime(&now);
 187     date[24] = '\0';
 188     return wxString::FromAscii(date);
 189 #endif
 190 }
 191
 192 #if WXWIN_COMPATIBILITY_2_8
 193 void wxUsleep(unsigned long milliseconds)
 194 {
 195     wxMilliSleep(milliseconds);
 196 }
 197 #endif
 198
 199 const wxChar *wxGetInstallPrefix()
 200 {
 201     wxString prefix;
 202
 203     if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
 204         return prefix.c_str();
 205
 206 #ifdef wxINSTALL_PREFIX
 207     return wxT(wxINSTALL_PREFIX);
 208 #else
 209     return wxEmptyString;
 210 #endif
 211 }
 212
 213 wxString wxGetDataDir()
 214 {
 215     wxString dir = wxGetInstallPrefix();
 216     dir <<  wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx");
 217     return dir;
 218 }
 219
 220 bool wxIsPlatformLittleEndian()
 221 {
 222     // Are we little or big endian? This method is from Harbison & Steele.
 223     union
 224     {
 225         long l;
 226         char c[sizeof(long)];
 227     } u;
 228     u.l = 1;
 229
 230     return u.c[0] == 1;
 231 }
 232
 233
 234 // ----------------------------------------------------------------------------
 235 // wxPlatform
 236 // ----------------------------------------------------------------------------
 237
 238 /*
 239  * Class to make it easier to specify platform-dependent values
 240  */
 241
 242 wxArrayInt*  wxPlatform::sm_customPlatforms = NULL;
 243
 244 void wxPlatform::Copy(const wxPlatform& platform)
 245 {
 246     m_longValue = platform.m_longValue;
 247     m_doubleValue = platform.m_doubleValue;
 248     m_stringValue = platform.m_stringValue;
 249 }
 250
 251 wxPlatform wxPlatform::If(int platform, long value)
 252 {
 253     if (Is(platform))
 254         return wxPlatform(value);
 255     else
 256         return wxPlatform();
 257 }
 258
 259 wxPlatform wxPlatform::IfNot(int platform, long value)
 260 {
 261     if (!Is(platform))
 262         return wxPlatform(value);
 263     else
 264         return wxPlatform();
 265 }
 266
 267 wxPlatform& wxPlatform::ElseIf(int platform, long value)
 268 {
 269     if (Is(platform))
 270         m_longValue = value;
 271     return *this;
 272 }
 273
 274 wxPlatform& wxPlatform::ElseIfNot(int platform, long value)
 275 {
 276     if (!Is(platform))
 277         m_longValue = value;
 278     return *this;
 279 }
 280
 281 wxPlatform wxPlatform::If(int platform, double value)
 282 {
 283     if (Is(platform))
 284         return wxPlatform(value);
 285     else
 286         return wxPlatform();
 287 }
 288
 289 wxPlatform wxPlatform::IfNot(int platform, double value)
 290 {
 291     if (!Is(platform))
 292         return wxPlatform(value);
 293     else
 294         return wxPlatform();
 295 }
 296
 297 wxPlatform& wxPlatform::ElseIf(int platform, double value)
 298 {
 299     if (Is(platform))
 300         m_doubleValue = value;
 301     return *this;
 302 }
 303
 304 wxPlatform& wxPlatform::ElseIfNot(int platform, double value)
 305 {
 306     if (!Is(platform))
 307         m_doubleValue = value;
 308     return *this;
 309 }
 310
 311 wxPlatform wxPlatform::If(int platform, const wxString& value)
 312 {
 313     if (Is(platform))
 314         return wxPlatform(value);
 315     else
 316         return wxPlatform();
 317 }
 318
 319 wxPlatform wxPlatform::IfNot(int platform, const wxString& value)
 320 {
 321     if (!Is(platform))
 322         return wxPlatform(value);
 323     else
 324         return wxPlatform();
 325 }
 326
 327 wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value)
 328 {
 329     if (Is(platform))
 330         m_stringValue = value;
 331     return *this;
 332 }
 333
 334 wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value)
 335 {
 336     if (!Is(platform))
 337         m_stringValue = value;
 338     return *this;
 339 }
 340
 341 wxPlatform& wxPlatform::Else(long value)
 342 {
 343     m_longValue = value;
 344     return *this;
 345 }
 346
 347 wxPlatform& wxPlatform::Else(double value)
 348 {
 349     m_doubleValue = value;
 350     return *this;
 351 }
 352
 353 wxPlatform& wxPlatform::Else(const wxString& value)
 354 {
 355     m_stringValue = value;
 356     return *this;
 357 }
 358
 359 void wxPlatform::AddPlatform(int platform)
 360 {
 361     if (!sm_customPlatforms)
 362         sm_customPlatforms = new wxArrayInt;
 363     sm_customPlatforms->Add(platform);
 364 }
 365
 366 void wxPlatform::ClearPlatforms()
 367 {
 368     delete sm_customPlatforms;
 369     sm_customPlatforms = NULL;
 370 }
 371
 372 /// Function for testing current platform
 373
 374 bool wxPlatform::Is(int platform)
 375 {
 376 #ifdef __WXMSW__
 377     if (platform == wxOS_WINDOWS)
 378         return true;
 379 #endif
 380 #ifdef __WXWINCE__
 381     if (platform == wxOS_WINDOWS_CE)
 382         return true;
 383 #endif
 384
 385 #if 0
 386
 387 // FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
 388
 389 #if defined(__WXWINCE__) && defined(__POCKETPC__)
 390     if (platform == wxWinPocketPC)
 391         return true;
 392 #endif
 393 #if defined(__WXWINCE__) && defined(__SMARTPHONE__)
 394     if (platform == wxWinSmartPhone)
 395         return true;
 396 #endif
 397
 398 #endif
 399
 400 #ifdef __WXGTK__
 401     if (platform == wxPORT_GTK)
 402         return true;
 403 #endif
 404 #ifdef __WXMAC__
 405     if (platform == wxPORT_MAC)
 406         return true;
 407 #endif
 408 #ifdef __WXX11__
 409     if (platform == wxPORT_X11)
 410         return true;
 411 #endif
 412 #ifdef __UNIX__
 413     if (platform == wxOS_UNIX)
 414         return true;
 415 #endif
 416 #ifdef __WXMGL__
 417     if (platform == wxPORT_MGL)
 418         return true;
 419 #endif
 420 #ifdef __OS2__
 421     if (platform == wxOS_OS2)
 422         return true;
 423 #endif
 424 #ifdef __WXPM__
 425     if (platform == wxPORT_PM)
 426         return true;
 427 #endif
 428 #ifdef __WXCOCOA__
 429     if (platform == wxPORT_MAC)
 430         return true;
 431 #endif
 432
 433     if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND)
 434         return true;
 435
 436     return false;
 437 }
 438
 439 // ----------------------------------------------------------------------------
 440 // network and user id functions
 441 // ----------------------------------------------------------------------------
 442
 443 // Get Full RFC822 style email address
 444 bool wxGetEmailAddress(wxChar *address, int maxSize)
 445 {
 446     wxString email = wxGetEmailAddress();
 447     if ( !email )
 448         return false;
 449
 450     wxStrlcpy(address, email.t_str(), maxSize);
 451
 452     return true;
 453 }
 454
 455 wxString wxGetEmailAddress()
 456 {
 457     wxString email;
 458
 459     wxString host = wxGetFullHostName();
 460     if ( !host.empty() )
 461     {
 462         wxString user = wxGetUserId();
 463         if ( !user.empty() )
 464         {
 465             email << user << wxT('@') << host;
 466         }
 467     }
 468
 469     return email;
 470 }
 471
 472 wxString wxGetUserId()
 473 {
 474     static const int maxLoginLen = 256; // FIXME arbitrary number
 475
 476     wxString buf;
 477     bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
 478
 479     if ( !ok )
 480         buf.Empty();
 481
 482     return buf;
 483 }
 484
 485 wxString wxGetUserName()
 486 {
 487     static const int maxUserNameLen = 1024; // FIXME arbitrary number
 488
 489     wxString buf;
 490     bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
 491
 492     if ( !ok )
 493         buf.Empty();
 494
 495     return buf;
 496 }
 497
 498 wxString wxGetHostName()
 499 {
 500     static const size_t hostnameSize = 257;
 501
 502     wxString buf;
 503     bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
 504
 505     if ( !ok )
 506         buf.Empty();
 507
 508     return buf;
 509 }
 510
 511 wxString wxGetFullHostName()
 512 {
 513     static const size_t hostnameSize = 257;
 514
 515     wxString buf;
 516     bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
 517
 518     if ( !ok )
 519         buf.Empty();
 520
 521     return buf;
 522 }
 523
 524 wxString wxGetHomeDir()
 525 {
 526     wxString home;
 527     wxGetHomeDir(&home);
 528
 529     return home;
 530 }
 531
 532 #if 0
 533
 534 wxString wxGetCurrentDir()
 535 {
 536     wxString dir;
 537     size_t len = 1024;
 538     bool ok;
 539     do
 540     {
 541         ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
 542         dir.UngetWriteBuf();
 543
 544         if ( !ok )
 545         {
 546             if ( errno != ERANGE )
 547             {
 548                 wxLogSysError(_T("Failed to get current directory"));
 549
 550                 return wxEmptyString;
 551             }
 552             else
 553             {
 554                 // buffer was too small, retry with a larger one
 555                 len *= 2;
 556             }
 557         }
 558         //else: ok
 559     } while ( !ok );
 560
 561     return dir;
 562 }
 563
 564 #endif // 0
 565
 566 // ----------------------------------------------------------------------------
 567 // wxExecute
 568 // ----------------------------------------------------------------------------
 569
 570 // wxDoExecuteWithCapture() helper: reads an entire stream into one array
 571 //
 572 // returns true if ok, false if error
 573 #if wxUSE_STREAMS
 574 static bool ReadAll(wxInputStream *is, wxArrayString& output)
 575 {
 576     wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") );
 577
 578     // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
 579     is->Reset();
 580
 581     wxTextInputStream tis(*is);
 582
 583     for ( ;; )
 584     {
 585         wxString line = tis.ReadLine();
 586
 587         // check for EOF before other errors as it's not really an error
 588         if ( is->Eof() )
 589         {
 590             // add the last, possibly incomplete, line
 591             if ( !line.empty() )
 592                 output.Add(line);
 593             break;
 594         }
 595
 596         // any other error is fatal
 597         if ( !*is )
 598             return false;
 599
 600         output.Add(line);
 601     }
 602
 603     return true;
 604 }
 605 #endif // wxUSE_STREAMS
 606
 607 // this is a private function because it hasn't a clean interface: the first
 608 // array is passed by reference, the second by pointer - instead we have 2
 609 // public versions of wxExecute() below
 610 static long wxDoExecuteWithCapture(const wxString& command,
 611                                    wxArrayString& output,
 612                                    wxArrayString* error,
 613                                    int flags)
 614 {
 615     // create a wxProcess which will capture the output
 616     wxProcess *process = new wxProcess;
 617     process->Redirect();
 618
 619     long rc = wxExecute(command, wxEXEC_SYNC | flags, process);
 620
 621 #if wxUSE_STREAMS
 622     if ( rc != -1 )
 623     {
 624         if ( !ReadAll(process->GetInputStream(), output) )
 625             rc = -1;
 626
 627         if ( error )
 628         {
 629             if ( !ReadAll(process->GetErrorStream(), *error) )
 630                 rc = -1;
 631         }
 632
 633     }
 634 #else
 635     wxUnusedVar(output);
 636     wxUnusedVar(error);
 637 #endif // wxUSE_STREAMS/!wxUSE_STREAMS
 638
 639     delete process;
 640
 641     return rc;
 642 }
 643
 644 long wxExecute(const wxString& command, wxArrayString& output, int flags)
 645 {
 646     return wxDoExecuteWithCapture(command, output, NULL, flags);
 647 }
 648
 649 long wxExecute(const wxString& command,
 650                wxArrayString& output,
 651                wxArrayString& error,
 652                int flags)
 653 {
 654     return wxDoExecuteWithCapture(command, output, &error, flags);
 655 }
 656
 657 // ----------------------------------------------------------------------------
 658 // Id functions
 659 // ----------------------------------------------------------------------------
 660
 661 // Id generation
 662 static long wxCurrentId = 100;
 663
 664 long 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
 673 long
 674 wxGetCurrentId(void) { return wxCurrentId; }
 675
 676 void
 677 wxRegisterId (long id)
 678 {
 679   if (id >= wxCurrentId)
 680     wxCurrentId = id + 1;
 681 }
 682
 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).
 689
 690    Douglas Schmidt kindly gave permission to relicence the
 691    code under the wxWindows licence:
 692
 693 From: "Douglas C. Schmidt" <schmidt@dre.vanderbilt.edu>
 694 To: Robert Roebling <robert.roebling@uni-ulm.de>
 695 Subject: Re: qsort licence
 696 Date: Mon, 23 Jul 2007 03:44:25 -0500
 697 Sender: schmidt@dre.vanderbilt.edu
 698 Message-Id: <20070723084426.64F511000A8@tango.dre.vanderbilt.edu>
 699
 700 Hi Robert,
 701
 702 > [...] I'm asking if you'd be willing to relicence your code
 703 > under the wxWindows licence. [...]
 704
 705 That's fine with me [...]
 706
 707 Thanks,
 708
 709      Doug */
 710
 711
 712 /* Byte-wise swap two items of size SIZE. */
 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);                                               \
 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. */
 731 typedef 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. */
 738 #define STACK_SIZE        (8 * sizeof(unsigned long int))
 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)
 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
 767 void wxQsort(void *const pbase, size_t total_elems,
 768                              size_t size, CMPFUNCDATA cmp, const void* user_data)
 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
 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);
 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)
 848                 /* Ignore both small partitions. */
 849                 POP (lo, hi);
 850               else
 851                 /* Ignore small left partition. */
 852                 lo = left_ptr;
 853             }
 854           else if ((size_t) (hi - left_ptr) <= max_thresh)
 855             /* Ignore small right partition. */
 856             hi = right_ptr;
 857           else if ((right_ptr - lo) > (hi - left_ptr))
 858             {
 859               /* Push larger left partition indices. */
 860               PUSH (lo, right_ptr);
 861               lo = left_ptr;
 862             }
 863           else
 864             {
 865               /* Push larger right partition indices. */
 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
 878   {
 879     char *const end_ptr = &base_ptr[size * (total_elems - 1)];
 880     char *tmp_ptr = base_ptr;
 881     char *thresh = base_ptr + max_thresh;
 882     if ( thresh > end_ptr )
 883         thresh = end_ptr;
 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       {
 902         tmp_ptr = run_ptr - size;
 903         while ((*cmp) ((void *) run_ptr, (void *) tmp_ptr, user_data) < 0)
 904           tmp_ptr -= size;
 905
 906         tmp_ptr += size;
 907         if (tmp_ptr != run_ptr)
 908           {
 909             char *trav;
 910
 911             trav = run_ptr + size;
 912             while (--trav >= run_ptr)
 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 #endif // wxUSE_BASE
 927
 928
 929
 930 // ============================================================================
 931 // GUI-only functions from now on
 932 // ============================================================================
 933
 934 #if wxUSE_GUI
 935
 936 // ----------------------------------------------------------------------------
 937 // Launch default browser
 938 // ----------------------------------------------------------------------------
 939
 940 #if defined(__WXMSW__)
 941
 942 // implemented in a port-specific utils source file:
 943 bool wxDoLaunchDefaultBrowser(const wxString& url, const wxString& scheme, int flags);
 944
 945 #elif defined(__WXX11__) || defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXCOCOA__) || \
 946       (defined(__WXMAC__) && !defined(__WXOSX_IPHONE__))
 947
 948 // implemented in a port-specific utils source file:
 949 bool wxDoLaunchDefaultBrowser(const wxString& url, int flags);
 950
 951 #else
 952
 953 // a "generic" implementation:
 954 bool wxDoLaunchDefaultBrowser(const wxString& url, int flags)
 955 {
 956     // on other platforms try to use mime types or wxExecute...
 957
 958     bool ok = false;
 959     wxString cmd;
 960
 961 #if wxUSE_MIMETYPE
 962     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
 963     if ( ft )
 964     {
 965         wxString mt;
 966         ft->GetMimeType(&mt);
 967
 968         ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
 969         delete ft;
 970     }
 971 #endif // wxUSE_MIMETYPE
 972
 973     if ( !ok || cmd.empty() )
 974     {
 975         // fallback to checking for the BROWSER environment variable
 976         if ( !wxGetEnv(wxT("BROWSER"), &cmd) || cmd.empty() )
 977             cmd << _T(' ') << url;
 978     }
 979
 980     ok = ( !cmd.empty() && wxExecute(cmd) );
 981     if (ok)
 982         return ok;
 983
 984     // no file type for HTML extension
 985     wxLogError(_("No default application configured for HTML files."));
 986
 987     return false;
 988 }
 989 #endif
 990
 991 static bool DoLaunchDefaultBrowserHelper(const wxString& urlOrig, int flags)
 992 {
 993     // NOTE: we don't have to care about the wxBROWSER_NOBUSYCURSOR flag
 994     //       as it was already handled by wxLaunchDefaultBrowser
 995
 996     wxUnusedVar(flags);
 997
 998     wxString url(urlOrig), scheme;
 999     wxURI uri(url);
1000
1001     // this check is useful to avoid that wxURI recognizes as scheme parts of
1002     // the filename, in case urlOrig is a local filename
1003     // (e.g. "C:\\test.txt" when parsed by wxURI reports a scheme == "C")
1004     bool hasValidScheme = uri.HasScheme() &&
1005             (uri.GetScheme() == "http" || uri.GetScheme() == "file");
1006
1007 #if defined(__WXMSW__)
1008
1009     // NOTE: when testing wxMSW's wxLaunchDefaultBrowser all possible forms
1010     //       of the URL/flags should be tested; e.g.:
1011     //
1012     // for (int i=0; i<2; i++)
1013     // {
1014     //   wxLaunchDefaultBrowser("C:\\test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1015     //   wxLaunchDefaultBrowser("wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1016     //   wxLaunchDefaultBrowser("file:/C%3A/test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1017     //   wxLaunchDefaultBrowser("http://wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1018     // }
1019     // (assuming you have a C:\test.txt file)
1020
1021     if ( !hasValidScheme )
1022     {
1023         if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
1024         {
1025             scheme = "file";
1026             // do not prepend the file scheme to the URL as ShellExecuteEx() doesn't like it
1027         }
1028         else
1029         {
1030             url.Prepend(wxS("http://"));
1031             scheme = "http";
1032         }
1033     }
1034     else if ( hasValidScheme )
1035     {
1036         scheme = uri.GetScheme();
1037
1038         if ( uri.GetScheme() == "file" )
1039         {
1040             // ShellExecuteEx() doesn't like the "file" scheme when opening local files;
1041             // remove it
1042             url = wxFileSystem::URLToFileName(url).GetFullPath();
1043         }
1044     }
1045
1046     if (wxDoLaunchDefaultBrowser(url, scheme, flags))
1047         return true;
1048     //else: call wxLogSysError
1049 #else
1050     if ( !hasValidScheme )
1051     {
1052         // set the scheme of url to "http" or "file" if it does not have one
1053         if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
1054             url.Prepend(wxS("file://"));
1055         else
1056             url.Prepend(wxS("http://"));
1057     }
1058
1059     if (wxDoLaunchDefaultBrowser(url, flags))
1060         return true;
1061     //else: call wxLogSysError
1062 #endif
1063
1064     wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1065                   url.c_str());
1066
1067     return false;
1068 }
1069
1070 bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1071 {
1072     // NOTE: as documented, "url" may be both a real well-formed URL
1073     //       and a local file name
1074
1075     if ( flags & wxBROWSER_NOBUSYCURSOR )
1076         return DoLaunchDefaultBrowserHelper(url, flags);
1077
1078     wxBusyCursor bc;
1079     return DoLaunchDefaultBrowserHelper(url, flags);
1080 }
1081
1082 // ----------------------------------------------------------------------------
1083 // Menu accelerators related functions
1084 // ----------------------------------------------------------------------------
1085
1086 #if WXWIN_COMPATIBILITY_2_6
1087 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
1088 {
1089 #if wxUSE_MENUS
1090     wxString s = wxMenuItem::GetLabelText(in);
1091 #else
1092     wxString str(in);
1093     wxString s = wxStripMenuCodes(str);
1094 #endif // wxUSE_MENUS
1095     if ( out )
1096     {
1097         // go smash their buffer if it's not big enough - I love char * params
1098         memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1099     }
1100     else
1101     {
1102         out = new wxChar[s.length() + 1];
1103         wxStrcpy(out, s.c_str());
1104     }
1105
1106     return out;
1107 }
1108 #endif
1109
1110 wxString wxStripMenuCodes(const wxString& in, int flags)
1111 {
1112     wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
1113
1114     wxString out;
1115
1116     size_t len = in.length();
1117     out.reserve(len);
1118
1119     for ( size_t n = 0; n < len; n++ )
1120     {
1121         wxChar ch = in[n];
1122         if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
1123         {
1124             // skip it, it is used to introduce the accel char (or to quote
1125             // itself in which case it should still be skipped): note that it
1126             // can't be the last character of the string
1127             if ( ++n == len )
1128             {
1129                 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1130             }
1131             else
1132             {
1133                 // use the next char instead
1134                 ch = in[n];
1135             }
1136         }
1137         else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
1138         {
1139             // everything after TAB is accel string, exit the loop
1140             break;
1141         }
1142
1143         out += ch;
1144     }
1145
1146     return out;
1147 }
1148
1149 // ----------------------------------------------------------------------------
1150 // Window search functions
1151 // ----------------------------------------------------------------------------
1152
1153 /*
1154  * If parent is non-NULL, look through children for a label or title
1155  * matching the specified string. If NULL, look through all top-level windows.
1156  *
1157  */
1158
1159 wxWindow *
1160 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1161 {
1162     return wxWindow::FindWindowByLabel( title, parent );
1163 }
1164
1165
1166 /*
1167  * If parent is non-NULL, look through children for a name
1168  * matching the specified string. If NULL, look through all top-level windows.
1169  *
1170  */
1171
1172 wxWindow *
1173 wxFindWindowByName (const wxString& name, wxWindow * parent)
1174 {
1175     return wxWindow::FindWindowByName( name, parent );
1176 }
1177
1178 // Returns menu item id or wxNOT_FOUND if none.
1179 int
1180 wxFindMenuItemId(wxFrame *frame,
1181                  const wxString& menuString,
1182                  const wxString& itemString)
1183 {
1184 #if wxUSE_MENUS
1185     wxMenuBar *menuBar = frame->GetMenuBar ();
1186     if ( menuBar )
1187         return menuBar->FindMenuItem (menuString, itemString);
1188 #else // !wxUSE_MENUS
1189     wxUnusedVar(frame);
1190     wxUnusedVar(menuString);
1191     wxUnusedVar(itemString);
1192 #endif // wxUSE_MENUS/!wxUSE_MENUS
1193
1194     return wxNOT_FOUND;
1195 }
1196
1197 // Try to find the deepest child that contains 'pt'.
1198 // We go backwards, to try to allow for controls that are spacially
1199 // within other controls, but are still siblings (e.g. buttons within
1200 // static boxes). Static boxes are likely to be created _before_ controls
1201 // that sit inside them.
1202 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1203 {
1204     if (!win->IsShown())
1205         return NULL;
1206
1207     // Hack for wxNotebook case: at least in wxGTK, all pages
1208     // claim to be shown, so we must only deal with the selected one.
1209 #if wxUSE_NOTEBOOK
1210     if (win->IsKindOf(CLASSINFO(wxNotebook)))
1211     {
1212       wxNotebook* nb = (wxNotebook*) win;
1213       int sel = nb->GetSelection();
1214       if (sel >= 0)
1215       {
1216         wxWindow* child = nb->GetPage(sel);
1217         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1218         if (foundWin)
1219            return foundWin;
1220       }
1221     }
1222 #endif
1223
1224     wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1225     while (node)
1226     {
1227         wxWindow* child = node->GetData();
1228         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1229         if (foundWin)
1230           return foundWin;
1231         node = node->GetPrevious();
1232     }
1233
1234     wxPoint pos = win->GetPosition();
1235     wxSize sz = win->GetSize();
1236     if ( !win->IsTopLevel() && win->GetParent() )
1237     {
1238         pos = win->GetParent()->ClientToScreen(pos);
1239     }
1240
1241     wxRect rect(pos, sz);
1242     if (rect.Contains(pt))
1243         return win;
1244
1245     return NULL;
1246 }
1247
1248 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1249 {
1250     // Go backwards through the list since windows
1251     // on top are likely to have been appended most
1252     // recently.
1253     wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1254     while (node)
1255     {
1256         wxWindow* win = node->GetData();
1257         wxWindow* found = wxFindWindowAtPoint(win, pt);
1258         if (found)
1259             return found;
1260         node = node->GetPrevious();
1261     }
1262     return NULL;
1263 }
1264
1265 // ----------------------------------------------------------------------------
1266 // GUI helpers
1267 // ----------------------------------------------------------------------------
1268
1269 /*
1270  * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1271  * since otherwise the generic code may be pulled in unnecessarily.
1272  */
1273
1274 #if wxUSE_MSGDLG
1275
1276 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1277                  wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1278 {
1279     long decorated_style = style;
1280
1281     if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1282     {
1283         decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1284     }
1285
1286     wxMessageDialog dialog(parent, message, caption, decorated_style);
1287
1288     int ans = dialog.ShowModal();
1289     switch ( ans )
1290     {
1291         case wxID_OK:
1292             return wxOK;
1293         case wxID_YES:
1294             return wxYES;
1295         case wxID_NO:
1296             return wxNO;
1297         case wxID_CANCEL:
1298             return wxCANCEL;
1299     }
1300
1301     wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1302
1303     return wxCANCEL;
1304 }
1305
1306 void wxInfoMessageBox(wxWindow* parent)
1307 {
1308     // don't translate these strings, they're for diagnostics purposes only
1309     wxString msg;
1310     msg.Printf(_T("wxWidgets Library (%s port)\n")
1311                _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
1312                _T("Runtime version of toolkit used is %d.%d.%s\n")
1313                _T("Copyright (c) 1995-2009 wxWidgets team"),
1314                wxPlatformInfo::Get().GetPortIdName().c_str(),
1315                wxMAJOR_VERSION,
1316                wxMINOR_VERSION,
1317                wxRELEASE_NUMBER,
1318 #if wxUSE_UNICODE
1319                L" (Unicode)",
1320 #else
1321                wxEmptyString,
1322 #endif
1323 #ifdef __WXDEBUG__
1324                _T(" Debug build"),
1325 #else
1326                wxEmptyString,
1327 #endif
1328                __TDATE__,
1329                __TTIME__,
1330                wxPlatformInfo::Get().GetToolkitMajorVersion(),
1331                wxPlatformInfo::Get().GetToolkitMinorVersion(),
1332 #ifdef __WXGTK__
1333                wxString::Format("\nThe compile-time GTK+ version is %d.%d.%d.",
1334                                 GTK_MAJOR_VERSION,
1335                                 GTK_MINOR_VERSION,
1336                                 GTK_MICRO_VERSION).c_str()
1337 #else
1338                wxEmptyString
1339 #endif
1340                );
1341     wxMessageBox(msg, _T("wxWidgets information"),
1342                  wxICON_INFORMATION | wxOK,
1343                  parent);
1344 }
1345
1346 #endif // wxUSE_MSGDLG
1347
1348 #if wxUSE_TEXTDLG
1349
1350 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1351                         const wxString& defaultValue, wxWindow *parent,
1352                         wxCoord x, wxCoord y, bool centre )
1353 {
1354     wxString str;
1355     long style = wxTextEntryDialogStyle;
1356
1357     if (centre)
1358         style |= wxCENTRE;
1359     else
1360         style &= ~wxCENTRE;
1361
1362     wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1363
1364     if (dialog.ShowModal() == wxID_OK)
1365     {
1366         str = dialog.GetValue();
1367     }
1368
1369     return str;
1370 }
1371
1372 wxString wxGetPasswordFromUser(const wxString& message,
1373                                const wxString& caption,
1374                                const wxString& defaultValue,
1375                                wxWindow *parent,
1376                                wxCoord x, wxCoord y, bool centre )
1377 {
1378     wxString str;
1379     long style = wxTextEntryDialogStyle;
1380
1381     if (centre)
1382         style |= wxCENTRE;
1383     else
1384         style &= ~wxCENTRE;
1385
1386     wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1387                              style, wxPoint(x, y));
1388     if ( dialog.ShowModal() == wxID_OK )
1389     {
1390         str = dialog.GetValue();
1391     }
1392
1393     return str;
1394 }
1395
1396 #endif // wxUSE_TEXTDLG
1397
1398 #if wxUSE_COLOURDLG
1399
1400 wxColour wxGetColourFromUser(wxWindow *parent,
1401                              const wxColour& colInit,
1402                              const wxString& caption,
1403                              wxColourData *ptrData)
1404 {
1405     // contains serialized representation of wxColourData used the last time
1406     // the dialog was shown: we want to reuse it the next time in order to show
1407     // the same custom colours to the user (and we can't just have static
1408     // wxColourData itself because it's a GUI object and so should be destroyed
1409     // before GUI shutdown and doing it during static cleanup is too late)
1410     static wxString s_strColourData;
1411
1412     wxColourData data;
1413     if ( !ptrData )
1414     {
1415         ptrData = &data;
1416         if ( !s_strColourData.empty() )
1417         {
1418             if ( !data.FromString(s_strColourData) )
1419             {
1420                 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1421             }
1422
1423 #ifdef __WXMSW__
1424             // we don't get back the "choose full" flag value from the native
1425             // dialog and so we can't preserve it between runs, so we decide to
1426             // always use it as it seems better than not using it (user can
1427             // just ignore the extra controls in the dialog but having to click
1428             // a button each time to show them would be very annoying
1429             data.SetChooseFull(true);
1430 #endif // __WXMSW__
1431         }
1432     }
1433
1434     if ( colInit.IsOk() )
1435     {
1436         ptrData->SetColour(colInit);
1437     }
1438
1439     wxColour colRet;
1440     wxColourDialog dialog(parent, ptrData);
1441     if (!caption.empty())
1442         dialog.SetTitle(caption);
1443     if ( dialog.ShowModal() == wxID_OK )
1444     {
1445         *ptrData = dialog.GetColourData();
1446         colRet = ptrData->GetColour();
1447         s_strColourData = ptrData->ToString();
1448     }
1449     //else: leave colRet invalid
1450
1451     return colRet;
1452 }
1453
1454 #endif // wxUSE_COLOURDLG
1455
1456 #if wxUSE_FONTDLG
1457
1458 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1459 {
1460     wxFontData data;
1461     if ( fontInit.Ok() )
1462     {
1463         data.SetInitialFont(fontInit);
1464     }
1465
1466     wxFont fontRet;
1467     wxFontDialog dialog(parent, data);
1468     if (!caption.empty())
1469         dialog.SetTitle(caption);
1470     if ( dialog.ShowModal() == wxID_OK )
1471     {
1472         fontRet = dialog.GetFontData().GetChosenFont();
1473     }
1474     //else: leave it invalid
1475
1476     return fontRet;
1477 }
1478
1479 #endif // wxUSE_FONTDLG
1480
1481 // ----------------------------------------------------------------------------
1482 // wxSafeYield and supporting functions
1483 // ----------------------------------------------------------------------------
1484
1485 void wxEnableTopLevelWindows(bool enable)
1486 {
1487     wxWindowList::compatibility_iterator node;
1488     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1489         node->GetData()->Enable(enable);
1490 }
1491
1492 wxWindowDisabler::wxWindowDisabler(bool disable)
1493 {
1494     m_disabled = disable;
1495     if ( disable )
1496         DoDisable();
1497 }
1498
1499 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1500 {
1501     m_disabled = true;
1502     DoDisable(winToSkip);
1503 }
1504
1505 void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
1506 {
1507     // remember the top level windows which were already disabled, so that we
1508     // don't reenable them later
1509     m_winDisabled = NULL;
1510
1511     wxWindowList::compatibility_iterator node;
1512     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1513     {
1514         wxWindow *winTop = node->GetData();
1515         if ( winTop == winToSkip )
1516             continue;
1517
1518         // we don't need to disable the hidden or already disabled windows
1519         if ( winTop->IsEnabled() && winTop->IsShown() )
1520         {
1521             winTop->Disable();
1522         }
1523         else
1524         {
1525             if ( !m_winDisabled )
1526             {
1527                 m_winDisabled = new wxWindowList;
1528             }
1529
1530             m_winDisabled->Append(winTop);
1531         }
1532     }
1533 }
1534
1535 wxWindowDisabler::~wxWindowDisabler()
1536 {
1537     if ( !m_disabled )
1538         return;
1539
1540     wxWindowList::compatibility_iterator node;
1541     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1542     {
1543         wxWindow *winTop = node->GetData();
1544         if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1545         {
1546             winTop->Enable();
1547         }
1548         //else: had been already disabled, don't reenable
1549     }
1550
1551     delete m_winDisabled;
1552 }
1553
1554 // Yield to other apps/messages and disable user input to all windows except
1555 // the given one
1556 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1557 {
1558     wxWindowDisabler wd(win);
1559
1560     bool rc;
1561     if (onlyIfNeeded)
1562         rc = wxYieldIfNeeded();
1563     else
1564         rc = wxYield();
1565
1566     return rc;
1567 }
1568
1569 // ----------------------------------------------------------------------------
1570 // wxApp::Yield() wrappers for backwards compatibility
1571 // ----------------------------------------------------------------------------
1572
1573 bool wxYield()
1574 {
1575     return wxTheApp && wxTheApp->Yield();
1576 }
1577
1578 bool wxYieldIfNeeded()
1579 {
1580     return wxTheApp && wxTheApp->Yield(true);
1581 }
1582
1583 #endif // wxUSE_GUI