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(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(wxT("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, wxT("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(wxT("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 << wxT(' ') << 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() && uri.GetScheme().length() > 1;
1005
1006 #if defined(__WXMSW__)
1007
1008     // NOTE: when testing wxMSW's wxLaunchDefaultBrowser all possible forms
1009     //       of the URL/flags should be tested; e.g.:
1010     //
1011     // for (int i=0; i<2; i++)
1012     // {
1013     //   // test arguments without a valid URL scheme:
1014     //   wxLaunchDefaultBrowser("C:\\test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1015     //   wxLaunchDefaultBrowser("wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1016     //
1017     //   // test arguments with different valid schemes:
1018     //   wxLaunchDefaultBrowser("file:/C%3A/test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1019     //   wxLaunchDefaultBrowser("http://wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1020     //   wxLaunchDefaultBrowser("mailto:user@host.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
1021     // }
1022     // (assuming you have a C:\test.txt file)
1023
1024     if ( !hasValidScheme )
1025     {
1026         if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
1027         {
1028             scheme = "file";
1029             // do not prepend the file scheme to the URL as ShellExecuteEx() doesn't like it
1030         }
1031         else
1032         {
1033             url.Prepend(wxS("http://"));
1034             scheme = "http";
1035         }
1036     }
1037     else if ( hasValidScheme )
1038     {
1039         scheme = uri.GetScheme();
1040
1041         if ( uri.GetScheme() == "file" )
1042         {
1043             // TODO: extract URLToFileName() to some always compiled in
1044             //       function
1045 #if wxUSE_FILESYSTEM
1046             // ShellExecuteEx() doesn't like the "file" scheme when opening local files;
1047             // remove it
1048             url = wxFileSystem::URLToFileName(url).GetFullPath();
1049 #endif // wxUSE_FILESYSTEM
1050         }
1051     }
1052
1053     if (wxDoLaunchDefaultBrowser(url, scheme, flags))
1054         return true;
1055     //else: call wxLogSysError
1056 #else
1057     if ( !hasValidScheme )
1058     {
1059         // set the scheme of url to "http" or "file" if it does not have one
1060         if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
1061             url.Prepend(wxS("file://"));
1062         else
1063             url.Prepend(wxS("http://"));
1064     }
1065
1066     if (wxDoLaunchDefaultBrowser(url, flags))
1067         return true;
1068     //else: call wxLogSysError
1069 #endif
1070
1071     wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1072                   url.c_str());
1073
1074     return false;
1075 }
1076
1077 bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1078 {
1079     // NOTE: as documented, "url" may be both a real well-formed URL
1080     //       and a local file name
1081
1082     if ( flags & wxBROWSER_NOBUSYCURSOR )
1083         return DoLaunchDefaultBrowserHelper(url, flags);
1084
1085     wxBusyCursor bc;
1086     return DoLaunchDefaultBrowserHelper(url, flags);
1087 }
1088
1089 // ----------------------------------------------------------------------------
1090 // Menu accelerators related functions
1091 // ----------------------------------------------------------------------------
1092
1093 #if WXWIN_COMPATIBILITY_2_6
1094 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
1095 {
1096 #if wxUSE_MENUS
1097     wxString s = wxMenuItem::GetLabelText(in);
1098 #else
1099     wxString str(in);
1100     wxString s = wxStripMenuCodes(str);
1101 #endif // wxUSE_MENUS
1102     if ( out )
1103     {
1104         // go smash their buffer if it's not big enough - I love char * params
1105         memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1106     }
1107     else
1108     {
1109         out = new wxChar[s.length() + 1];
1110         wxStrcpy(out, s.c_str());
1111     }
1112
1113     return out;
1114 }
1115 #endif
1116
1117 wxString wxStripMenuCodes(const wxString& in, int flags)
1118 {
1119     wxASSERT_MSG( flags, wxT("this is useless to call without any flags") );
1120
1121     wxString out;
1122
1123     size_t len = in.length();
1124     out.reserve(len);
1125
1126     for ( size_t n = 0; n < len; n++ )
1127     {
1128         wxChar ch = in[n];
1129         if ( (flags & wxStrip_Mnemonics) && ch == wxT('&') )
1130         {
1131             // skip it, it is used to introduce the accel char (or to quote
1132             // itself in which case it should still be skipped): note that it
1133             // can't be the last character of the string
1134             if ( ++n == len )
1135             {
1136                 wxLogDebug(wxT("Invalid menu string '%s'"), in.c_str());
1137             }
1138             else
1139             {
1140                 // use the next char instead
1141                 ch = in[n];
1142             }
1143         }
1144         else if ( (flags & wxStrip_Accel) && ch == wxT('\t') )
1145         {
1146             // everything after TAB is accel string, exit the loop
1147             break;
1148         }
1149
1150         out += ch;
1151     }
1152
1153     return out;
1154 }
1155
1156 // ----------------------------------------------------------------------------
1157 // Window search functions
1158 // ----------------------------------------------------------------------------
1159
1160 /*
1161  * If parent is non-NULL, look through children for a label or title
1162  * matching the specified string. If NULL, look through all top-level windows.
1163  *
1164  */
1165
1166 wxWindow *
1167 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1168 {
1169     return wxWindow::FindWindowByLabel( title, parent );
1170 }
1171
1172
1173 /*
1174  * If parent is non-NULL, look through children for a name
1175  * matching the specified string. If NULL, look through all top-level windows.
1176  *
1177  */
1178
1179 wxWindow *
1180 wxFindWindowByName (const wxString& name, wxWindow * parent)
1181 {
1182     return wxWindow::FindWindowByName( name, parent );
1183 }
1184
1185 // Returns menu item id or wxNOT_FOUND if none.
1186 int
1187 wxFindMenuItemId(wxFrame *frame,
1188                  const wxString& menuString,
1189                  const wxString& itemString)
1190 {
1191 #if wxUSE_MENUS
1192     wxMenuBar *menuBar = frame->GetMenuBar ();
1193     if ( menuBar )
1194         return menuBar->FindMenuItem (menuString, itemString);
1195 #else // !wxUSE_MENUS
1196     wxUnusedVar(frame);
1197     wxUnusedVar(menuString);
1198     wxUnusedVar(itemString);
1199 #endif // wxUSE_MENUS/!wxUSE_MENUS
1200
1201     return wxNOT_FOUND;
1202 }
1203
1204 // Try to find the deepest child that contains 'pt'.
1205 // We go backwards, to try to allow for controls that are spacially
1206 // within other controls, but are still siblings (e.g. buttons within
1207 // static boxes). Static boxes are likely to be created _before_ controls
1208 // that sit inside them.
1209 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1210 {
1211     if (!win->IsShown())
1212         return NULL;
1213
1214     // Hack for wxNotebook case: at least in wxGTK, all pages
1215     // claim to be shown, so we must only deal with the selected one.
1216 #if wxUSE_NOTEBOOK
1217     if (win->IsKindOf(CLASSINFO(wxNotebook)))
1218     {
1219       wxNotebook* nb = (wxNotebook*) win;
1220       int sel = nb->GetSelection();
1221       if (sel >= 0)
1222       {
1223         wxWindow* child = nb->GetPage(sel);
1224         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1225         if (foundWin)
1226            return foundWin;
1227       }
1228     }
1229 #endif
1230
1231     wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1232     while (node)
1233     {
1234         wxWindow* child = node->GetData();
1235         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1236         if (foundWin)
1237           return foundWin;
1238         node = node->GetPrevious();
1239     }
1240
1241     wxPoint pos = win->GetPosition();
1242     wxSize sz = win->GetSize();
1243     if ( !win->IsTopLevel() && win->GetParent() )
1244     {
1245         pos = win->GetParent()->ClientToScreen(pos);
1246     }
1247
1248     wxRect rect(pos, sz);
1249     if (rect.Contains(pt))
1250         return win;
1251
1252     return NULL;
1253 }
1254
1255 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1256 {
1257     // Go backwards through the list since windows
1258     // on top are likely to have been appended most
1259     // recently.
1260     wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1261     while (node)
1262     {
1263         wxWindow* win = node->GetData();
1264         wxWindow* found = wxFindWindowAtPoint(win, pt);
1265         if (found)
1266             return found;
1267         node = node->GetPrevious();
1268     }
1269     return NULL;
1270 }
1271
1272 // ----------------------------------------------------------------------------
1273 // GUI helpers
1274 // ----------------------------------------------------------------------------
1275
1276 /*
1277  * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1278  * since otherwise the generic code may be pulled in unnecessarily.
1279  */
1280
1281 #if wxUSE_MSGDLG
1282
1283 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1284                  wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1285 {
1286     // add the appropriate icon unless this was explicitly disabled by use of
1287     // wxICON_NONE
1288     if ( !(style & wxICON_NONE) && !(style & wxICON_MASK) )
1289     {
1290         style |= style & wxYES ? wxICON_QUESTION : wxICON_INFORMATION;
1291     }
1292
1293     wxMessageDialog dialog(parent, message, caption, style);
1294
1295     int ans = dialog.ShowModal();
1296     switch ( ans )
1297     {
1298         case wxID_OK:
1299             return wxOK;
1300         case wxID_YES:
1301             return wxYES;
1302         case wxID_NO:
1303             return wxNO;
1304         case wxID_CANCEL:
1305             return wxCANCEL;
1306     }
1307
1308     wxFAIL_MSG( wxT("unexpected return code from wxMessageDialog") );
1309
1310     return wxCANCEL;
1311 }
1312
1313 void wxInfoMessageBox(wxWindow* parent)
1314 {
1315     // don't translate these strings, they're for diagnostics purposes only
1316     wxString msg;
1317     msg.Printf(wxS("wxWidgets Library (%s port)\n")
1318                wxS("Version %d.%d.%d (Unicode: %s, debug level: %d),\n")
1319                wxS("compiled at %s %s\n\n")
1320                wxS("Runtime version of toolkit used is %d.%d.\n"),
1321                wxPlatformInfo::Get().GetPortIdName(),
1322                wxMAJOR_VERSION,
1323                wxMINOR_VERSION,
1324                wxRELEASE_NUMBER,
1325 #if wxUSE_UNICODE_UTF8
1326                "UTF-8",
1327 #elif wxUSE_UNICODE
1328                "wchar_t",
1329 #else
1330                "none",
1331 #endif
1332                wxDEBUG_LEVEL,
1333                __TDATE__,
1334                __TTIME__,
1335                wxPlatformInfo::Get().GetToolkitMajorVersion(),
1336                wxPlatformInfo::Get().GetToolkitMinorVersion()
1337               );
1338
1339 #ifdef __WXGTK__
1340     msg += wxString::Format("Compile-time GTK+ version is %d.%d.%d.\n",
1341                             GTK_MAJOR_VERSION,
1342                             GTK_MINOR_VERSION,
1343                             GTK_MICRO_VERSION);
1344 #endif // __WXGTK__
1345
1346     msg += wxS("\nCopyright (c) 1995-2009 wxWidgets team");
1347
1348     wxMessageBox(msg, wxT("wxWidgets information"),
1349                  wxICON_INFORMATION | wxOK,
1350                  parent);
1351 }
1352
1353 #endif // wxUSE_MSGDLG
1354
1355 #if wxUSE_TEXTDLG
1356
1357 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1358                         const wxString& defaultValue, wxWindow *parent,
1359                         wxCoord x, wxCoord y, bool centre )
1360 {
1361     wxString str;
1362     long style = wxTextEntryDialogStyle;
1363
1364     if (centre)
1365         style |= wxCENTRE;
1366     else
1367         style &= ~wxCENTRE;
1368
1369     wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1370
1371     if (dialog.ShowModal() == wxID_OK)
1372     {
1373         str = dialog.GetValue();
1374     }
1375
1376     return str;
1377 }
1378
1379 wxString wxGetPasswordFromUser(const wxString& message,
1380                                const wxString& caption,
1381                                const wxString& defaultValue,
1382                                wxWindow *parent,
1383                                wxCoord x, wxCoord y, bool centre )
1384 {
1385     wxString str;
1386     long style = wxTextEntryDialogStyle;
1387
1388     if (centre)
1389         style |= wxCENTRE;
1390     else
1391         style &= ~wxCENTRE;
1392
1393     wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1394                              style, wxPoint(x, y));
1395     if ( dialog.ShowModal() == wxID_OK )
1396     {
1397         str = dialog.GetValue();
1398     }
1399
1400     return str;
1401 }
1402
1403 #endif // wxUSE_TEXTDLG
1404
1405 #if wxUSE_COLOURDLG
1406
1407 wxColour wxGetColourFromUser(wxWindow *parent,
1408                              const wxColour& colInit,
1409                              const wxString& caption,
1410                              wxColourData *ptrData)
1411 {
1412     // contains serialized representation of wxColourData used the last time
1413     // the dialog was shown: we want to reuse it the next time in order to show
1414     // the same custom colours to the user (and we can't just have static
1415     // wxColourData itself because it's a GUI object and so should be destroyed
1416     // before GUI shutdown and doing it during static cleanup is too late)
1417     static wxString s_strColourData;
1418
1419     wxColourData data;
1420     if ( !ptrData )
1421     {
1422         ptrData = &data;
1423         if ( !s_strColourData.empty() )
1424         {
1425             if ( !data.FromString(s_strColourData) )
1426             {
1427                 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1428             }
1429
1430 #ifdef __WXMSW__
1431             // we don't get back the "choose full" flag value from the native
1432             // dialog and so we can't preserve it between runs, so we decide to
1433             // always use it as it seems better than not using it (user can
1434             // just ignore the extra controls in the dialog but having to click
1435             // a button each time to show them would be very annoying
1436             data.SetChooseFull(true);
1437 #endif // __WXMSW__
1438         }
1439     }
1440
1441     if ( colInit.IsOk() )
1442     {
1443         ptrData->SetColour(colInit);
1444     }
1445
1446     wxColour colRet;
1447     wxColourDialog dialog(parent, ptrData);
1448     if (!caption.empty())
1449         dialog.SetTitle(caption);
1450     if ( dialog.ShowModal() == wxID_OK )
1451     {
1452         *ptrData = dialog.GetColourData();
1453         colRet = ptrData->GetColour();
1454         s_strColourData = ptrData->ToString();
1455     }
1456     //else: leave colRet invalid
1457
1458     return colRet;
1459 }
1460
1461 #endif // wxUSE_COLOURDLG
1462
1463 #if wxUSE_FONTDLG
1464
1465 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1466 {
1467     wxFontData data;
1468     if ( fontInit.Ok() )
1469     {
1470         data.SetInitialFont(fontInit);
1471     }
1472
1473     wxFont fontRet;
1474     wxFontDialog dialog(parent, data);
1475     if (!caption.empty())
1476         dialog.SetTitle(caption);
1477     if ( dialog.ShowModal() == wxID_OK )
1478     {
1479         fontRet = dialog.GetFontData().GetChosenFont();
1480     }
1481     //else: leave it invalid
1482
1483     return fontRet;
1484 }
1485
1486 #endif // wxUSE_FONTDLG
1487
1488 // ----------------------------------------------------------------------------
1489 // wxSafeYield and supporting functions
1490 // ----------------------------------------------------------------------------
1491
1492 void wxEnableTopLevelWindows(bool enable)
1493 {
1494     wxWindowList::compatibility_iterator node;
1495     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1496         node->GetData()->Enable(enable);
1497 }
1498
1499 wxWindowDisabler::wxWindowDisabler(bool disable)
1500 {
1501     m_disabled = disable;
1502     if ( disable )
1503         DoDisable();
1504 }
1505
1506 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1507 {
1508     m_disabled = true;
1509     DoDisable(winToSkip);
1510 }
1511
1512 void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
1513 {
1514     // remember the top level windows which were already disabled, so that we
1515     // don't reenable them later
1516     m_winDisabled = NULL;
1517
1518     wxWindowList::compatibility_iterator node;
1519     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1520     {
1521         wxWindow *winTop = node->GetData();
1522         if ( winTop == winToSkip )
1523             continue;
1524
1525         // we don't need to disable the hidden or already disabled windows
1526         if ( winTop->IsEnabled() && winTop->IsShown() )
1527         {
1528             winTop->Disable();
1529         }
1530         else
1531         {
1532             if ( !m_winDisabled )
1533             {
1534                 m_winDisabled = new wxWindowList;
1535             }
1536
1537             m_winDisabled->Append(winTop);
1538         }
1539     }
1540 }
1541
1542 wxWindowDisabler::~wxWindowDisabler()
1543 {
1544     if ( !m_disabled )
1545         return;
1546
1547     wxWindowList::compatibility_iterator node;
1548     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1549     {
1550         wxWindow *winTop = node->GetData();
1551         if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1552         {
1553             winTop->Enable();
1554         }
1555         //else: had been already disabled, don't reenable
1556     }
1557
1558     delete m_winDisabled;
1559 }
1560
1561 // Yield to other apps/messages and disable user input to all windows except
1562 // the given one
1563 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1564 {
1565     wxWindowDisabler wd(win);
1566
1567     bool rc;
1568     if (onlyIfNeeded)
1569         rc = wxYieldIfNeeded();
1570     else
1571         rc = wxYield();
1572
1573     return rc;
1574 }
1575
1576 // ----------------------------------------------------------------------------
1577 // wxApp::Yield() wrappers for backwards compatibility
1578 // ----------------------------------------------------------------------------
1579
1580 bool wxYield()
1581 {
1582     return wxTheApp && wxTheApp->Yield();
1583 }
1584
1585 bool wxYieldIfNeeded()
1586 {
1587     return wxTheApp && wxTheApp->Yield(true);
1588 }
1589
1590 #endif // wxUSE_GUI