src/common/utilscmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "utils.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/defs.h"
  33     #include "wx/string.h"
  34     #include "wx/utils.h"
  35     #include "wx/intl.h"
  36     #include "wx/log.h"
  37
  38     #if wxUSE_GUI
  39         #include "wx/app.h"
  40         #include "wx/window.h"
  41         #include "wx/frame.h"
  42         #include "wx/menu.h"
  43         #include "wx/msgdlg.h"
  44         #include "wx/textdlg.h"
  45         #include "wx/textctrl.h"    // for wxTE_PASSWORD
  46         #if wxUSE_ACCEL
  47             #include "wx/menuitem.h"
  48             #include "wx/accel.h"
  49         #endif // wxUSE_ACCEL
  50     #endif // wxUSE_GUI
  51 #endif // WX_PRECOMP
  52
  53 #ifndef __WIN16__
  54 #include "wx/process.h"
  55 #include "wx/txtstrm.h"
  56 #endif
  57
  58 #include <ctype.h>
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62
  63 #if !defined(__WATCOMC__)
  64     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
  65         #include <errno.h>
  66     #endif
  67 #endif
  68
  69 #if wxUSE_GUI
  70     #include "wx/colordlg.h"
  71     #include "wx/fontdlg.h"
  72     #include "wx/notebook.h"
  73     #include "wx/frame.h"
  74     #include "wx/statusbr.h"
  75 #endif // wxUSE_GUI
  76
  77 #include <time.h>
  78
  79 #ifndef __MWERKS__
  80     #include <sys/types.h>
  81     #include <sys/stat.h>
  82 #endif
  83
  84 #ifdef __SALFORDC__
  85     #include <clib.h>
  86 #endif
  87
  88 #ifdef __WXMSW__
  89     #include "wx/msw/private.h"
  90 #endif
  91
  92 // ----------------------------------------------------------------------------
  93 // common data
  94 // ----------------------------------------------------------------------------
  95
  96 #if WXWIN_COMPATIBILITY_2_2
  97     const wxChar *wxInternalErrorStr = wxT("wxWindows Internal Error");
  98     const wxChar *wxFatalErrorStr = wxT("wxWindows Fatal Error");
  99 #endif // WXWIN_COMPATIBILITY_2_2
 100
 101 // ----------------------------------------------------------------------------
 102 // function protoypes
 103 // ----------------------------------------------------------------------------
 104
 105 // ============================================================================
 106 // implementation
 107 // ============================================================================
 108
 109 // ----------------------------------------------------------------------------
 110 // string functions
 111 // ----------------------------------------------------------------------------
 112
 113 #if defined(__WXMAC__) && !defined(__DARWIN__)
 114 int strcasecmp(const char *str_1, const char *str_2)
 115 {
 116   register char c1, c2;
 117   do {
 118     c1 = tolower(*str_1++);
 119     c2 = tolower(*str_2++);
 120   } while ( c1 && (c1 == c2) );
 121
 122   return c1 - c2;
 123 }
 124
 125 int strncasecmp(const char *str_1, const char *str_2, size_t maxchar)
 126 {
 127
 128   register char c1, c2;
 129   while( maxchar--)
 130   {
 131     c1 = tolower(*str_1++);
 132     c2 = tolower(*str_2++);
 133
 134     if ( !c1 || c1!=c2 )
 135                   return c1 - c2;
 136
 137   } ;
 138
 139   return 0 ;
 140
 141 }
 142 #endif // __WXMAC__ && !__DARWIN__
 143
 144 #if defined( __VMS__ ) && ( __VMS_VER < 70000000 )
 145 // we have no strI functions under VMS, therefore I have implemented
 146 // an inefficient but portable version: convert copies of strings to lowercase
 147 // and then use the normal comparison
 148 static void myLowerString(char *s)
 149 {
 150   while(*s){
 151     if(isalpha(*s)) *s = (char)tolower(*s);
 152     s++;
 153   }
 154 }
 155
 156 int strcasecmp(const char *str_1, const char *str_2)
 157 {
 158   char *temp1 = new char[strlen(str_1)+1];
 159   char *temp2 = new char[strlen(str_2)+1];
 160   strcpy(temp1,str_1);
 161   strcpy(temp2,str_2);
 162   myLowerString(temp1);
 163   myLowerString(temp2);
 164
 165   int result = wxStrcmp(temp1,temp2);
 166   delete[] temp1;
 167   delete[] temp2;
 168
 169   return(result);
 170 }
 171
 172 int strncasecmp(const char *str_1, const char *str_2, size_t maxchar)
 173 {
 174   char *temp1 = new char[strlen(str_1)+1];
 175   char *temp2 = new char[strlen(str_2)+1];
 176   strcpy(temp1,str_1);
 177   strcpy(temp2,str_2);
 178   myLowerString(temp1);
 179   myLowerString(temp2);
 180
 181   int result = strncmp(temp1,temp2,maxchar);
 182   delete[] temp1;
 183   delete[] temp2;
 184
 185   return(result);
 186 }
 187 #endif // __VMS__
 188
 189 #if defined(__WINDOWS__) && !defined(__WXMICROWIN__)
 190
 191 #ifndef __GNUWIN32__
 192 #ifndef __MWERKS__
 193 #define strcasecmp stricmp
 194 #define strncasecmp strnicmp
 195 #else
 196 #define strcasecmp _stricmp
 197 #define strncasecmp _strnicmp
 198 #endif
 199 #endif
 200
 201 #else
 202
 203 #ifdef __EMX__
 204 #define strcasecmp stricmp
 205 #define strncasecmp strnicmp
 206 #endif
 207
 208 // This declaration is missing in SunOS!
 209 // (Yes, I know it is NOT ANSI-C but its in BSD libc)
 210 #if defined(__xlC) || defined(__AIX__) || defined(__GNUG__)
 211 extern "C"
 212 {
 213   int strcasecmp (const char *, const char *);
 214   int strncasecmp (const char *, const char *, size_t);
 215 }
 216 #endif
 217 #endif  /* __WXMSW__ */
 218
 219 #ifdef __WXPM__
 220 #define strcasecmp stricmp
 221 #define strncasecmp strnicmp
 222 #endif
 223
 224 #ifdef __WATCOMC__
 225 #define strcasecmp stricmp
 226 #define strncasecmp strnicmp
 227 #endif
 228
 229 wxChar *
 230 copystring (const wxChar *s)
 231 {
 232   if (s == NULL) s = wxT("");
 233   size_t len = wxStrlen (s) + 1;
 234
 235   wxChar *news = new wxChar[len];
 236   memcpy (news, s, len * sizeof(wxChar));    // Should be the fastest
 237
 238   return news;
 239 }
 240
 241 // Id generation
 242 static long wxCurrentId = 100;
 243
 244 long
 245 wxNewId (void)
 246 {
 247   return wxCurrentId++;
 248 }
 249
 250 long
 251 wxGetCurrentId(void) { return wxCurrentId; }
 252
 253 void
 254 wxRegisterId (long id)
 255 {
 256   if (id >= wxCurrentId)
 257     wxCurrentId = id + 1;
 258 }
 259
 260 void
 261 StringToFloat (const wxChar *s, float *number)
 262 {
 263   if (s && *s && number)
 264     *number = (float) wxStrtod (s, (wxChar **) NULL);
 265 }
 266
 267 void
 268 StringToDouble (const wxChar *s, double *number)
 269 {
 270   if (s && *s && number)
 271     *number = wxStrtod (s, (wxChar **) NULL);
 272 }
 273
 274 wxChar *
 275 FloatToString (float number, const wxChar *fmt)
 276 {
 277   static wxChar buf[256];
 278
 279   wxSprintf (buf, fmt, number);
 280   return buf;
 281 }
 282
 283 wxChar *
 284 DoubleToString (double number, const wxChar *fmt)
 285 {
 286   static wxChar buf[256];
 287
 288   wxSprintf (buf, fmt, number);
 289   return buf;
 290 }
 291
 292 void
 293 StringToInt (const wxChar *s, int *number)
 294 {
 295   if (s && *s && number)
 296     *number = (int) wxStrtol (s, (wxChar **) NULL, 10);
 297 }
 298
 299 void
 300 StringToLong (const wxChar *s, long *number)
 301 {
 302   if (s && *s && number)
 303     *number = wxStrtol (s, (wxChar **) NULL, 10);
 304 }
 305
 306 wxChar *
 307 IntToString (int number)
 308 {
 309   static wxChar buf[20];
 310
 311   wxSprintf (buf, wxT("%d"), number);
 312   return buf;
 313 }
 314
 315 wxChar *
 316 LongToString (long number)
 317 {
 318   static wxChar buf[20];
 319
 320   wxSprintf (buf, wxT("%ld"), number);
 321   return buf;
 322 }
 323
 324 // Array used in DecToHex conversion routine.
 325 static wxChar hexArray[] = wxT("0123456789ABCDEF");
 326
 327 // Convert 2-digit hex number to decimal
 328 int wxHexToDec(const wxString& buf)
 329 {
 330   int firstDigit, secondDigit;
 331
 332   if (buf.GetChar(0) >= wxT('A'))
 333     firstDigit = buf.GetChar(0) - wxT('A') + 10;
 334   else
 335     firstDigit = buf.GetChar(0) - wxT('0');
 336
 337   if (buf.GetChar(1) >= wxT('A'))
 338     secondDigit = buf.GetChar(1) - wxT('A') + 10;
 339   else
 340     secondDigit = buf.GetChar(1) - wxT('0');
 341
 342   return (firstDigit & 0xF) * 16 + (secondDigit & 0xF );
 343 }
 344
 345 // Convert decimal integer to 2-character hex string
 346 void wxDecToHex(int dec, wxChar *buf)
 347 {
 348   int firstDigit = (int)(dec/16.0);
 349   int secondDigit = (int)(dec - (firstDigit*16.0));
 350   buf[0] = hexArray[firstDigit];
 351   buf[1] = hexArray[secondDigit];
 352   buf[2] = 0;
 353 }
 354
 355 // Convert decimal integer to 2-character hex string
 356 wxString wxDecToHex(int dec)
 357 {
 358     wxChar buf[3];
 359     wxDecToHex(dec, buf);
 360     return wxString(buf);
 361 }
 362
 363 // Match a string INDEPENDENT OF CASE
 364 bool
 365 StringMatch (const char *str1, const char *str2, bool subString, bool exact)
 366 {
 367   if (str1 == NULL || str2 == NULL)
 368     return FALSE;
 369   if (str1 == str2)
 370     return TRUE;
 371
 372   if (subString)
 373     {
 374       int len1 = strlen (str1);
 375       int len2 = strlen (str2);
 376       int i;
 377
 378       // Search for str1 in str2
 379       // Slow .... but acceptable for short strings
 380       for (i = 0; i <= len2 - len1; i++)
 381         {
 382           if (strncasecmp (str1, str2 + i, len1) == 0)
 383             return TRUE;
 384         }
 385     }
 386   else if (exact)
 387     {
 388       if (strcasecmp (str1, str2) == 0)
 389         return TRUE;
 390     }
 391   else
 392     {
 393       int len1 = strlen (str1);
 394       int len2 = strlen (str2);
 395
 396       if (strncasecmp (str1, str2, wxMin (len1, len2)) == 0)
 397         return TRUE;
 398     }
 399
 400   return FALSE;
 401 }
 402
 403 // Return the current date/time
 404 // [volatile]
 405 wxString wxNow()
 406 {
 407   time_t now = time((time_t *) NULL);
 408   char *date = ctime(&now);
 409   date[24] = '\0';
 410   return wxString(date);
 411 }
 412
 413 #if wxUSE_GUI
 414
 415 #if wxUSE_MENUS
 416
 417 // ----------------------------------------------------------------------------
 418 // Menu accelerators related functions
 419 // ----------------------------------------------------------------------------
 420
 421 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
 422 {
 423     wxString s = wxMenuItem::GetLabelFromText(in);
 424     if ( out )
 425     {
 426         // go smash their buffer if it's not big enough - I love char * params
 427         memcpy(out, s.c_str(), s.length() * sizeof(wxChar));
 428     }
 429     else
 430     {
 431         out = copystring(s);
 432     }
 433
 434     return out;
 435 }
 436
 437 wxString wxStripMenuCodes(const wxString& in)
 438 {
 439     wxString out;
 440
 441     size_t len = in.length();
 442     out.reserve(len);
 443
 444     for ( size_t n = 0; n < len; n++ )
 445     {
 446         wxChar ch = in[n];
 447         if ( ch == _T('&') )
 448         {
 449             // skip it, it is used to introduce the accel char (or to quote
 450             // itself in which case it should still be skipped): note that it
 451             // can't be the last character of the string
 452             if ( ++n == len )
 453             {
 454                 wxLogDebug(_T("Invalid menu string '%s'"), in.c_str());
 455             }
 456             else
 457             {
 458                 // use the next char instead
 459                 ch = in[n];
 460             }
 461         }
 462         else if ( ch == _T('\t') )
 463         {
 464             // everything after TAB is accel string, exit the loop
 465             break;
 466         }
 467
 468         out += ch;
 469     }
 470
 471     return out;
 472 }
 473
 474 #endif // wxUSE_MENUS
 475
 476 // ----------------------------------------------------------------------------
 477 // Window search functions
 478 // ----------------------------------------------------------------------------
 479
 480 /*
 481  * If parent is non-NULL, look through children for a label or title
 482  * matching the specified string. If NULL, look through all top-level windows.
 483  *
 484  */
 485
 486 wxWindow *
 487 wxFindWindowByLabel (const wxString& title, wxWindow * parent)
 488 {
 489     return wxWindow::FindWindowByLabel( title, parent );
 490 }
 491
 492
 493 /*
 494  * If parent is non-NULL, look through children for a name
 495  * matching the specified string. If NULL, look through all top-level windows.
 496  *
 497  */
 498
 499 wxWindow *
 500 wxFindWindowByName (const wxString& name, wxWindow * parent)
 501 {
 502     return wxWindow::FindWindowByName( name, parent );
 503 }
 504
 505 // Returns menu item id or -1 if none.
 506 int
 507 wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
 508 {
 509 #if wxUSE_MENUS
 510   wxMenuBar *menuBar = frame->GetMenuBar ();
 511   if ( menuBar )
 512       return menuBar->FindMenuItem (menuString, itemString);
 513 #endif // wxUSE_MENUS
 514
 515   return -1;
 516 }
 517
 518 // Try to find the deepest child that contains 'pt'.
 519 // We go backwards, to try to allow for controls that are spacially
 520 // within other controls, but are still siblings (e.g. buttons within
 521 // static boxes). Static boxes are likely to be created _before_ controls
 522 // that sit inside them.
 523 wxWindow* wxFindWindowAtPoint(wxWindow* win, const wxPoint& pt)
 524 {
 525     if (!win->IsShown())
 526         return NULL;
 527
 528     // Hack for wxNotebook case: at least in wxGTK, all pages
 529     // claim to be shown, so we must only deal with the selected one.
 530 #if wxUSE_NOTEBOOK
 531     if (win->IsKindOf(CLASSINFO(wxNotebook)))
 532     {
 533       wxNotebook* nb = (wxNotebook*) win;
 534       int sel = nb->GetSelection();
 535       if (sel >= 0)
 536       {
 537         wxWindow* child = nb->GetPage(sel);
 538         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
 539         if (foundWin)
 540            return foundWin;
 541       }
 542     }
 543 #endif
 544
 545     /* Doesn't work
 546     // Frame case
 547     else if (win->IsKindOf(CLASSINFO(wxFrame)))
 548     {
 549       // Pseudo-children that may not be mentioned in the child list
 550       wxWindowList extraChildren;
 551       wxFrame* frame = (wxFrame*) win;
 552       if (frame->GetStatusBar())
 553         extraChildren.Append(frame->GetStatusBar());
 554       if (frame->GetToolBar())
 555         extraChildren.Append(frame->GetToolBar());
 556
 557       wxNode* node = extraChildren.First();
 558       while (node)
 559       {
 560           wxWindow* child = (wxWindow*) node->Data();
 561           wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
 562           if (foundWin)
 563             return foundWin;
 564           node = node->Next();
 565       }
 566     }
 567     */
 568
 569     wxNode* node = win->GetChildren().Last();
 570     while (node)
 571     {
 572         wxWindow* child = (wxWindow*) node->Data();
 573         wxWindow* foundWin = wxFindWindowAtPoint(child, pt);
 574         if (foundWin)
 575           return foundWin;
 576         node = node->Previous();
 577     }
 578
 579     wxPoint pos = win->GetPosition();
 580     wxSize sz = win->GetSize();
 581     if (win->GetParent())
 582     {
 583         pos = win->GetParent()->ClientToScreen(pos);
 584     }
 585
 586     wxRect rect(pos, sz);
 587     if (rect.Inside(pt))
 588         return win;
 589     else
 590         return NULL;
 591 }
 592
 593 wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt)
 594 {
 595     // Go backwards through the list since windows
 596     // on top are likely to have been appended most
 597     // recently.
 598     wxNode* node = wxTopLevelWindows.Last();
 599     while (node)
 600     {
 601         wxWindow* win = (wxWindow*) node->Data();
 602         wxWindow* found = wxFindWindowAtPoint(win, pt);
 603         if (found)
 604             return found;
 605         node = node->Previous();
 606     }
 607     return NULL;
 608 }
 609
 610 #endif // wxUSE_GUI
 611
 612 /*
 613 On Fri, 21 Jul 1995, Paul Craven wrote:
 614
 615 > Is there a way to find the path of running program's executable? I can get
 616 > my home directory, and the current directory, but I don't know how to get the
 617 > executable directory.
 618 >
 619
 620 The code below (warty as it is), does what you want on most Unix,
 621 DOS, and Mac platforms (it's from the ALS Prolog main).
 622
 623 || Ken Bowen      Applied Logic Systems, Inc.         PO Box 180,
 624 ||====            Voice:  +1 (617)965-9191            Newton Centre,
 625 ||                FAX:    +1 (617)965-1636            MA  02159  USA
 626                   Email:  ken@als.com        WWW: http://www.als.com
 627 ------------------------------------------------------------------------
 628 */
 629
 630 // This code is commented out but it may be integrated with wxWin at
 631 // a later date, after testing. Thanks Ken!
 632 #if 0
 633
 634 /*--------------------------------------------------------------------*
 635  | whereami is given a filename f in the form:  whereami(argv[0])
 636  | It returns the directory in which the executable file (containing
 637  | this code [main.c] ) may be found.  A dot will be returned to indicate
 638  | the current directory.
 639  *--------------------------------------------------------------------*/
 640
 641 static void
 642 whereami(name)
 643     char *name;
 644 {
 645     register char *cutoff = NULL;        /* stifle -Wall */
 646     register char *s;
 647     register char *t;
 648     int   cc;
 649     char  ebuf[4096];
 650
 651     /*
 652      * See if the file is accessible either through the current directory
 653      * or through an absolute path.
 654      */
 655
 656     if (access(name, R_OK) == 0) {
 657
 658         /*-------------------------------------------------------------*
 659          * The file was accessible without any other work.  But the current
 660          * working directory might change on us, so if it was accessible
 661          * through the cwd, then we should get it for later accesses.
 662          *-------------------------------------------------------------*/
 663
 664         t = imagedir;
 665         if (!absolute_pathname(name)) {
 666 #if defined(__DOS__) || defined(__WIN32__)
 667             int   drive;
 668             char *newrbuf;
 669
 670             newrbuf = imagedir;
 671 #ifndef __DJGPP__
 672             if (*(name + 1) == ':') {
 673                 if (*name >= 'a' && *name <= 'z')
 674                     drive = (int) (*name - 'a' + 1);
 675                 else
 676                     drive = (int) (*name - 'A' + 1);
 677                 *newrbuf++ = *name;
 678                 *newrbuf++ = *(name + 1);
 679                 *newrbuf++ = DIR_SEPARATOR;
 680             }
 681             else {
 682                 drive = 0;
 683                 *newrbuf++ = DIR_SEPARATOR;
 684             }
 685             if (getcwd(newrbuf, drive) == 0) {        /* } */
 686 #else
 687             if (getcwd(newrbuf, 1024) == 0) {        /* } */
 688 #endif
 689 #else  /* DOS */
 690 #ifdef HAVE_GETWD
 691             if (getwd(imagedir) == 0) {                /* } */
 692 #else  /* !HAVE_GETWD */
 693             if (getcwd(imagedir, 1024) == 0) {
 694 #endif /* !HAVE_GETWD */
 695 #endif /* DOS */
 696                 fatal_error(FE_GETCWD, 0);
 697             }
 698             for (; *t; t++)        /* Set t to end of buffer */
 699                 ;
 700             if (*(t - 1) == DIR_SEPARATOR)        /* leave slash if already
 701                                                  * last char
 702                                                  */
 703                 cutoff = t - 1;
 704             else {
 705                 cutoff = t;        /* otherwise put one in */
 706                 *t++ = DIR_SEPARATOR;
 707             }
 708         }
 709 #if (!defined(__MAC__) && !defined(__DJGPP__) && !defined(__GO32__) && !defined(__WIN32__))
 710         else
 711                 (*t++ = DIR_SEPARATOR);
 712 #endif
 713
 714         /*-------------------------------------------------------------*
 715          * Copy the rest of the string and set the cutoff if it was not
 716          * already set.  If the first character of name is a slash, cutoff
 717          * is not presently set but will be on the first iteration of the
 718          * loop below.
 719          *-------------------------------------------------------------*/
 720
 721         for ((*name == DIR_SEPARATOR ? (s = name+1) : (s = name));;) {
 722             if (*s == DIR_SEPARATOR)
 723                         cutoff = t;
 724             if (!(*t++ = *s++))
 725                         break;
 726         }
 727
 728     }
 729     else {
 730
 731         /*-------------------------------------------------------------*
 732          * Get the path list from the environment.  If the path list is
 733          * inaccessible for any reason, leave with fatal error.
 734          *-------------------------------------------------------------*/
 735
 736 #ifdef __MAC__
 737         if ((s = getenv("Commands")) == (char *) 0)
 738 #else
 739         if ((s = getenv("PATH")) == (char *) 0)
 740 #endif
 741             fatal_error(FE_PATH, 0);
 742
 743         /*
 744          * Copy path list into ebuf and set the source pointer to the
 745          * beginning of this buffer.
 746          */
 747
 748         strcpy(ebuf, s);
 749         s = ebuf;
 750
 751         for (;;) {
 752             t = imagedir;
 753             while (*s && *s != PATH_SEPARATOR)
 754                 *t++ = *s++;
 755             if (t > imagedir && *(t - 1) == DIR_SEPARATOR)
 756                 ;                /* do nothing -- slash already is in place */
 757             else
 758                 *t++ = DIR_SEPARATOR;        /* put in the slash */
 759             cutoff = t - 1;        /* set cutoff */
 760             strcpy(t, name);
 761             if (access(imagedir, R_OK) == 0)
 762                 break;
 763
 764             if (*s)
 765                 s++;                /* advance source pointer */
 766             else
 767                 fatal_error(FE_INFND, 0);
 768         }
 769
 770     }
 771
 772     /*-------------------------------------------------------------*
 773      | At this point the full pathname should exist in imagedir and
 774      | cutoff should be set to the final slash.  We must now determine
 775      | whether the file name is a symbolic link or not and chase it down
 776      | if it is.  Note that we reuse ebuf for getting the link.
 777      *-------------------------------------------------------------*/
 778
 779 #ifdef HAVE_SYMLINK
 780     while ((cc = readlink(imagedir, ebuf, 512)) != -1) {
 781         ebuf[cc] = 0;
 782         s = ebuf;
 783         if (*s == DIR_SEPARATOR) {
 784             t = imagedir;
 785         }
 786         else {
 787             t = cutoff + 1;
 788         }
 789         for (;;) {
 790             if (*s == DIR_SEPARATOR)
 791                 cutoff = t;        /* mark the last slash seen */
 792             if (!(*t++ = *s++))        /* copy the character */
 793                 break;
 794         }
 795     }
 796
 797 #endif /* HAVE_SYMLINK */
 798
 799     strcpy(imagename, cutoff + 1);        /* keep the image name */
 800     *(cutoff + 1) = 0;                /* chop off the filename part */
 801 }
 802
 803 #endif
 804
 805 #if wxUSE_GUI
 806
 807 // ----------------------------------------------------------------------------
 808 // GUI helpers
 809 // ----------------------------------------------------------------------------
 810
 811 /*
 812  * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
 813  * since otherwise the generic code may be pulled in unnecessarily.
 814  */
 815
 816 #if wxUSE_MSGDLG
 817
 818 int wxMessageBox(const wxString& message, const wxString& caption, long style,
 819                  wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
 820 {
 821     wxMessageDialog dialog(parent, message, caption, style);
 822
 823     int ans = dialog.ShowModal();
 824     switch ( ans )
 825     {
 826         case wxID_OK:
 827             return wxOK;
 828         case wxID_YES:
 829             return wxYES;
 830         case wxID_NO:
 831             return wxNO;
 832         case wxID_CANCEL:
 833             return wxCANCEL;
 834     }
 835
 836     wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
 837
 838     return wxCANCEL;
 839 }
 840
 841 #endif // wxUSE_MSGDLG
 842
 843 #if wxUSE_TEXTDLG
 844
 845 wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
 846                         const wxString& defaultValue, wxWindow *parent,
 847                         int x, int y, bool WXUNUSED(centre) )
 848 {
 849     wxString str;
 850     wxTextEntryDialog dialog(parent, message, caption, defaultValue, wxOK|wxCANCEL, wxPoint(x, y));
 851     if (dialog.ShowModal() == wxID_OK)
 852     {
 853         str = dialog.GetValue();
 854     }
 855
 856     return str;
 857 }
 858
 859 wxString wxGetPasswordFromUser(const wxString& message,
 860                                const wxString& caption,
 861                                const wxString& defaultValue,
 862                                wxWindow *parent)
 863 {
 864     wxString str;
 865     wxTextEntryDialog dialog(parent, message, caption, defaultValue,
 866                              wxOK | wxCANCEL | wxTE_PASSWORD);
 867     if ( dialog.ShowModal() == wxID_OK )
 868     {
 869         str = dialog.GetValue();
 870     }
 871
 872     return str;
 873 }
 874
 875 #endif // wxUSE_TEXTDLG
 876
 877 #if wxUSE_COLOURDLG
 878
 879 wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit)
 880 {
 881     wxColourData data;
 882     data.SetChooseFull(TRUE);
 883     if ( colInit.Ok() )
 884     {
 885         data.SetColour((wxColour &)colInit); // const_cast
 886     }
 887
 888     wxColour colRet;
 889     wxColourDialog dialog(parent, &data);
 890     if ( dialog.ShowModal() == wxID_OK )
 891     {
 892         colRet = dialog.GetColourData().GetColour();
 893     }
 894     //else: leave it invalid
 895
 896     return colRet;
 897 }
 898
 899 #endif // wxUSE_COLOURDLG
 900
 901 #if wxUSE_FONTDLG
 902
 903 wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit)
 904 {
 905     wxFontData data;
 906     if ( fontInit.Ok() )
 907     {
 908         data.SetInitialFont(fontInit);
 909     }
 910
 911     wxFont fontRet;
 912     wxFontDialog dialog(parent, data);
 913     if ( dialog.ShowModal() == wxID_OK )
 914     {
 915         fontRet = dialog.GetFontData().GetChosenFont();
 916     }
 917     //else: leave it invalid
 918
 919     return fontRet;
 920 }
 921
 922 #endif // wxUSE_FONTDLG
 923 // ----------------------------------------------------------------------------
 924 // missing C RTL functions (FIXME shouldn't be here at all)
 925 // ----------------------------------------------------------------------------
 926
 927 #ifdef __MWERKS__
 928 #if __MSL__ < 0x7000
 929 char *strdup(const char *s)
 930 {
 931         return strcpy( (char*) malloc( strlen( s ) + 1 ) , s ) ;
 932 }
 933 #endif
 934 int isascii( int c )
 935 {
 936         return ( c >= 0 && c < 128 ) ;
 937 }
 938 #endif // __MWERKS__
 939
 940 // ----------------------------------------------------------------------------
 941 // wxSafeYield and supporting functions
 942 // ----------------------------------------------------------------------------
 943
 944 void wxEnableTopLevelWindows(bool enable)
 945 {
 946     wxWindowList::Node *node;
 947     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
 948         node->GetData()->Enable(enable);
 949 }
 950
 951 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
 952 {
 953     // remember the top level windows which were already disabled, so that we
 954     // don't reenable them later
 955     m_winDisabled = NULL;
 956
 957     wxWindowList::Node *node;
 958     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
 959     {
 960         wxWindow *winTop = node->GetData();
 961         if ( winTop == winToSkip )
 962             continue;
 963
 964         if ( winTop->IsEnabled() )
 965         {
 966             winTop->Disable();
 967         }
 968         else
 969         {
 970             if ( !m_winDisabled )
 971             {
 972                 m_winDisabled = new wxWindowList;
 973             }
 974
 975             m_winDisabled->Append(winTop);
 976         }
 977     }
 978 }
 979
 980 wxWindowDisabler::~wxWindowDisabler()
 981 {
 982     wxWindowList::Node *node;
 983     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
 984     {
 985         wxWindow *winTop = node->GetData();
 986         if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
 987         {
 988             winTop->Enable();
 989         }
 990         //else: had been already disabled, don't reenable
 991     }
 992
 993     delete m_winDisabled;
 994 }
 995
 996 // Yield to other apps/messages and disable user input to all windows except
 997 // the given one
 998 bool wxSafeYield(wxWindow *win)
 999 {
1000     wxWindowDisabler wd(win);
1001
1002     bool rc = wxYield();
1003
1004     return rc;
1005 }
1006
1007 // ----------------------------------------------------------------------------
1008 // misc functions
1009 // ----------------------------------------------------------------------------
1010
1011 // Don't synthesize KeyUp events holding down a key and producing KeyDown
1012 // events with autorepeat. On by default and always on in wxMSW. wxGTK version
1013 // in utilsgtk.cpp.
1014 #ifndef __WXGTK__
1015 bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
1016 {
1017     return TRUE;    // detectable auto-repeat is the only mode MSW supports
1018 }
1019 #endif // !wxGTK
1020
1021 #endif // wxUSE_GUI
1022
1023 const wxChar *wxGetInstallPrefix()
1024 {
1025     wxString prefix;
1026
1027     if ( wxGetEnv(wxT("WXPREFIX"), &prefix) )
1028         return prefix.c_str();
1029
1030 #ifdef wxINSTALL_PREFIX
1031     return wxT(wxINSTALL_PREFIX);
1032 #else
1033     return wxT("");
1034 #endif
1035 }
1036
1037 wxString wxGetDataDir()
1038 {
1039     wxString format = wxGetInstallPrefix();
1040     format <<  wxFILE_SEP_PATH
1041            << wxT("share") << wxFILE_SEP_PATH
1042            << wxT("wx") << wxFILE_SEP_PATH
1043            << wxT("%i.%i");
1044     wxString dir;
1045     dir.Printf(format.c_str(), wxMAJOR_VERSION, wxMINOR_VERSION);
1046     return dir;
1047 }
1048
1049
1050 // ----------------------------------------------------------------------------
1051 // network and user id functions
1052 // ----------------------------------------------------------------------------
1053
1054 // Get Full RFC822 style email address
1055 bool wxGetEmailAddress(wxChar *address, int maxSize)
1056 {
1057     wxString email = wxGetEmailAddress();
1058     if ( !email )
1059         return FALSE;
1060
1061     wxStrncpy(address, email, maxSize - 1);
1062     address[maxSize - 1] = wxT('\0');
1063
1064     return TRUE;
1065 }
1066
1067 wxString wxGetEmailAddress()
1068 {
1069     wxString email;
1070
1071     wxString host = wxGetFullHostName();
1072     if ( !!host )
1073     {
1074         wxString user = wxGetUserId();
1075         if ( !!user )
1076         {
1077             email << user << wxT('@') << host;
1078         }
1079     }
1080
1081     return email;
1082 }
1083
1084 wxString wxGetUserId()
1085 {
1086     static const int maxLoginLen = 256; // FIXME arbitrary number
1087
1088     wxString buf;
1089     bool ok = wxGetUserId(buf.GetWriteBuf(maxLoginLen), maxLoginLen);
1090     buf.UngetWriteBuf();
1091
1092     if ( !ok )
1093         buf.Empty();
1094
1095     return buf;
1096 }
1097
1098 wxString wxGetUserName()
1099 {
1100     static const int maxUserNameLen = 1024; // FIXME arbitrary number
1101
1102     wxString buf;
1103     bool ok = wxGetUserName(buf.GetWriteBuf(maxUserNameLen), maxUserNameLen);
1104     buf.UngetWriteBuf();
1105
1106     if ( !ok )
1107         buf.Empty();
1108
1109     return buf;
1110 }
1111
1112 wxString wxGetHostName()
1113 {
1114     static const size_t hostnameSize = 257;
1115
1116     wxString buf;
1117     bool ok = wxGetHostName(buf.GetWriteBuf(hostnameSize), hostnameSize);
1118
1119     buf.UngetWriteBuf();
1120
1121     if ( !ok )
1122         buf.Empty();
1123
1124     return buf;
1125 }
1126
1127 wxString wxGetFullHostName()
1128 {
1129     static const size_t hostnameSize = 257;
1130
1131     wxString buf;
1132     bool ok = wxGetFullHostName(buf.GetWriteBuf(hostnameSize), hostnameSize);
1133
1134     buf.UngetWriteBuf();
1135
1136     if ( !ok )
1137         buf.Empty();
1138
1139     return buf;
1140 }
1141
1142 wxString wxGetHomeDir()
1143 {
1144     wxString home;
1145     wxGetHomeDir(&home);
1146
1147     return home;
1148 }
1149
1150 #if 0
1151
1152 wxString wxGetCurrentDir()
1153 {
1154     wxString dir;
1155     size_t len = 1024;
1156     bool ok;
1157     do
1158     {
1159         ok = getcwd(dir.GetWriteBuf(len + 1), len) != NULL;
1160         dir.UngetWriteBuf();
1161
1162         if ( !ok )
1163         {
1164             if ( errno != ERANGE )
1165             {
1166                 wxLogSysError(_T("Failed to get current directory"));
1167
1168                 return wxEmptyString;
1169             }
1170             else
1171             {
1172                 // buffer was too small, retry with a larger one
1173                 len *= 2;
1174             }
1175         }
1176         //else: ok
1177     } while ( !ok );
1178
1179     return dir;
1180 }
1181
1182 #endif // 0
1183
1184 // ----------------------------------------------------------------------------
1185 // wxExecute
1186 // ----------------------------------------------------------------------------
1187
1188 // this is a private function because it hasn't a clean interface: the first
1189 // array is passed by reference, the second by pointer - instead we have 2
1190 // public versions of wxExecute() below
1191 static long wxDoExecuteWithCapture(const wxString& command,
1192                                    wxArrayString& output,
1193                                    wxArrayString* error)
1194 {
1195 #ifdef __WIN16__
1196     wxFAIL_MSG("Sorry, this version of wxExecute not implemented on WIN16.");
1197
1198     return 0;
1199 #else // !Win16
1200     // create a wxProcess which will capture the output
1201     wxProcess *process = new wxProcess;
1202     process->Redirect();
1203
1204     long rc = wxExecute(command, wxEXEC_SYNC, process);
1205
1206 #if wxUSE_STREAMS
1207     if ( rc != -1 )
1208     {
1209         wxInputStream* is = process->GetInputStream();
1210         wxCHECK_MSG( is, -1, _T("if wxExecute() succeded, stream can't be NULL") );
1211         wxTextInputStream tis(*is);
1212
1213         wxTextInputStream *tes = NULL;
1214         wxInputStream *es = NULL;
1215         if ( error )
1216         {
1217             es = process->GetErrorStream();
1218
1219             wxCHECK_MSG( es, -1, _T("stderr can't be NULL") );
1220
1221             tes = new wxTextInputStream(*es);
1222         }
1223
1224         bool cont;
1225         do
1226         {
1227             cont = FALSE;
1228
1229             if ( !is->Eof() && is->IsOk() )
1230             {
1231                 wxString line = tis.ReadLine();
1232                 if ( is->LastError() )
1233                     break;
1234
1235                 cont = TRUE;
1236
1237                 output.Add(line);
1238             }
1239
1240             if ( error && !es->Eof() && es->IsOk() )
1241             {
1242                 wxString line = tes->ReadLine();
1243                 if ( es->LastError() )
1244                     break;
1245
1246                 cont = TRUE;
1247
1248                 error->Add(line);
1249             }
1250         }
1251         while ( cont );
1252
1253         delete tes;
1254     }
1255 #endif // wxUSE_STREAMS
1256
1257     delete process;
1258
1259     return rc;
1260 #endif // IO redirection supoprted
1261 }
1262
1263 long wxExecute(const wxString& command, wxArrayString& output)
1264 {
1265     return wxDoExecuteWithCapture(command, output, NULL);
1266 }
1267
1268 long wxExecute(const wxString& command,
1269                wxArrayString& output,
1270                wxArrayString& error)
1271 {
1272     return wxDoExecuteWithCapture(command, output, &error);
1273 }
1274
1275 // ----------------------------------------------------------------------------
1276 // wxApp::Yield() wrappers for backwards compatibility
1277 // ----------------------------------------------------------------------------
1278
1279 bool wxYield()
1280 {
1281 #if wxUSE_GUI
1282     return wxTheApp && wxTheApp->Yield();
1283 #else
1284     return FALSE;
1285 #endif
1286 }
1287
1288 bool wxYieldIfNeeded()
1289 {
1290 #if wxUSE_GUI
1291     return wxTheApp && wxTheApp->Yield(TRUE);
1292 #else
1293     return FALSE;
1294 #endif
1295 }
1296