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