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