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/msw/registry.h"
 100     #include <shellapi.h> // needed for SHELLEXECUTEINFO
 101 #endif
 102
 103 #if wxUSE_GUI && defined(__WXGTK__)
 104     #include <gtk/gtk.h>    // for GTK_XXX_VERSION constants
 105 #endif
 106
 107 #if wxUSE_BASE
 108
 109 // ----------------------------------------------------------------------------
 110 // common data
 111 // ----------------------------------------------------------------------------
 112
 113 // ============================================================================
 114 // implementation
 115 // ============================================================================
 116
 117 // Array used in DecToHex conversion routine.
 118 static wxChar hexArray[] = wxT("0123456789ABCDEF");
 119
 120 // Convert 2-digit hex number to decimal
 121 int wxHexToDec(const wxString& buf)
 122 {
 123     int firstDigit, secondDigit;
 124
 125     if (buf.GetChar(0) >= wxT('A'))
 126         firstDigit = buf.GetChar(0) - wxT('A') + 10;
 127     else
 128        firstDigit = buf.GetChar(0) - wxT('0');
 129
 130     if (buf.GetChar(1) >= wxT('A'))
 131         secondDigit = buf.GetChar(1) - wxT('A') + 10;
 132     else
 133         secondDigit = buf.GetChar(1) - wxT('0');
 134
 135     return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
 136 }
 137
 138 // Convert decimal integer to 2-character hex string
 139 void wxDecToHex(int dec, wxChar *buf)
 140 {
 141     int firstDigit = (int)(dec/16.0);
 142     int secondDigit = (int)(dec - (firstDigit*16.0));
 143     buf[0] = hexArray[firstDigit];
 144     buf[1] = hexArray[secondDigit];
 145     buf[2] = 0;
 146 }
 147
 148 // Convert decimal integer to 2 characters
 149 void wxDecToHex(int dec, char* ch1, char* ch2)
 150 {
 151     int firstDigit = (int)(dec/16.0);
 152     int secondDigit = (int)(dec - (firstDigit*16.0));
 153     (*ch1) = (char) hexArray[firstDigit];
 154     (*ch2) = (char) hexArray[secondDigit];
 155 }
 156
 157 // Convert decimal integer to 2-character hex string
 158 wxString wxDecToHex(int dec)
 159 {
 160     wxChar buf[3];
 161     wxDecToHex(dec, buf);
 162     return wxString(buf);
 163 }
 164
 165 // ----------------------------------------------------------------------------
 166 // misc functions
 167 // ----------------------------------------------------------------------------
 168
 169 // Return the current date/time
 170 wxString wxNow()
 171 {
 172 #ifdef __WXWINCE__
 173 #if wxUSE_DATETIME
 174     wxDateTime now = wxDateTime::Now();
 175     return now.Format();
 176 #else
 177     return wxEmptyString;
 178 #endif
 179 #else
 180     time_t now = time((time_t *) NULL);
 181     char *date = ctime(&now);
 182     date[24] = '\0';
 183     return wxString::FromAscii(date);
 184 #endif
 185 }
 186
 187 void wxUsleep(unsigned long milliseconds)
 188 {
 189     wxMilliSleep(milliseconds);
 190 }
 191
 192 const wxChar *wxGetInstallPrefix()
 193 {
 194     wxString prefix;
 195
 196     if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
 197         return prefix.c_str();
 198
 199 #ifdef wxINSTALL_PREFIX
 200     return wxT(wxINSTALL_PREFIX);
 201 #else
 202     return wxEmptyString;
 203 #endif
 204 }
 205
 206 wxString wxGetDataDir()
 207 {
 208     wxString dir = wxGetInstallPrefix();
 209     dir <<  wxFILE_SEP_PATH << wxT("share") << wxFILE_SEP_PATH << wxT("wx");
 210     return dir;
 211 }
 212
 213 bool wxIsPlatformLittleEndian()
 214 {
 215     // Are we little or big endian? This method is from Harbison & Steele.
 216     union
 217     {
 218         long l;
 219         char c[sizeof(long)];
 220     } u;
 221     u.l = 1;
 222
 223     return u.c[0] == 1;
 224 }
 225
 226
 227 /*
 228  * Class to make it easier to specify platform-dependent values
 229  */
 230
 231 wxArrayInt*  wxPlatform::sm_customPlatforms = NULL;
 232
 233 void wxPlatform::Copy(const wxPlatform& platform)
 234 {
 235     m_longValue = platform.m_longValue;
 236     m_doubleValue = platform.m_doubleValue;
 237     m_stringValue = platform.m_stringValue;
 238 }
 239
 240 wxPlatform wxPlatform::If(int platform, long value)
 241 {
 242     if (Is(platform))
 243         return wxPlatform(value);
 244     else
 245         return wxPlatform();
 246 }
 247
 248 wxPlatform wxPlatform::IfNot(int platform, long value)
 249 {
 250     if (!Is(platform))
 251         return wxPlatform(value);
 252     else
 253         return wxPlatform();
 254 }
 255
 256 wxPlatform& wxPlatform::ElseIf(int platform, long value)
 257 {
 258     if (Is(platform))
 259         m_longValue = value;
 260     return *this;
 261 }
 262
 263 wxPlatform& wxPlatform::ElseIfNot(int platform, long value)
 264 {
 265     if (!Is(platform))
 266         m_longValue = value;
 267     return *this;
 268 }
 269
 270 wxPlatform wxPlatform::If(int platform, double value)
 271 {
 272     if (Is(platform))
 273         return wxPlatform(value);
 274     else
 275         return wxPlatform();
 276 }
 277
 278 wxPlatform wxPlatform::IfNot(int platform, double value)
 279 {
 280     if (!Is(platform))
 281         return wxPlatform(value);
 282     else
 283         return wxPlatform();
 284 }
 285
 286 wxPlatform& wxPlatform::ElseIf(int platform, double value)
 287 {
 288     if (Is(platform))
 289         m_doubleValue = value;
 290     return *this;
 291 }
 292
 293 wxPlatform& wxPlatform::ElseIfNot(int platform, double value)
 294 {
 295     if (!Is(platform))
 296         m_doubleValue = value;
 297     return *this;
 298 }
 299
 300 wxPlatform wxPlatform::If(int platform, const wxString& value)
 301 {
 302     if (Is(platform))
 303         return wxPlatform(value);
 304     else
 305         return wxPlatform();
 306 }
 307
 308 wxPlatform wxPlatform::IfNot(int platform, const wxString& value)
 309 {
 310     if (!Is(platform))
 311         return wxPlatform(value);
 312     else
 313         return wxPlatform();
 314 }
 315
 316 wxPlatform& wxPlatform::ElseIf(int platform, const wxString& value)
 317 {
 318     if (Is(platform))
 319         m_stringValue = value;
 320     return *this;
 321 }
 322
 323 wxPlatform& wxPlatform::ElseIfNot(int platform, const wxString& value)
 324 {
 325     if (!Is(platform))
 326         m_stringValue = value;
 327     return *this;
 328 }
 329
 330 wxPlatform& wxPlatform::Else(long value)
 331 {
 332     m_longValue = value;
 333     return *this;
 334 }
 335
 336 wxPlatform& wxPlatform::Else(double value)
 337 {
 338     m_doubleValue = value;
 339     return *this;
 340 }
 341
 342 wxPlatform& wxPlatform::Else(const wxString& value)
 343 {
 344     m_stringValue = value;
 345     return *this;
 346 }
 347
 348 void wxPlatform::AddPlatform(int platform)
 349 {
 350     if (!sm_customPlatforms)
 351         sm_customPlatforms = new wxArrayInt;
 352     sm_customPlatforms->Add(platform);
 353 }
 354
 355 void wxPlatform::ClearPlatforms()
 356 {
 357     delete sm_customPlatforms;
 358     sm_customPlatforms = NULL;
 359 }
 360
 361 /// Function for testing current platform
 362
 363 bool wxPlatform::Is(int platform)
 364 {
 365 #ifdef __WXMSW__
 366     if (platform == wxOS_WINDOWS)
 367         return true;
 368 #endif
 369 #ifdef __WXWINCE__
 370     if (platform == wxOS_WINDOWS_CE)
 371         return true;
 372 #endif
 373
 374 #if 0
 375
 376 // FIXME: wxWinPocketPC and wxWinSmartPhone are unknown symbols
 377
 378 #if defined(__WXWINCE__) && defined(__POCKETPC__)
 379     if (platform == wxWinPocketPC)
 380         return true;
 381 #endif
 382 #if defined(__WXWINCE__) && defined(__SMARTPHONE__)
 383     if (platform == wxWinSmartPhone)
 384         return true;
 385 #endif
 386
 387 #endif
 388
 389 #ifdef __WXGTK__
 390     if (platform == wxPORT_GTK)
 391         return true;
 392 #endif
 393 #ifdef __WXMAC__
 394     if (platform == wxPORT_MAC)
 395         return true;
 396 #endif
 397 #ifdef __WXX11__
 398     if (platform == wxPORT_X11)
 399         return true;
 400 #endif
 401 #ifdef __UNIX__
 402     if (platform == wxOS_UNIX)
 403         return true;
 404 #endif
 405 #ifdef __WXMGL__
 406     if (platform == wxPORT_MGL)
 407         return true;
 408 #endif
 409 #ifdef __OS2__
 410     if (platform == wxOS_OS2)
 411         return true;
 412 #endif
 413 #ifdef __WXPM__
 414     if (platform == wxPORT_PM)
 415         return true;
 416 #endif
 417 #ifdef __WXCOCOA__
 418     if (platform == wxPORT_MAC)
 419         return true;
 420 #endif
 421
 422     if (sm_customPlatforms && sm_customPlatforms->Index(platform) != wxNOT_FOUND)
 423         return true;
 424
 425     return false;
 426 }
 427
 428 // ----------------------------------------------------------------------------
 429 // network and user id functions
 430 // ----------------------------------------------------------------------------
 431
 432 // Get Full RFC822 style email address
 433 bool wxGetEmailAddress(wxChar *address, int maxSize)
 434 {
 435     wxString email = wxGetEmailAddress();
 436     if ( !email )
 437         return false;
 438
 439     wxStrncpy(address, email, maxSize - 1);
 440     address[maxSize - 1] = wxT('\0');
 441
 442     return true;
 443 }
 444
 445 wxString wxGetEmailAddress()
 446 {
 447     wxString email;
 448
 449     wxString host = wxGetFullHostName();
 450     if ( !host.empty() )
 451     {
 452         wxString user = wxGetUserId();
 453         if ( !user.empty() )
 454         {
 455             email << user << wxT('@') << host;
 456         }
 457     }
 458
 459     return email;
 460 }
 461
 462 wxString wxGetUserId()
 463 {
 464     static const int maxLoginLen = 256; // FIXME arbitrary number
 465
 466     wxString buf;
 467     bool ok = wxGetUserId(wxStringBuffer(buf, maxLoginLen), maxLoginLen);
 468
 469     if ( !ok )
 470         buf.Empty();
 471
 472     return buf;
 473 }
 474
 475 wxString wxGetUserName()
 476 {
 477     static const int maxUserNameLen = 1024; // FIXME arbitrary number
 478
 479     wxString buf;
 480     bool ok = wxGetUserName(wxStringBuffer(buf, maxUserNameLen), maxUserNameLen);
 481
 482     if ( !ok )
 483         buf.Empty();
 484
 485     return buf;
 486 }
 487
 488 wxString wxGetHostName()
 489 {
 490     static const size_t hostnameSize = 257;
 491
 492     wxString buf;
 493     bool ok = wxGetHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
 494
 495     if ( !ok )
 496         buf.Empty();
 497
 498     return buf;
 499 }
 500
 501 wxString wxGetFullHostName()
 502 {
 503     static const size_t hostnameSize = 257;
 504
 505     wxString buf;
 506     bool ok = wxGetFullHostName(wxStringBuffer(buf, hostnameSize), hostnameSize);
 507
 508     if ( !ok )
 509         buf.Empty();
 510
 511     return buf;
 512 }
 513
 514 wxString wxGetHomeDir()
 515 {
 516     wxString home;
 517     wxGetHomeDir(&home);
 518
 519     return home;
 520 }
 521
 522 #if 0
 523
 524 wxString wxGetCurrentDir()
 525 {
 526     wxString dir;
 527     size_t len = 1024;
 528     bool ok;
 529     do
 530     {
 531         ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
 532         dir.UngetWriteBuf();
 533
 534         if ( !ok )
 535         {
 536             if ( errno != ERANGE )
 537             {
 538                 wxLogSysError(_T("Failed to get current directory"));
 539
 540                 return wxEmptyString;
 541             }
 542             else
 543             {
 544                 // buffer was too small, retry with a larger one
 545                 len *= 2;
 546             }
 547         }
 548         //else: ok
 549     } while ( !ok );
 550
 551     return dir;
 552 }
 553
 554 #endif // 0
 555
 556 // ----------------------------------------------------------------------------
 557 // wxExecute
 558 // ----------------------------------------------------------------------------
 559
 560 // wxDoExecuteWithCapture() helper: reads an entire stream into one array
 561 //
 562 // returns true if ok, false if error
 563 #if wxUSE_STREAMS
 564 static bool ReadAll(wxInputStream *is, wxArrayString& output)
 565 {
 566     wxCHECK_MSG( is, false, _T("NULL stream in wxExecute()?") );
 567
 568     // the stream could be already at EOF or in wxSTREAM_BROKEN_PIPE state
 569     is->Reset();
 570
 571     wxTextInputStream tis(*is);
 572
 573     for ( ;; )
 574     {
 575         wxString line = tis.ReadLine();
 576
 577         // check for EOF before other errors as it's not really an error
 578         if ( is->Eof() )
 579         {
 580             // add the last, possibly incomplete, line
 581             if ( !line.empty() )
 582                 output.Add(line);
 583             break;
 584         }
 585
 586         // any other error is fatal
 587         if ( !*is )
 588             return false;
 589
 590         output.Add(line);
 591     }
 592
 593     return true;
 594 }
 595 #endif // wxUSE_STREAMS
 596
 597 // this is a private function because it hasn't a clean interface: the first
 598 // array is passed by reference, the second by pointer - instead we have 2
 599 // public versions of wxExecute() below
 600 static long wxDoExecuteWithCapture(const wxString& command,
 601                                    wxArrayString& output,
 602                                    wxArrayString* error,
 603                                    int flags)
 604 {
 605     // create a wxProcess which will capture the output
 606     wxProcess *process = new wxProcess;
 607     process->Redirect();
 608
 609     long rc = wxExecute(command, wxEXEC_SYNC | flags, process);
 610
 611 #if wxUSE_STREAMS
 612     if ( rc != -1 )
 613     {
 614         if ( !ReadAll(process->GetInputStream(), output) )
 615             rc = -1;
 616
 617         if ( error )
 618         {
 619             if ( !ReadAll(process->GetErrorStream(), *error) )
 620                 rc = -1;
 621         }
 622
 623     }
 624 #else
 625     wxUnusedVar(output);
 626     wxUnusedVar(error);
 627 #endif // wxUSE_STREAMS/!wxUSE_STREAMS
 628
 629     delete process;
 630
 631     return rc;
 632 }
 633
 634 long wxExecute(const wxString& command, wxArrayString& output, int flags)
 635 {
 636     return wxDoExecuteWithCapture(command, output, NULL, flags);
 637 }
 638
 639 long wxExecute(const wxString& command,
 640                wxArrayString& output,
 641                wxArrayString& error,
 642                int flags)
 643 {
 644     return wxDoExecuteWithCapture(command, output, &error, flags);
 645 }
 646
 647 // ----------------------------------------------------------------------------
 648 // wxApp::Yield() wrappers for backwards compatibility
 649 // ----------------------------------------------------------------------------
 650
 651 bool wxYield()
 652 {
 653     return wxTheApp && wxTheApp->Yield();
 654 }
 655
 656 bool wxYieldIfNeeded()
 657 {
 658     return wxTheApp && wxTheApp->Yield(true);
 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
 927
 928 #endif // wxUSE_BASE
 929
 930 // ============================================================================
 931 // GUI-only functions from now on
 932 // ============================================================================
 933
 934 #if wxUSE_GUI
 935
 936 // ----------------------------------------------------------------------------
 937 // Launch document with default app
 938 // ----------------------------------------------------------------------------
 939
 940 bool wxLaunchDefaultApplication(const wxString& document, int flags)
 941 {
 942     wxUnusedVar(flags);
 943
 944 #ifdef __WXMAC__
 945     static const char * const OPEN_CMD = "/usr/bin/open";
 946     if ( wxFileExists(OPEN_CMD) &&
 947             wxExecute(wxString(OPEN_CMD) + " " + document) )
 948         return true;
 949 #elif defined(__UNIX__)
 950     // Our best best is to use xdg-open from freedesktop.org cross-desktop
 951     // compatibility suite xdg-utils
 952     // (see http://portland.freedesktop.org/wiki/) -- this is installed on
 953     // most modern distributions and may be tweaked by them to handle
 954     // distribution specifics.
 955     wxString path, xdg_open;
 956     if ( wxGetEnv("PATH", &path) &&
 957          wxFindFileInPath(&xdg_open, path, "xdg-open") )
 958     {
 959         if ( wxExecute(xdg_open + " " + document) )
 960             return true;
 961     }
 962 #elif defined(__WXMSW__)
 963     const INT_PTR result = (INT_PTR)::ShellExecute
 964                                       (
 965                                         NULL,           // parent window
 966                                         _T("open"),
 967                                         document.wx_str(),
 968                                         NULL,           // parameters
 969                                         NULL,           // working directory
 970                                         SW_SHOWDEFAULT
 971                                       );
 972     if ( result > 32 )
 973         return true;
 974 #endif
 975
 976     return false;
 977 }
 978
 979 // ----------------------------------------------------------------------------
 980 // Launch default browser
 981 // ----------------------------------------------------------------------------
 982
 983 #ifdef __WXCOCOA__
 984 // Private method in Objective-C++ source file.
 985 bool wxCocoaLaunchDefaultBrowser(const wxString& url, int flags);
 986 #endif
 987
 988 static bool DoLaunchDefaultBrowser(const wxString& urlOrig, int flags)
 989 {
 990     wxUnusedVar(flags);
 991
 992     // set the scheme of url to http if it does not have one
 993     // RR: This doesn't work if the url is just a local path
 994     wxString url(urlOrig);
 995     wxURI uri(url);
 996     if ( !uri.HasScheme() )
 997     {
 998         if (wxFileExists(urlOrig))
 999             url.Prepend( wxT("file://") );
1000         else
1001             url.Prepend(wxT("http://"));
1002     }
1003
1004
1005 #if defined(__WXMSW__)
1006
1007 #if wxUSE_IPC
1008     if ( flags & wxBROWSER_NEW_WINDOW )
1009     {
1010         // ShellExecuteEx() opens the URL in an existing window by default so
1011         // we can't use it if we need a new window
1012         wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open"));
1013         if ( !key.Exists() )
1014         {
1015             // try default browser, it must be registered at least for http URLs
1016             key.SetName(wxRegKey::HKCR, _T("http\\shell\\open"));
1017         }
1018
1019         if ( key.Exists() )
1020         {
1021             wxRegKey keyDDE(key, wxT("DDEExec"));
1022             if ( keyDDE.Exists() )
1023             {
1024                 // we only know the syntax of WWW_OpenURL DDE request for IE,
1025                 // optimistically assume that all other browsers are compatible
1026                 // with it
1027                 wxRegKey keyTopic(keyDDE, wxT("topic"));
1028                 bool ok = keyTopic.Exists() && keyTopic == wxT("WWW_OpenURL");
1029                 if ( ok )
1030                 {
1031                     ddeCmd = keyDDE.QueryDefaultValue();
1032                     ok = !ddeCmd.empty();
1033                 }
1034
1035                 if ( ok )
1036                 {
1037                     // for WWW_OpenURL, the index of the window to open the URL
1038                     // in is -1 (meaning "current") by default, replace it with
1039                     // 0 which means "new" (see KB article 160957)
1040                     ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
1041                                         false /* only first occurence */) == 1;
1042                 }
1043
1044                 if ( ok )
1045                 {
1046                     // and also replace the parameters: the topic should
1047                     // contain a placeholder for the URL
1048                     ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
1049                 }
1050
1051                 if ( ok )
1052                 {
1053                     // try to send it the DDE request now but ignore the errors
1054                     wxLogNull noLog;
1055
1056                     const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
1057                     if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCmd) )
1058                         return true;
1059
1060                     // this is not necessarily an error: maybe browser is
1061                     // simply not running, but no matter, in any case we're
1062                     // going to launch it using ShellExecuteEx() below now and
1063                     // we shouldn't try to open a new window if we open a new
1064                     // browser anyhow
1065                 }
1066             }
1067         }
1068     }
1069 #endif // wxUSE_IPC
1070
1071     WinStruct<SHELLEXECUTEINFO> sei;
1072     sei.lpFile = url.c_str();
1073     sei.lpVerb = _T("open");
1074     sei.nShow = SW_SHOWNORMAL;
1075     sei.fMask = SEE_MASK_FLAG_NO_UI; // we give error message ourselves
1076
1077     ::ShellExecuteEx(&sei);
1078
1079     const INT_PTR nResult = (INT_PTR)sei.hInstApp;
1080
1081     // Firefox returns file not found for some reason, so make an exception
1082     // for it
1083     if ( nResult > 32 || nResult == SE_ERR_FNF )
1084     {
1085 #ifdef __WXDEBUG__
1086         // Log something if SE_ERR_FNF happens
1087         if ( nResult == SE_ERR_FNF )
1088             wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?"));
1089 #endif // __WXDEBUG__
1090         return true;
1091     }
1092 #elif defined(__WXCOCOA__)
1093     // NOTE: We need to call the real implementation from src/cocoa/utils.mm
1094     // because the code must use Objective-C features.
1095     return wxCocoaLaunchDefaultBrowser(url, flags);
1096 #elif defined(__WXMAC__) && !defined(__WXOSX_IPHONE__)
1097     wxCFRef< CFURLRef > curl( CFURLCreateWithString( kCFAllocatorDefault,
1098             wxCFStringRef( url ), NULL ) );
1099     OSStatus err = LSOpenCFURLRef( curl , NULL );
1100
1101     if (err == noErr)
1102     {
1103         return true;
1104     }
1105     else
1106     {
1107         wxLogDebug(wxT("Browser Launch error %d"), (int) err);
1108         return false;
1109     }
1110 #else
1111     // (non-Mac, non-MSW)
1112
1113 #ifdef __UNIX__
1114
1115     // Our best best is to use xdg-open from freedesktop.org cross-desktop
1116     // compatibility suite xdg-utils
1117     // (see http://portland.freedesktop.org/wiki/) -- this is installed on
1118     // most modern distributions and may be tweaked by them to handle
1119     // distribution specifics. Only if that fails, try to find the right
1120     // browser ourselves.
1121     wxString path, xdg_open;
1122     if ( wxGetEnv("PATH", &path) &&
1123          wxFindFileInPath(&xdg_open, path, "xdg-open") )
1124     {
1125         if ( wxExecute(xdg_open + " " + url) )
1126             return true;
1127     }
1128
1129     wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment();
1130
1131     // GNOME and KDE desktops have some applications which should be always installed
1132     // together with their main parts, which give us the
1133     if (desktop == wxT("GNOME"))
1134     {
1135         wxArrayString errors;
1136         wxArrayString output;
1137
1138         // gconf will tell us the path of the application to use as browser
1139         long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"),
1140                               output, errors, wxEXEC_NODISABLE );
1141         if (res >= 0 && errors.GetCount() == 0)
1142         {
1143             wxString cmd = output[0];
1144             cmd << _T(' ') << url;
1145             if (wxExecute(cmd))
1146                 return true;
1147         }
1148     }
1149     else if (desktop == wxT("KDE"))
1150     {
1151         // kfmclient directly opens the given URL
1152         if (wxExecute(wxT("kfmclient openURL ") + url))
1153             return true;
1154     }
1155 #endif
1156
1157     bool ok = false;
1158     wxString cmd;
1159
1160 #if wxUSE_MIMETYPE
1161     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
1162     if ( ft )
1163     {
1164         wxString mt;
1165         ft->GetMimeType(&mt);
1166
1167         ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
1168         delete ft;
1169     }
1170 #endif // wxUSE_MIMETYPE
1171
1172     if ( !ok || cmd.empty() )
1173     {
1174         // fallback to checking for the BROWSER environment variable
1175         cmd = wxGetenv(wxT("BROWSER"));
1176         if ( !cmd.empty() )
1177             cmd << _T(' ') << url;
1178     }
1179
1180     ok = ( !cmd.empty() && wxExecute(cmd) );
1181     if (ok)
1182         return ok;
1183
1184     // no file type for HTML extension
1185     wxLogError(_("No default application configured for HTML files."));
1186
1187 #endif // !wxUSE_MIMETYPE && !__WXMSW__
1188
1189     wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1190                   url.c_str());
1191
1192     return false;
1193 }
1194
1195 bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1196 {
1197     if ( flags & wxBROWSER_NOBUSYCURSOR )
1198         return DoLaunchDefaultBrowser(url, flags);
1199
1200     wxBusyCursor bc;
1201     return DoLaunchDefaultBrowser(url, flags);
1202 }
1203
1204 // ----------------------------------------------------------------------------
1205 // Menu accelerators related functions
1206 // ----------------------------------------------------------------------------
1207
1208 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
1209 {
1210 #if wxUSE_MENUS
1211     wxString s = wxMenuItem::GetLabelText(in);
1212 #else
1213     wxString str(in);
1214     wxString s = wxStripMenuCodes(str);
1215 #endif // wxUSE_MENUS
1216     if ( out )
1217     {
1218         // go smash their buffer if it's not big enough - I love char * params
1219         memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1220     }
1221     else
1222     {
1223         out = new wxChar[s.length() + 1];
1224         wxStrcpy(out, s.c_str());
1225     }
1226
1227     return out;
1228 }
1229
1230 wxString wxStripMenuCodes(const wxString& in, int flags)
1231 {
1232     wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
1233
1234     wxString out;
1235
1236     size_t len = in.length();
1237     out.reserve(len);
1238
1239     for ( size_t n = 0; n < len; n++ )
1240     {
1241         wxChar ch = in[n];
1242         if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
1243         {
1244             // skip it, it is used to introduce the accel char (or to quote
1245             // itself in which case it should still be skipped): note that it
1246             // can't be the last character of the string
1247             if ( ++n == len )
1248             {
1249                 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1250             }
1251             else
1252             {
1253                 // use the next char instead
1254                 ch = in[n];
1255             }
1256         }
1257         else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
1258         {
1259             // everything after TAB is accel string, exit the loop
1260             break;
1261         }
1262
1263         out += ch;
1264     }
1265
1266     return out;
1267 }
1268
1269 // ----------------------------------------------------------------------------
1270 // Window search functions
1271 // ----------------------------------------------------------------------------
1272
1273 /*
1274  * If parent is non-NULL, look through children for a label or title
1275  * matching the specified string. If NULL, look through all top-level windows.
1276  *
1277  */
1278
1279 wxWindow *
1280 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1281 {
1282     return wxWindow::FindWindowByLabel( title, parent );
1283 }
1284
1285
1286 /*
1287  * If parent is non-NULL, look through children for a name
1288  * matching the specified string. If NULL, look through all top-level windows.
1289  *
1290  */
1291
1292 wxWindow *
1293 wxFindWindowByName (const wxString& name, wxWindow * parent)
1294 {
1295     return wxWindow::FindWindowByName( name, parent );
1296 }
1297
1298 // Returns menu item id or wxNOT_FOUND if none.
1299 int
1300 wxFindMenuItemId(wxFrame *frame,
1301                  const wxString& menuString,
1302                  const wxString& itemString)
1303 {
1304 #if wxUSE_MENUS
1305     wxMenuBar *menuBar = frame->GetMenuBar ();
1306     if ( menuBar )
1307         return menuBar->FindMenuItem (menuString, itemString);
1308 #else // !wxUSE_MENUS
1309     wxUnusedVar(frame);
1310     wxUnusedVar(menuString);
1311     wxUnusedVar(itemString);
1312 #endif // wxUSE_MENUS/!wxUSE_MENUS
1313
1314     return wxNOT_FOUND;
1315 }
1316
1317 // Try to find the deepest child that contains 'pt'.
1318 // We go backwards, to try to allow for controls that are spacially
1319 // within other controls, but are still siblings (e.g. buttons within
1320 // static boxes). Static boxes are likely to be created _before_ controls
1321 // that sit inside them.
1322 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1323 {
1324     if (!win->IsShown())
1325         return NULL;
1326
1327     // Hack for wxNotebook case: at least in wxGTK, all pages
1328     // claim to be shown, so we must only deal with the selected one.
1329 #if wxUSE_NOTEBOOK
1330     if (win->IsKindOf(CLASSINFO(wxNotebook)))
1331     {
1332       wxNotebook* nb = (wxNotebook*) win;
1333       int sel = nb->GetSelection();
1334       if (sel >= 0)
1335       {
1336         wxWindow* child = nb->GetPage(sel);
1337         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1338         if (foundWin)
1339            return foundWin;
1340       }
1341     }
1342 #endif
1343
1344     wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1345     while (node)
1346     {
1347         wxWindow* child = node->GetData();
1348         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1349         if (foundWin)
1350           return foundWin;
1351         node = node->GetPrevious();
1352     }
1353
1354     wxPoint pos = win->GetPosition();
1355     wxSize sz = win->GetSize();
1356     if ( !win->IsTopLevel() && win->GetParent() )
1357     {
1358         pos = win->GetParent()->ClientToScreen(pos);
1359     }
1360
1361     wxRect rect(pos, sz);
1362     if (rect.Contains(pt))
1363         return win;
1364
1365     return NULL;
1366 }
1367
1368 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1369 {
1370     // Go backwards through the list since windows
1371     // on top are likely to have been appended most
1372     // recently.
1373     wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1374     while (node)
1375     {
1376         wxWindow* win = node->GetData();
1377         wxWindow* found = wxFindWindowAtPoint(win, pt);
1378         if (found)
1379             return found;
1380         node = node->GetPrevious();
1381     }
1382     return NULL;
1383 }
1384
1385 // ----------------------------------------------------------------------------
1386 // GUI helpers
1387 // ----------------------------------------------------------------------------
1388
1389 /*
1390  * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1391  * since otherwise the generic code may be pulled in unnecessarily.
1392  */
1393
1394 #if wxUSE_MSGDLG
1395
1396 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1397                  wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1398 {
1399     long decorated_style = style;
1400
1401     if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1402     {
1403         decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1404     }
1405
1406     wxMessageDialog dialog(parent, message, caption, decorated_style);
1407
1408     int ans = dialog.ShowModal();
1409     switch ( ans )
1410     {
1411         case wxID_OK:
1412             return wxOK;
1413         case wxID_YES:
1414             return wxYES;
1415         case wxID_NO:
1416             return wxNO;
1417         case wxID_CANCEL:
1418             return wxCANCEL;
1419     }
1420
1421     wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1422
1423     return wxCANCEL;
1424 }
1425
1426 void wxInfoMessageBox(wxWindow* parent)
1427 {
1428     // don't translate these strings, they're for diagnostics purposes only
1429     wxString msg;
1430     msg.Printf(_T("wxWidgets Library (%s port)\n")
1431                _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
1432                _T("Runtime version of toolkit used is %d.%d.%s\n")
1433                _T("Copyright (c) 1995-2008 wxWidgets team"),
1434                wxPlatformInfo::Get().GetPortIdName().c_str(),
1435                wxMAJOR_VERSION,
1436                wxMINOR_VERSION,
1437                wxRELEASE_NUMBER,
1438 #if wxUSE_UNICODE
1439                L" (Unicode)",
1440 #else
1441                wxEmptyString,
1442 #endif
1443 #ifdef __WXDEBUG__
1444                _T(" Debug build"),
1445 #else
1446                wxEmptyString,
1447 #endif
1448                __TDATE__,
1449                __TTIME__,
1450                wxPlatformInfo::Get().GetToolkitMajorVersion(),
1451                wxPlatformInfo::Get().GetToolkitMinorVersion(),
1452 #ifdef __WXGTK__
1453                wxString::Format("\nThe compile-time GTK+ version is %d.%d.%d.",
1454                                 GTK_MAJOR_VERSION,
1455                                 GTK_MINOR_VERSION,
1456                                 GTK_MICRO_VERSION).c_str()
1457 #else
1458                wxEmptyString
1459 #endif
1460                );
1461     wxMessageBox(msg, _T("wxWidgets information"),
1462                  wxICON_INFORMATION | wxOK,
1463                  parent);
1464 }
1465
1466 #endif // wxUSE_MSGDLG
1467
1468 #if wxUSE_TEXTDLG
1469
1470 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1471                         const wxString& defaultValue, wxWindow *parent,
1472                         wxCoord x, wxCoord y, bool centre )
1473 {
1474     wxString str;
1475     long style = wxTextEntryDialogStyle;
1476
1477     if (centre)
1478         style |= wxCENTRE;
1479     else
1480         style &= ~wxCENTRE;
1481
1482     wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1483
1484     if (dialog.ShowModal() == wxID_OK)
1485     {
1486         str = dialog.GetValue();
1487     }
1488
1489     return str;
1490 }
1491
1492 wxString wxGetPasswordFromUser(const wxString& message,
1493                                const wxString& caption,
1494                                const wxString& defaultValue,
1495                                wxWindow *parent,
1496                                wxCoord x, wxCoord y, bool centre )
1497 {
1498     wxString str;
1499     long style = wxTextEntryDialogStyle;
1500
1501     if (centre)
1502         style |= wxCENTRE;
1503     else
1504         style &= ~wxCENTRE;
1505
1506     wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1507                              style, wxPoint(x, y));
1508     if ( dialog.ShowModal() == wxID_OK )
1509     {
1510         str = dialog.GetValue();
1511     }
1512
1513     return str;
1514 }
1515
1516 #endif // wxUSE_TEXTDLG
1517
1518 #if wxUSE_COLOURDLG
1519
1520 wxColour wxGetColourFromUser(wxWindow *parent,
1521                              const wxColour& colInit,
1522                              const wxString& caption,
1523                              wxColourData *ptrData)
1524 {
1525     // contains serialized representation of wxColourData used the last time
1526     // the dialog was shown: we want to reuse it the next time in order to show
1527     // the same custom colours to the user (and we can't just have static
1528     // wxColourData itself because it's a GUI object and so should be destroyed
1529     // before GUI shutdown and doing it during static cleanup is too late)
1530     static wxString s_strColourData;
1531
1532     wxColourData data;
1533     if ( !ptrData )
1534     {
1535         ptrData = &data;
1536         if ( !s_strColourData.empty() )
1537         {
1538             if ( !data.FromString(s_strColourData) )
1539             {
1540                 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1541             }
1542
1543 #ifdef __WXMSW__
1544             // we don't get back the "choose full" flag value from the native
1545             // dialog and so we can't preserve it between runs, so we decide to
1546             // always use it as it seems better than not using it (user can
1547             // just ignore the extra controls in the dialog but having to click
1548             // a button each time to show them would be very annoying
1549             data.SetChooseFull(true);
1550 #endif // __WXMSW__
1551         }
1552     }
1553
1554     if ( colInit.IsOk() )
1555     {
1556         ptrData->SetColour(colInit);
1557     }
1558
1559     wxColour colRet;
1560     wxColourDialog dialog(parent, ptrData);
1561     if (!caption.empty())
1562         dialog.SetTitle(caption);
1563     if ( dialog.ShowModal() == wxID_OK )
1564     {
1565         *ptrData = dialog.GetColourData();
1566         colRet = ptrData->GetColour();
1567         s_strColourData = ptrData->ToString();
1568     }
1569     //else: leave colRet invalid
1570
1571     return colRet;
1572 }
1573
1574 #endif // wxUSE_COLOURDLG
1575
1576 #if wxUSE_FONTDLG
1577
1578 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1579 {
1580     wxFontData data;
1581     if ( fontInit.Ok() )
1582     {
1583         data.SetInitialFont(fontInit);
1584     }
1585
1586     wxFont fontRet;
1587     wxFontDialog dialog(parent, data);
1588     if (!caption.empty())
1589         dialog.SetTitle(caption);
1590     if ( dialog.ShowModal() == wxID_OK )
1591     {
1592         fontRet = dialog.GetFontData().GetChosenFont();
1593     }
1594     //else: leave it invalid
1595
1596     return fontRet;
1597 }
1598
1599 #endif // wxUSE_FONTDLG
1600
1601 // ----------------------------------------------------------------------------
1602 // wxSafeYield and supporting functions
1603 // ----------------------------------------------------------------------------
1604
1605 void wxEnableTopLevelWindows(bool enable)
1606 {
1607     wxWindowList::compatibility_iterator node;
1608     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1609         node->GetData()->Enable(enable);
1610 }
1611
1612 wxWindowDisabler::wxWindowDisabler(bool disable)
1613 {
1614     m_disabled = disable;
1615     if ( disable )
1616         DoDisable();
1617 }
1618
1619 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1620 {
1621     m_disabled = true;
1622     DoDisable(winToSkip);
1623 }
1624
1625 void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
1626 {
1627     // remember the top level windows which were already disabled, so that we
1628     // don't reenable them later
1629     m_winDisabled = NULL;
1630
1631     wxWindowList::compatibility_iterator node;
1632     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1633     {
1634         wxWindow *winTop = node->GetData();
1635         if ( winTop == winToSkip )
1636             continue;
1637
1638         // we don't need to disable the hidden or already disabled windows
1639         if ( winTop->IsEnabled() && winTop->IsShown() )
1640         {
1641             winTop->Disable();
1642         }
1643         else
1644         {
1645             if ( !m_winDisabled )
1646             {
1647                 m_winDisabled = new wxWindowList;
1648             }
1649
1650             m_winDisabled->Append(winTop);
1651         }
1652     }
1653 }
1654
1655 wxWindowDisabler::~wxWindowDisabler()
1656 {
1657     if ( !m_disabled )
1658         return;
1659
1660     wxWindowList::compatibility_iterator node;
1661     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1662     {
1663         wxWindow *winTop = node->GetData();
1664         if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1665         {
1666             winTop->Enable();
1667         }
1668         //else: had been already disabled, don't reenable
1669     }
1670
1671     delete m_winDisabled;
1672 }
1673
1674 // Yield to other apps/messages and disable user input to all windows except
1675 // the given one
1676 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1677 {
1678     wxWindowDisabler wd(win);
1679
1680     bool rc;
1681     if (onlyIfNeeded)
1682         rc = wxYieldIfNeeded();
1683     else
1684         rc = wxYield();
1685
1686     return rc;
1687 }
1688
1689 // Don't synthesize KeyUp events holding down a key and producing KeyDown
1690 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
1691 // in utilsgtk.cpp.
1692 #ifndef __WXGTK__
1693 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
1694 {
1695     return true;    // detectable auto-repeat is the only mode MSW supports
1696 }
1697 #endif // !wxGTK
1698
1699 #endif // wxUSE_GUI