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 __UNIX__
 945     // Our best best is to use xdg-open from freedesktop.org cross-desktop
 946     // compatibility suite xdg-utils
 947     // (see http://portland.freedesktop.org/wiki/) -- this is installed on
 948     // most modern distributions and may be tweaked by them to handle
 949     // distribution specifics.
 950     wxString path, xdg_open;
 951     if ( wxGetEnv("PATH", &path) &&
 952          wxFindFileInPath(&xdg_open, path, "xdg-open") )
 953     {
 954         if ( wxExecute(xdg_open + " " + document) )
 955             return true;
 956     }
 957 #endif
 958
 959    return false;
 960 }
 961
 962 // ----------------------------------------------------------------------------
 963 // Launch default browser
 964 // ----------------------------------------------------------------------------
 965
 966 #ifdef __WXCOCOA__
 967 // Private method in Objective-C++ source file.
 968 bool wxCocoaLaunchDefaultBrowser(const wxString& url, int flags);
 969 #endif
 970
 971 static bool DoLaunchDefaultBrowser(const wxString& urlOrig, int flags)
 972 {
 973     wxUnusedVar(flags);
 974
 975     // set the scheme of url to http if it does not have one
 976     // RR: This doesn't work if the url is just a local path
 977     wxString url(urlOrig);
 978     wxURI uri(url);
 979     if ( !uri.HasScheme() )
 980     {
 981         if (wxFileExists(urlOrig))
 982             url.Prepend( wxT("file://") );
 983         else
 984             url.Prepend(wxT("http://"));
 985     }
 986
 987
 988 #if defined(__WXMSW__)
 989
 990 #if wxUSE_IPC
 991     if ( flags & wxBROWSER_NEW_WINDOW )
 992     {
 993         // ShellExecuteEx() opens the URL in an existing window by default so
 994         // we can't use it if we need a new window
 995         wxRegKey key(wxRegKey::HKCR, uri.GetScheme() + _T("\\shell\\open"));
 996         if ( !key.Exists() )
 997         {
 998             // try default browser, it must be registered at least for http URLs
 999             key.SetName(wxRegKey::HKCR, _T("http\\shell\\open"));
1000         }
1001
1002         if ( key.Exists() )
1003         {
1004             wxRegKey keyDDE(key, wxT("DDEExec"));
1005             if ( keyDDE.Exists() )
1006             {
1007                 const wxString ddeTopic = wxRegKey(keyDDE, wxT("topic"));
1008
1009                 // we only know the syntax of WWW_OpenURL DDE request for IE,
1010                 // optimistically assume that all other browsers are compatible
1011                 // with it
1012                 wxString ddeCmd;
1013                 bool ok = ddeTopic == wxT("WWW_OpenURL");
1014                 if ( ok )
1015                 {
1016                     ddeCmd = keyDDE.QueryDefaultValue();
1017                     ok = !ddeCmd.empty();
1018                 }
1019
1020                 if ( ok )
1021                 {
1022                     // for WWW_OpenURL, the index of the window to open the URL
1023                     // in is -1 (meaning "current") by default, replace it with
1024                     // 0 which means "new" (see KB article 160957)
1025                     ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
1026                                         false /* only first occurence */) == 1;
1027                 }
1028
1029                 if ( ok )
1030                 {
1031                     // and also replace the parameters: the topic should
1032                     // contain a placeholder for the URL
1033                     ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
1034                 }
1035
1036                 if ( ok )
1037                 {
1038                     // try to send it the DDE request now but ignore the errors
1039                     wxLogNull noLog;
1040
1041                     const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
1042                     if ( wxExecuteDDE(ddeServer, ddeTopic, ddeCmd) )
1043                         return true;
1044
1045                     // this is not necessarily an error: maybe browser is
1046                     // simply not running, but no matter, in any case we're
1047                     // going to launch it using ShellExecuteEx() below now and
1048                     // we shouldn't try to open a new window if we open a new
1049                     // browser anyhow
1050                 }
1051             }
1052         }
1053     }
1054 #endif // wxUSE_IPC
1055
1056     WinStruct<SHELLEXECUTEINFO> sei;
1057     sei.lpFile = url.c_str();
1058     sei.lpVerb = _T("open");
1059     sei.nShow = SW_SHOWNORMAL;
1060
1061     ::ShellExecuteEx(&sei);
1062
1063     const INT_PTR nResult = (INT_PTR)sei.hInstApp;
1064
1065     // Firefox returns file not found for some reason, so make an exception
1066     // for it
1067     if ( nResult > 32 || nResult == SE_ERR_FNF )
1068     {
1069 #ifdef __WXDEBUG__
1070         // Log something if SE_ERR_FNF happens
1071         if ( nResult == SE_ERR_FNF )
1072             wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?"));
1073 #endif // __WXDEBUG__
1074         return true;
1075     }
1076 #elif defined(__WXCOCOA__)
1077     // NOTE: We need to call the real implementation from src/cocoa/utils.mm
1078     // because the code must use Objective-C features.
1079     return wxCocoaLaunchDefaultBrowser(url, flags);
1080 #elif defined(__WXMAC__) && !defined(__WXOSX_IPHONE__)
1081     wxCFRef< CFURLRef > curl( CFURLCreateWithString( kCFAllocatorDefault,
1082             wxCFStringRef( url ), NULL ) );
1083     OSStatus err = LSOpenCFURLRef( curl , NULL );
1084
1085     if (err == noErr)
1086     {
1087         return true;
1088     }
1089     else
1090     {
1091         wxLogDebug(wxT("Browser Launch error %d"), (int) err);
1092         return false;
1093     }
1094 #else
1095     // (non-Mac, non-MSW)
1096
1097 #ifdef __UNIX__
1098
1099     // Our best best is to use xdg-open from freedesktop.org cross-desktop
1100     // compatibility suite xdg-utils
1101     // (see http://portland.freedesktop.org/wiki/) -- this is installed on
1102     // most modern distributions and may be tweaked by them to handle
1103     // distribution specifics. Only if that fails, try to find the right
1104     // browser ourselves.
1105     wxString path, xdg_open;
1106     if ( wxGetEnv("PATH", &path) &&
1107          wxFindFileInPath(&xdg_open, path, "xdg-open") )
1108     {
1109         if ( wxExecute(xdg_open + " " + url) )
1110             return true;
1111     }
1112
1113     wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment();
1114
1115     // GNOME and KDE desktops have some applications which should be always installed
1116     // together with their main parts, which give us the
1117     if (desktop == wxT("GNOME"))
1118     {
1119         wxArrayString errors;
1120         wxArrayString output;
1121
1122         // gconf will tell us the path of the application to use as browser
1123         long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"),
1124                               output, errors, wxEXEC_NODISABLE );
1125         if (res >= 0 && errors.GetCount() == 0)
1126         {
1127             wxString cmd = output[0];
1128             cmd << _T(' ') << url;
1129             if (wxExecute(cmd))
1130                 return true;
1131         }
1132     }
1133     else if (desktop == wxT("KDE"))
1134     {
1135         // kfmclient directly opens the given URL
1136         if (wxExecute(wxT("kfmclient openURL ") + url))
1137             return true;
1138     }
1139 #endif
1140
1141     bool ok = false;
1142     wxString cmd;
1143
1144 #if wxUSE_MIMETYPE
1145     wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(_T("html"));
1146     if ( ft )
1147     {
1148         wxString mt;
1149         ft->GetMimeType(&mt);
1150
1151         ok = ft->GetOpenCommand(&cmd, wxFileType::MessageParameters(url));
1152         delete ft;
1153     }
1154 #endif // wxUSE_MIMETYPE
1155
1156     if ( !ok || cmd.empty() )
1157     {
1158         // fallback to checking for the BROWSER environment variable
1159         cmd = wxGetenv(wxT("BROWSER"));
1160         if ( !cmd.empty() )
1161             cmd << _T(' ') << url;
1162     }
1163
1164     ok = ( !cmd.empty() && wxExecute(cmd) );
1165     if (ok)
1166         return ok;
1167
1168     // no file type for HTML extension
1169     wxLogError(_("No default application configured for HTML files."));
1170
1171 #endif // !wxUSE_MIMETYPE && !__WXMSW__
1172
1173     wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
1174                   url.c_str());
1175
1176     return false;
1177 }
1178
1179 bool wxLaunchDefaultBrowser(const wxString& url, int flags)
1180 {
1181     if ( flags & wxBROWSER_NOBUSYCURSOR )
1182         return DoLaunchDefaultBrowser(url, flags);
1183
1184     wxBusyCursor bc;
1185     return DoLaunchDefaultBrowser(url, flags);
1186 }
1187
1188 // ----------------------------------------------------------------------------
1189 // Menu accelerators related functions
1190 // ----------------------------------------------------------------------------
1191
1192 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
1193 {
1194 #if wxUSE_MENUS
1195     wxString s = wxMenuItem::GetLabelText(in);
1196 #else
1197     wxString str(in);
1198     wxString s = wxStripMenuCodes(str);
1199 #endif // wxUSE_MENUS
1200     if ( out )
1201     {
1202         // go smash their buffer if it's not big enough - I love char * params
1203         memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
1204     }
1205     else
1206     {
1207         out = new wxChar[s.length() + 1];
1208         wxStrcpy(out, s.c_str());
1209     }
1210
1211     return out;
1212 }
1213
1214 wxString wxStripMenuCodes(const wxString& in, int flags)
1215 {
1216     wxASSERT_MSG( flags, _T("this is useless to call without any flags") );
1217
1218     wxString out;
1219
1220     size_t len = in.length();
1221     out.reserve(len);
1222
1223     for ( size_t n = 0; n < len; n++ )
1224     {
1225         wxChar ch = in[n];
1226         if ( (flags & wxStrip_Mnemonics) && ch == _T('&') )
1227         {
1228             // skip it, it is used to introduce the accel char (or to quote
1229             // itself in which case it should still be skipped): note that it
1230             // can't be the last character of the string
1231             if ( ++n == len )
1232             {
1233                 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
1234             }
1235             else
1236             {
1237                 // use the next char instead
1238                 ch = in[n];
1239             }
1240         }
1241         else if ( (flags & wxStrip_Accel) && ch == _T('\t') )
1242         {
1243             // everything after TAB is accel string, exit the loop
1244             break;
1245         }
1246
1247         out += ch;
1248     }
1249
1250     return out;
1251 }
1252
1253 // ----------------------------------------------------------------------------
1254 // Window search functions
1255 // ----------------------------------------------------------------------------
1256
1257 /*
1258  * If parent is non-NULL, look through children for a label or title
1259  * matching the specified string. If NULL, look through all top-level windows.
1260  *
1261  */
1262
1263 wxWindow *
1264 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
1265 {
1266     return wxWindow::FindWindowByLabel( title, parent );
1267 }
1268
1269
1270 /*
1271  * If parent is non-NULL, look through children for a name
1272  * matching the specified string. If NULL, look through all top-level windows.
1273  *
1274  */
1275
1276 wxWindow *
1277 wxFindWindowByName (const wxString& name, wxWindow * parent)
1278 {
1279     return wxWindow::FindWindowByName( name, parent );
1280 }
1281
1282 // Returns menu item id or wxNOT_FOUND if none.
1283 int
1284 wxFindMenuItemId(wxFrame *frame,
1285                  const wxString& menuString,
1286                  const wxString& itemString)
1287 {
1288 #if wxUSE_MENUS
1289     wxMenuBar *menuBar = frame->GetMenuBar ();
1290     if ( menuBar )
1291         return menuBar->FindMenuItem (menuString, itemString);
1292 #else // !wxUSE_MENUS
1293     wxUnusedVar(frame);
1294     wxUnusedVar(menuString);
1295     wxUnusedVar(itemString);
1296 #endif // wxUSE_MENUS/!wxUSE_MENUS
1297
1298     return wxNOT_FOUND;
1299 }
1300
1301 // Try to find the deepest child that contains 'pt'.
1302 // We go backwards, to try to allow for controls that are spacially
1303 // within other controls, but are still siblings (e.g. buttons within
1304 // static boxes). Static boxes are likely to be created _before_ controls
1305 // that sit inside them.
1306 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
1307 {
1308     if (!win->IsShown())
1309         return NULL;
1310
1311     // Hack for wxNotebook case: at least in wxGTK, all pages
1312     // claim to be shown, so we must only deal with the selected one.
1313 #if wxUSE_NOTEBOOK
1314     if (win->IsKindOf(CLASSINFO(wxNotebook)))
1315     {
1316       wxNotebook* nb = (wxNotebook*) win;
1317       int sel = nb->GetSelection();
1318       if (sel >= 0)
1319       {
1320         wxWindow* child = nb->GetPage(sel);
1321         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1322         if (foundWin)
1323            return foundWin;
1324       }
1325     }
1326 #endif
1327
1328     wxWindowList::compatibility_iterator node = win->GetChildren().GetLast();
1329     while (node)
1330     {
1331         wxWindow* child = node->GetData();
1332         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
1333         if (foundWin)
1334           return foundWin;
1335         node = node->GetPrevious();
1336     }
1337
1338     wxPoint pos = win->GetPosition();
1339     wxSize sz = win->GetSize();
1340     if ( !win->IsTopLevel() && win->GetParent() )
1341     {
1342         pos = win->GetParent()->ClientToScreen(pos);
1343     }
1344
1345     wxRect rect(pos, sz);
1346     if (rect.Contains(pt))
1347         return win;
1348
1349     return NULL;
1350 }
1351
1352 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
1353 {
1354     // Go backwards through the list since windows
1355     // on top are likely to have been appended most
1356     // recently.
1357     wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetLast();
1358     while (node)
1359     {
1360         wxWindow* win = node->GetData();
1361         wxWindow* found = wxFindWindowAtPoint(win, pt);
1362         if (found)
1363             return found;
1364         node = node->GetPrevious();
1365     }
1366     return NULL;
1367 }
1368
1369 // ----------------------------------------------------------------------------
1370 // GUI helpers
1371 // ----------------------------------------------------------------------------
1372
1373 /*
1374  * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
1375  * since otherwise the generic code may be pulled in unnecessarily.
1376  */
1377
1378 #if wxUSE_MSGDLG
1379
1380 int wxMessageBox(const wxString& message, const wxString& caption, long style,
1381                  wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
1382 {
1383     long decorated_style = style;
1384
1385     if ( ( style & ( wxICON_EXCLAMATION | wxICON_HAND | wxICON_INFORMATION | wxICON_QUESTION ) ) == 0 )
1386     {
1387         decorated_style |= ( style & wxYES ) ? wxICON_QUESTION : wxICON_INFORMATION ;
1388     }
1389
1390     wxMessageDialog dialog(parent, message, caption, decorated_style);
1391
1392     int ans = dialog.ShowModal();
1393     switch ( ans )
1394     {
1395         case wxID_OK:
1396             return wxOK;
1397         case wxID_YES:
1398             return wxYES;
1399         case wxID_NO:
1400             return wxNO;
1401         case wxID_CANCEL:
1402             return wxCANCEL;
1403     }
1404
1405     wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
1406
1407     return wxCANCEL;
1408 }
1409
1410 void wxInfoMessageBox(wxWindow* parent)
1411 {
1412     // don't translate these strings, they're for diagnostics purposes only
1413     wxString msg;
1414     msg.Printf(_T("wxWidgets Library (%s port)\n")
1415                _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
1416                _T("Runtime version of toolkit used is %d.%d.%s\n")
1417                _T("Copyright (c) 1995-2008 wxWidgets team"),
1418                wxPlatformInfo::Get().GetPortIdName().c_str(),
1419                wxMAJOR_VERSION,
1420                wxMINOR_VERSION,
1421                wxRELEASE_NUMBER,
1422 #if wxUSE_UNICODE
1423                L" (Unicode)",
1424 #else
1425                wxEmptyString,
1426 #endif
1427 #ifdef __WXDEBUG__
1428                _T(" Debug build"),
1429 #else
1430                wxEmptyString,
1431 #endif
1432                __TDATE__,
1433                __TTIME__,
1434                wxPlatformInfo::Get().GetToolkitMajorVersion(),
1435                wxPlatformInfo::Get().GetToolkitMinorVersion(),
1436 #ifdef __WXGTK__
1437                wxString::Format("\nThe compile-time GTK+ version is %d.%d.%d.",
1438                                 GTK_MAJOR_VERSION,
1439                                 GTK_MINOR_VERSION,
1440                                 GTK_MICRO_VERSION).c_str()
1441 #else
1442                wxEmptyString
1443 #endif
1444                );
1445     wxMessageBox(msg, _T("wxWidgets information"),
1446                  wxICON_INFORMATION | wxOK,
1447                  parent);
1448 }
1449
1450 #endif // wxUSE_MSGDLG
1451
1452 #if wxUSE_TEXTDLG
1453
1454 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
1455                         const wxString& defaultValue, wxWindow *parent,
1456                         wxCoord x, wxCoord y, bool centre )
1457 {
1458     wxString str;
1459     long style = wxTextEntryDialogStyle;
1460
1461     if (centre)
1462         style |= wxCENTRE;
1463     else
1464         style &= ~wxCENTRE;
1465
1466     wxTextEntryDialog dialog(parent, message, caption, defaultValue, style, wxPoint(x, y));
1467
1468     if (dialog.ShowModal() == wxID_OK)
1469     {
1470         str = dialog.GetValue();
1471     }
1472
1473     return str;
1474 }
1475
1476 wxString wxGetPasswordFromUser(const wxString& message,
1477                                const wxString& caption,
1478                                const wxString& defaultValue,
1479                                wxWindow *parent,
1480                                wxCoord x, wxCoord y, bool centre )
1481 {
1482     wxString str;
1483     long style = wxTextEntryDialogStyle;
1484
1485     if (centre)
1486         style |= wxCENTRE;
1487     else
1488         style &= ~wxCENTRE;
1489
1490     wxPasswordEntryDialog dialog(parent, message, caption, defaultValue,
1491                              style, wxPoint(x, y));
1492     if ( dialog.ShowModal() == wxID_OK )
1493     {
1494         str = dialog.GetValue();
1495     }
1496
1497     return str;
1498 }
1499
1500 #endif // wxUSE_TEXTDLG
1501
1502 #if wxUSE_COLOURDLG
1503
1504 wxColour wxGetColourFromUser(wxWindow *parent,
1505                              const wxColour& colInit,
1506                              const wxString& caption,
1507                              wxColourData *ptrData)
1508 {
1509     // contains serialized representation of wxColourData used the last time
1510     // the dialog was shown: we want to reuse it the next time in order to show
1511     // the same custom colours to the user (and we can't just have static
1512     // wxColourData itself because it's a GUI object and so should be destroyed
1513     // before GUI shutdown and doing it during static cleanup is too late)
1514     static wxString s_strColourData;
1515
1516     wxColourData data;
1517     if ( !ptrData )
1518     {
1519         ptrData = &data;
1520         if ( !s_strColourData.empty() )
1521         {
1522             if ( !data.FromString(s_strColourData) )
1523             {
1524                 wxFAIL_MSG( "bug in wxColourData::FromString()?" );
1525             }
1526
1527 #ifdef __WXMSW__
1528             // we don't get back the "choose full" flag value from the native
1529             // dialog and so we can't preserve it between runs, so we decide to
1530             // always use it as it seems better than not using it (user can
1531             // just ignore the extra controls in the dialog but having to click
1532             // a button each time to show them would be very annoying
1533             data.SetChooseFull(true);
1534 #endif // __WXMSW__
1535         }
1536     }
1537
1538     if ( colInit.IsOk() )
1539     {
1540         ptrData->SetColour(colInit);
1541     }
1542
1543     wxColour colRet;
1544     wxColourDialog dialog(parent, ptrData);
1545     if (!caption.empty())
1546         dialog.SetTitle(caption);
1547     if ( dialog.ShowModal() == wxID_OK )
1548     {
1549         *ptrData = dialog.GetColourData();
1550         colRet = ptrData->GetColour();
1551         s_strColourData = ptrData->ToString();
1552     }
1553     //else: leave colRet invalid
1554
1555     return colRet;
1556 }
1557
1558 #endif // wxUSE_COLOURDLG
1559
1560 #if wxUSE_FONTDLG
1561
1562 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit, const wxString& caption)
1563 {
1564     wxFontData data;
1565     if ( fontInit.Ok() )
1566     {
1567         data.SetInitialFont(fontInit);
1568     }
1569
1570     wxFont fontRet;
1571     wxFontDialog dialog(parent, data);
1572     if (!caption.empty())
1573         dialog.SetTitle(caption);
1574     if ( dialog.ShowModal() == wxID_OK )
1575     {
1576         fontRet = dialog.GetFontData().GetChosenFont();
1577     }
1578     //else: leave it invalid
1579
1580     return fontRet;
1581 }
1582
1583 #endif // wxUSE_FONTDLG
1584
1585 // ----------------------------------------------------------------------------
1586 // wxSafeYield and supporting functions
1587 // ----------------------------------------------------------------------------
1588
1589 void wxEnableTopLevelWindows(bool enable)
1590 {
1591     wxWindowList::compatibility_iterator node;
1592     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1593         node->GetData()->Enable(enable);
1594 }
1595
1596 wxWindowDisabler::wxWindowDisabler(bool disable)
1597 {
1598     m_disabled = disable;
1599     if ( disable )
1600         DoDisable();
1601 }
1602
1603 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
1604 {
1605     m_disabled = true;
1606     DoDisable(winToSkip);
1607 }
1608
1609 void wxWindowDisabler::DoDisable(wxWindow *winToSkip)
1610 {
1611     // remember the top level windows which were already disabled, so that we
1612     // don't reenable them later
1613     m_winDisabled = NULL;
1614
1615     wxWindowList::compatibility_iterator node;
1616     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1617     {
1618         wxWindow *winTop = node->GetData();
1619         if ( winTop == winToSkip )
1620             continue;
1621
1622         // we don't need to disable the hidden or already disabled windows
1623         if ( winTop->IsEnabled() && winTop->IsShown() )
1624         {
1625             winTop->Disable();
1626         }
1627         else
1628         {
1629             if ( !m_winDisabled )
1630             {
1631                 m_winDisabled = new wxWindowList;
1632             }
1633
1634             m_winDisabled->Append(winTop);
1635         }
1636     }
1637 }
1638
1639 wxWindowDisabler::~wxWindowDisabler()
1640 {
1641     if ( !m_disabled )
1642         return;
1643
1644     wxWindowList::compatibility_iterator node;
1645     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
1646     {
1647         wxWindow *winTop = node->GetData();
1648         if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
1649         {
1650             winTop->Enable();
1651         }
1652         //else: had been already disabled, don't reenable
1653     }
1654
1655     delete m_winDisabled;
1656 }
1657
1658 // Yield to other apps/messages and disable user input to all windows except
1659 // the given one
1660 bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
1661 {
1662     wxWindowDisabler wd(win);
1663
1664     bool rc;
1665     if (onlyIfNeeded)
1666         rc = wxYieldIfNeeded();
1667     else
1668         rc = wxYield();
1669
1670     return rc;
1671 }
1672
1673 // Don't synthesize KeyUp events holding down a key and producing KeyDown
1674 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
1675 // in utilsgtk.cpp.
1676 #ifndef __WXGTK__
1677 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
1678 {
1679     return true;    // detectable auto-repeat is the only mode MSW supports
1680 }
1681 #endif // !wxGTK
1682
1683 #endif // wxUSE_GUI