src/common/utilscmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        utilscmn.cpp
// Purpose:     Miscellaneous utility functions and classes
// Author:      Julian Smart
// Modified by:
// Created:     29/01/98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Julian Smart
// Licence:   	wxWindows license
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "utils.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/defs.h"
#include "wx/utils.h"
#include "wx/window.h"
#include "wx/menu.h"
#include "wx/frame.h"
#endif

#if USE_IOSTREAMH
#include <iostream.h>
#else
#include <iostream>
#endif

#include <fstream.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if !defined(__WATCOMC__)
#if !(defined(_MSC_VER) && (_MSC_VER > 800))
#include <errno.h>
#endif
#endif
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>

// Pattern matching code.
// Yes, this path is deliberate (for Borland compilation)
#ifdef wx_mac /* MATTHEW: [5] Mac doesn't like paths with "/" */
#include "glob.inc"
#else
#include "../common/glob.inc"
#endif

#ifdef __WXMSW__
#include "windows.h"
#endif

#define _MAXPATHLEN 500

extern char *wxBuffer;

#ifdef __VMS__
// we have no strI functions under VMS, therefore I have implemented
// an inefficient but portable version: convert copies of strings to lowercase
// and then use the normal comparison
static void myLowerString(char *s)
{
  while(*s){
    if(isalpha(*s)) *s = (char)tolower(*s);
    s++;
  }
}

int strcasecmp(const char *str_1, const char *str_2)
{
  char *temp1 = new char[strlen(str_1)+1];
  char *temp2 = new char[strlen(str_2)+1];
  strcpy(temp1,str_1);
  strcpy(temp2,str_2);
  myLowerString(temp1);
  myLowerString(temp2);

  int result = strcmp(temp1,temp2);
  delete[] temp1;
  delete[] temp2;

  return(result);
}

int strncasecmp(const char *str_1, const char *str_2, size_t maxchar)
{
  char *temp1 = new char[strlen(str_1)+1];
  char *temp2 = new char[strlen(str_2)+1];
  strcpy(temp1,str_1);
  strcpy(temp2,str_2);
  myLowerString(temp1);
  myLowerString(temp2);

  int result = strncmp(temp1,temp2,maxchar);
  delete[] temp1;
  delete[] temp2;

  return(result);
}
#endif

#ifdef __WXMSW__

#ifndef __GNUWIN32__
#define strcasecmp stricmp
#define strncasecmp strnicmp
#endif

#ifdef _MSC_VER
#pragma warning (disable : 4245)
#endif

#ifdef _MSC_VER
#pragma warning (default : 4245)
#endif

#else
// This declaration is missing in SunOS!
// (Yes, I know it is NOT ANSI-C but its in BSD libc)
#if defined(__xlC) || defined(__AIX__) || defined(__GNUG__)
extern "C"
{
  int strcasecmp (const char *, const char *);
  int strncasecmp (const char *, const char *, size_t);
}
#endif
#endif				/* __WXMSW__ */


char *
copystring (const char *s)
{
  if (s == NULL) s = "";
  size_t len = strlen (s) + 1;

  char *news = new char[len];
  memcpy (news, s, len);	// Should be the fastest

  return news;
}

// Id generation
static long wxCurrentId = 100;

long
wxNewId (void)
{
  return wxCurrentId++;
}

long
wxGetCurrentId(void) { return wxCurrentId; }

void
wxRegisterId (long id)
{
  if (id >= wxCurrentId)
    wxCurrentId = id + 1;
}

void
StringToFloat (char *s, float *number)
{
  if (s && *s && number)
    *number = (float) strtod (s, NULL);
}

void
StringToDouble (char *s, double *number)
{
  if (s && *s && number)
    *number = strtod (s, NULL);
}

char *
FloatToString (float number, const char *fmt)
{
  static char buf[256];

//  sprintf (buf, "%.2f", number);
  sprintf (buf, fmt, number);
  return buf;
}

char *
DoubleToString (double number, const char *fmt)
{
  static char buf[256];

  sprintf (buf, fmt, number);
  return buf;
}

void
StringToInt (char *s, int *number)
{
  if (s && *s && number)
    *number = (int) strtol (s, NULL, 10);
}

void
StringToLong (char *s, long *number)
{
  if (s && *s && number)
    *number = strtol (s, NULL, 10);
}

char *
IntToString (int number)
{
  static char buf[20];

  sprintf (buf, "%d", number);
  return buf;
}

char *
LongToString (long number)
{
  static char buf[20];

  sprintf (buf, "%ld", number);
  return buf;
}

// Array used in DecToHex conversion routine.
static char hexArray[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
  'C', 'D', 'E', 'F' };

// Convert 2-digit hex number to decimal
int wxHexToDec(char *buf)
{
  int firstDigit, secondDigit;

  if (buf[0] >= 'A')
    firstDigit = buf[0] - 'A' + 10;
  else
    firstDigit = buf[0] - '0';

  if (buf[1] >= 'A')
    secondDigit = buf[1] - 'A' + 10;
  else
    secondDigit = buf[1] - '0';

  return firstDigit * 16 + secondDigit;
}

// Convert decimal integer to 2-character hex string
void wxDecToHex(int dec, char *buf)
{
  int firstDigit = (int)(dec/16.0);
  int secondDigit = (int)(dec - (firstDigit*16.0));
  buf[0] = hexArray[firstDigit];
  buf[1] = hexArray[secondDigit];
  buf[2] = 0;
}

// Match a string INDEPENDENT OF CASE
bool
StringMatch (char *str1, char *str2, bool subString, bool exact)
{
  if (str1 == NULL || str2 == NULL)
    return FALSE;
  if (str1 == str2)
    return TRUE;

  if (subString)
    {
      int len1 = strlen (str1);
      int len2 = strlen (str2);
      int i;

      // Search for str1 in str2
      // Slow .... but acceptable for short strings
      for (i = 0; i <= len2 - len1; i++)
	{
	  if (strncasecmp (str1, str2 + i, len1) == 0)
	    return TRUE;
	}
    }
  else if (exact)
    {
      if (strcasecmp (str1, str2) == 0)
	return TRUE;
    }
  else
    {
      int len1 = strlen (str1);
      int len2 = strlen (str2);

      if (strncasecmp (str1, str2, wxMin (len1, len2)) == 0)
	return TRUE;
    }

  return FALSE;
}

// Return the current date/time
// [volatile]
wxString wxNow( void )
{
  time_t now = time(NULL);
  char *date = ctime(&now);
  date[24] = '\0';
  return wxString(date);
}

/* Get Full RFC822 style email address */
bool
wxGetEmailAddress (char *address, int maxSize)
{
  char host[65];
  char user[65];

  if (wxGetHostName(host, 64) == FALSE)
    return FALSE;
  if (wxGetUserId(user, 64) == FALSE)
    return FALSE;

  char tmp[130];
  strcpy(tmp, user);
  strcat(tmp, "@");
  strcat(tmp, host);

  strncpy(address, tmp, maxSize - 1);
  address[maxSize-1] = '\0';
  return TRUE;
}

/*
 * Strip out any menu codes
 */

char *wxStripMenuCodes (char *in, char *out)
{
  if (!in)
    return NULL;

  if (!out)
    out = copystring(in);

  char *tmpOut = out;

  while (*in)
    {
      if (*in == '&')
	{
	  // Check && -> &, &x -> x
	  if (*++in == '&')
	    *out++ = *in++;
	}
      else if (*in == '\t')
	{
          // Remove all stuff after \t in X mode, and let the stuff as is
          // in Windows mode.
          // Accelerators are handled in wx_item.cc for Motif, and are not
          // YET supported in XView
	  break;
	}
      else
	*out++ = *in++;
    }				// while

  *out = '\0';

  return tmpOut;
}


/*
 * Window search functions
 *
 */

/*
 * If parent is non-NULL, look through children for a label or title
 * matching the specified string. If NULL, look through all top-level windows.
 *
 */

static wxWindow *wxFindWindowByLabel1 (const wxString& title, wxWindow * parent);

wxWindow *
wxFindWindowByLabel (const wxString& title, wxWindow * parent)
{
  if (parent)
    {
      return wxFindWindowByLabel1 (title, parent);
    }
  else
    {
      for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ())
	{
	  wxWindow *win = (wxWindow *) node->Data ();
	  wxWindow *retwin = wxFindWindowByLabel1 (title, win);
	  if (retwin)
	    return retwin;
	}			// for()

    }
  return NULL;
}

// Recursive
static wxWindow *
wxFindWindowByLabel1 (const wxString& title, wxWindow * parent)
{
  if (parent)
    {
      if (parent->GetLabel() == title)
		return parent;
    }

  if (parent)
    {
      for (wxNode * node = parent->GetChildren()->First (); node; node = node->Next ())
	{
	  wxWindow *win = (wxWindow *) node->Data ();
	  wxWindow *retwin = wxFindWindowByLabel1 (title, win);
	  if (retwin)
	    return retwin;
	}			// for()

    }

  return NULL;			// Not found

}

/*
 * If parent is non-NULL, look through children for a name
 * matching the specified string. If NULL, look through all top-level windows.
 *
 */

static wxWindow *wxFindWindowByName1 (const wxString& title, wxWindow * parent);

wxWindow *
wxFindWindowByName (const wxString& title, wxWindow * parent)
{
  if (parent)
    {
      return wxFindWindowByName1 (title, parent);
    }
  else
    {
      for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ())
	{
	  wxWindow *win = (wxWindow *) node->Data ();
	  wxWindow *retwin = wxFindWindowByName1 (title, win);
	  if (retwin)
	    return retwin;
	}			// for()

    }
  // Failed? Try by label instead.
  return wxFindWindowByLabel(title, parent);
}

// Recursive
static wxWindow *
wxFindWindowByName1 (const wxString& title, wxWindow * parent)
{
  if (parent)
    {
    	if ( parent->GetName() == title )
			return parent;
    }

  if (parent)
    {
      for (wxNode * node = parent->GetChildren()->First (); node; node = node->Next ())
	{
	  wxWindow *win = (wxWindow *) node->Data ();
	  wxWindow *retwin = wxFindWindowByName1 (title, win);
	  if (retwin)
	    return retwin;
	}			// for()

    }

  return NULL;			// Not found

}

// Returns menu item id or -1 if none.
int
wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
{
  wxMenuBar *menuBar = frame->GetMenuBar ();
  if (!menuBar)
    return -1;
  return menuBar->FindMenuItem (menuString, itemString);
}

/*
 * wxDebugStreamBuf
 */
#if !defined(_WINDLL)

wxDebugStreamBuf::wxDebugStreamBuf(void)
{
  if (allocate()) setp(base(),ebuf());
}

int wxDebugStreamBuf::overflow(int WXUNUSED(i))
{
  int len = pptr() - pbase();
  char *txt = new char[len+1];
  strncpy(txt, pbase(), len);
  txt[len] = '\0';
#ifdef __WXMSW__
  OutputDebugString((LPCSTR)txt);
#else
  fprintf(stderr, txt);
#endif
  setp(pbase(), epptr());
  delete[] txt;
  return EOF;
}

int wxDebugStreamBuf::sync(void)
{
  int len = pptr() - pbase();
  char *txt = new char[len+1];
  strncpy(txt, pbase(), len);
  txt[len] = '\0';
#ifdef __WXMSW__
  OutputDebugString((LPCSTR)txt);
#else
  fprintf(stderr, txt);
#endif
  setp(pbase(), epptr());
  delete[] txt;
  return 0;
}

#endif

/*
On Fri, 21 Jul 1995, Paul Craven wrote:

> Is there a way to find the path of running program's executable? I can get
> my home directory, and the current directory, but I don't know how to get the
> executable directory.
>

The code below (warty as it is), does what you want on most Unix,
DOS, and Mac platforms (it's from the ALS Prolog main).

|| Ken Bowen      Applied Logic Systems, Inc.         PO Box 180,
||====            Voice:  +1 (617)965-9191            Newton Centre,
||                FAX:    +1 (617)965-1636            MA  02159  USA
                  Email:  ken@als.com        WWW: http://www.als.com
------------------------------------------------------------------------
*/

// This code is commented out but it may be integrated with wxWin at
// a later date, after testing. Thanks Ken!
#if 0

/*--------------------------------------------------------------------*
 | whereami is given a filename f in the form:  whereami(argv[0])
 | It returns the directory in which the executable file (containing
 | this code [main.c] ) may be found.  A dot will be returned to indicate
 | the current directory.
 *--------------------------------------------------------------------*/

static void
whereami(name)
    char *name;
{
    register char *cutoff = NULL;	/* stifle -Wall */
    register char *s;
    register char *t;
    int   cc;
    char  ebuf[4096];

    /*
     * See if the file is accessible either through the current directory
     * or through an absolute path.
     */

    if (access(name, R_OK) == 0) {

	/*-------------------------------------------------------------*
	 * The file was accessible without any other work.  But the current
	 * working directory might change on us, so if it was accessible
	 * through the cwd, then we should get it for later accesses.
	 *-------------------------------------------------------------*/

	t = imagedir;
	if (!absolute_pathname(name)) {
#if defined(DOS) || defined(__WIN32__)
	    int   drive;
	    char *newrbuf;

	    newrbuf = imagedir;
#ifndef __DJGPP__
	    if (*(name + 1) == ':') {
		if (*name >= 'a' && *name <= 'z')
		    drive = (int) (*name - 'a' + 1);
		else
		    drive = (int) (*name - 'A' + 1);
		*newrbuf++ = *name;
		*newrbuf++ = *(name + 1);
		*newrbuf++ = DIR_SEPARATOR;
	    }
	    else {
		drive = 0;
		*newrbuf++ = DIR_SEPARATOR;
	    }
	    if (getcwd(newrbuf, drive) == 0) {	/* } */
#else
	    if (getcwd(newrbuf, 1024) == 0) {	/* } */
#endif
#else  /* DOS */
#ifdef HAVE_GETWD
	    if (getwd(imagedir) == 0) {		/* } */
#else  /* !HAVE_GETWD */
	    if (getcwd(imagedir, 1024) == 0) {
#endif /* !HAVE_GETWD */
#endif /* DOS */
		fatal_error(FE_GETCWD, 0);
	    }
	    for (; *t; t++)	/* Set t to end of buffer */
		;
	    if (*(t - 1) == DIR_SEPARATOR)	/* leave slash if already
						 * last char
						 */
		cutoff = t - 1;
	    else {
		cutoff = t;	/* otherwise put one in */
		*t++ = DIR_SEPARATOR;
	    }
	}
#if (!defined(__MAC__) && !defined(__DJGPP__) && !defined(__GO32__) && !defined(__WIN32__))
	else
		(*t++ = DIR_SEPARATOR);
#endif

	/*-------------------------------------------------------------*
	 * Copy the rest of the string and set the cutoff if it was not
	 * already set.  If the first character of name is a slash, cutoff
	 * is not presently set but will be on the first iteration of the
	 * loop below.
	 *-------------------------------------------------------------*/

	for ((*name == DIR_SEPARATOR ? (s = name+1) : (s = name));;) {
	    if (*s == DIR_SEPARATOR)
			cutoff = t;
	    if (!(*t++ = *s++))
			break;
	}

    }
    else {

	/*-------------------------------------------------------------*
	 * Get the path list from the environment.  If the path list is
	 * inaccessible for any reason, leave with fatal error.
	 *-------------------------------------------------------------*/

#ifdef __MAC__
	if ((s = getenv("Commands")) == (char *) 0)
#else
	if ((s = getenv("PATH")) == (char *) 0)
#endif
	    fatal_error(FE_PATH, 0);

	/*
	 * Copy path list into ebuf and set the source pointer to the
	 * beginning of this buffer.
	 */

	strcpy(ebuf, s);
	s = ebuf;

	for (;;) {
	    t = imagedir;
	    while (*s && *s != PATH_SEPARATOR)
		*t++ = *s++;
	    if (t > imagedir && *(t - 1) == DIR_SEPARATOR)
		;		/* do nothing -- slash already is in place */
	    else
		*t++ = DIR_SEPARATOR;	/* put in the slash */
	    cutoff = t - 1;	/* set cutoff */
	    strcpy(t, name);
	    if (access(imagedir, R_OK) == 0)
		break;

	    if (*s)
		s++;		/* advance source pointer */
	    else
		fatal_error(FE_INFND, 0);
	}

    }

    /*-------------------------------------------------------------*
     | At this point the full pathname should exist in imagedir and
     | cutoff should be set to the final slash.  We must now determine
     | whether the file name is a symbolic link or not and chase it down
     | if it is.  Note that we reuse ebuf for getting the link.
     *-------------------------------------------------------------*/

#ifdef HAVE_SYMLINK
    while ((cc = readlink(imagedir, ebuf, 512)) != -1) {
	ebuf[cc] = 0;
	s = ebuf;
	if (*s == DIR_SEPARATOR) {
	    t = imagedir;
	}
	else {
	    t = cutoff + 1;
	}
	for (;;) {
	    if (*s == DIR_SEPARATOR)
		cutoff = t;	/* mark the last slash seen */
	    if (!(*t++ = *s++))	/* copy the character */
		break;
	}
    }

#endif /* HAVE_SYMLINK */

    strcpy(imagename, cutoff + 1);	/* keep the image name */
    *(cutoff + 1) = 0;		/* chop off the filename part */
}

#endif
Commit	Line	Data
	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	#ifdef __GNUG__
	13	#pragma implementation "utils.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/defs.h"
	25	#include "wx/utils.h"
	26	#include "wx/window.h"
	27	#include "wx/menu.h"
	28	#include "wx/frame.h"
	29	#endif
	30
	31	#if USE_IOSTREAMH
	32	#include <iostream.h>
	33	#else
	34	#include <iostream>
	35	#endif
	36
	37	#include <fstream.h>
	38	#include <ctype.h>
	39	#include <stdio.h>
	40	#include <stdlib.h>
	41	#include <string.h>
	42	#if !defined(__WATCOMC__)
	43	#if !(defined(_MSC_VER) && (_MSC_VER > 800))
	44	#include <errno.h>
	45	#endif
	46	#endif
	47	#include <time.h>
	48	#include <sys/types.h>
	49	#include <sys/stat.h>
	50
	51	// Pattern matching code.
	52	// Yes, this path is deliberate (for Borland compilation)
	53	#ifdef wx_mac /* MATTHEW: [5] Mac doesn't like paths with "/" */
	54	#include "glob.inc"
	55	#else
	56	#include "../common/glob.inc"
	57	#endif
	58
	59	#ifdef __WXMSW__
	60	#include "windows.h"
	61	#endif
	62
	63	#define _MAXPATHLEN 500
	64
	65	extern char *wxBuffer;
	66
	67	#ifdef __VMS__
	68	// we have no strI functions under VMS, therefore I have implemented
	69	// an inefficient but portable version: convert copies of strings to lowercase
	70	// and then use the normal comparison
	71	static void myLowerString(char *s)
	72	{
	73	while(*s){
	74	if(isalpha(s)) s = (char)tolower(*s);
	75	s++;
	76	}
	77	}
	78
	79	int strcasecmp(const char str_1, const char str_2)
	80	{
	81	char *temp1 = new char[strlen(str_1)+1];
	82	char *temp2 = new char[strlen(str_2)+1];
	83	strcpy(temp1,str_1);
	84	strcpy(temp2,str_2);
	85	myLowerString(temp1);
	86	myLowerString(temp2);
	87
	88	int result = strcmp(temp1,temp2);
	89	delete[] temp1;
	90	delete[] temp2;
	91
	92	return(result);
	93	}
	94
	95	int strncasecmp(const char str_1, const char str_2, size_t maxchar)
	96	{
	97	char *temp1 = new char[strlen(str_1)+1];
	98	char *temp2 = new char[strlen(str_2)+1];
	99	strcpy(temp1,str_1);
	100	strcpy(temp2,str_2);
	101	myLowerString(temp1);
	102	myLowerString(temp2);
	103
	104	int result = strncmp(temp1,temp2,maxchar);
	105	delete[] temp1;
	106	delete[] temp2;
	107
	108	return(result);
	109	}
	110	#endif
	111
	112	#ifdef __WXMSW__
	113
	114	#ifndef __GNUWIN32__
	115	#define strcasecmp stricmp
	116	#define strncasecmp strnicmp
	117	#endif
	118
	119	#ifdef _MSC_VER
	120	#pragma warning (disable : 4245)
	121	#endif
	122
	123	#ifdef _MSC_VER
	124	#pragma warning (default : 4245)
	125	#endif
	126
	127	#else
	128	// This declaration is missing in SunOS!
	129	// (Yes, I know it is NOT ANSI-C but its in BSD libc)
	130	#if defined(__xlC) \|\| defined(__AIX__) \|\| defined(__GNUG__)
	131	extern "C"
	132	{
	133	int strcasecmp (const char , const char );
	134	int strncasecmp (const char , const char , size_t);
	135	}
	136	#endif
	137	#endif /* __WXMSW__ */
	138
	139
	140	char *
	141	copystring (const char *s)
	142	{
	143	if (s == NULL) s = "";
	144	size_t len = strlen (s) + 1;
	145
	146	char *news = new char[len];
	147	memcpy (news, s, len); // Should be the fastest
	148
	149	return news;
	150	}
	151
	152	// Id generation
	153	static long wxCurrentId = 100;
	154
	155	long
	156	wxNewId (void)
	157	{
	158	return wxCurrentId++;
	159	}
	160
	161	long
	162	wxGetCurrentId(void) { return wxCurrentId; }
	163
	164	void
	165	wxRegisterId (long id)
	166	{
	167	if (id >= wxCurrentId)
	168	wxCurrentId = id + 1;
	169	}
	170
	171	void
	172	StringToFloat (char s, float number)
	173	{
	174	if (s && *s && number)
	175	*number = (float) strtod (s, NULL);
	176	}
	177
	178	void
	179	StringToDouble (char s, double number)
	180	{
	181	if (s && *s && number)
	182	*number = strtod (s, NULL);
	183	}
	184
	185	char *
	186	FloatToString (float number, const char *fmt)
	187	{
	188	static char buf[256];
	189
	190	// sprintf (buf, "%.2f", number);
	191	sprintf (buf, fmt, number);
	192	return buf;
	193	}
	194
	195	char *
	196	DoubleToString (double number, const char *fmt)
	197	{
	198	static char buf[256];
	199
	200	sprintf (buf, fmt, number);
	201	return buf;
	202	}
	203
	204	void
	205	StringToInt (char s, int number)
	206	{
	207	if (s && *s && number)
	208	*number = (int) strtol (s, NULL, 10);
	209	}
	210
	211	void
	212	StringToLong (char s, long number)
	213	{
	214	if (s && *s && number)
	215	*number = strtol (s, NULL, 10);
	216	}
	217
	218	char *
	219	IntToString (int number)
	220	{
	221	static char buf[20];
	222
	223	sprintf (buf, "%d", number);
	224	return buf;
	225	}
	226
	227	char *
	228	LongToString (long number)
	229	{
	230	static char buf[20];
	231
	232	sprintf (buf, "%ld", number);
	233	return buf;
	234	}
	235
	236	// Array used in DecToHex conversion routine.
	237	static char hexArray[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
	238	'C', 'D', 'E', 'F' };
	239
	240	// Convert 2-digit hex number to decimal
	241	int wxHexToDec(char *buf)
	242	{
	243	int firstDigit, secondDigit;
	244
	245	if (buf[0] >= 'A')
	246	firstDigit = buf[0] - 'A' + 10;
	247	else
	248	firstDigit = buf[0] - '0';
	249
	250	if (buf[1] >= 'A')
	251	secondDigit = buf[1] - 'A' + 10;
	252	else
	253	secondDigit = buf[1] - '0';
	254
	255	return firstDigit * 16 + secondDigit;
	256	}
	257
	258	// Convert decimal integer to 2-character hex string
	259	void wxDecToHex(int dec, char *buf)
	260	{
	261	int firstDigit = (int)(dec/16.0);
	262	int secondDigit = (int)(dec - (firstDigit*16.0));
	263	buf[0] = hexArray[firstDigit];
	264	buf[1] = hexArray[secondDigit];
	265	buf[2] = 0;
	266	}
	267
	268	// Match a string INDEPENDENT OF CASE
	269	bool
	270	StringMatch (char str1, char str2, bool subString, bool exact)
	271	{
	272	if (str1 == NULL \|\| str2 == NULL)
	273	return FALSE;
	274	if (str1 == str2)
	275	return TRUE;
	276
	277	if (subString)
	278	{
	279	int len1 = strlen (str1);
	280	int len2 = strlen (str2);
	281	int i;
	282
	283	// Search for str1 in str2
	284	// Slow .... but acceptable for short strings
	285	for (i = 0; i <= len2 - len1; i++)
	286	{
	287	if (strncasecmp (str1, str2 + i, len1) == 0)
	288	return TRUE;
	289	}
	290	}
	291	else if (exact)
	292	{
	293	if (strcasecmp (str1, str2) == 0)
	294	return TRUE;
	295	}
	296	else
	297	{
	298	int len1 = strlen (str1);
	299	int len2 = strlen (str2);
	300
	301	if (strncasecmp (str1, str2, wxMin (len1, len2)) == 0)
	302	return TRUE;
	303	}
	304
	305	return FALSE;
	306	}
	307
	308	// Return the current date/time
	309	// [volatile]
	310	wxString wxNow( void )
	311	{
	312	time_t now = time(NULL);
	313	char *date = ctime(&now);
	314	date[24] = '\0';
	315	return wxString(date);
	316	}
	317
	318	/* Get Full RFC822 style email address */
	319	bool
	320	wxGetEmailAddress (char *address, int maxSize)
	321	{
	322	char host[65];
	323	char user[65];
	324
	325	if (wxGetHostName(host, 64) == FALSE)
	326	return FALSE;
	327	if (wxGetUserId(user, 64) == FALSE)
	328	return FALSE;
	329
	330	char tmp[130];
	331	strcpy(tmp, user);
	332	strcat(tmp, "@");
	333	strcat(tmp, host);
	334
	335	strncpy(address, tmp, maxSize - 1);
	336	address[maxSize-1] = '\0';
	337	return TRUE;
	338	}
	339
	340	/*
	341	* Strip out any menu codes
	342	*/
	343
	344	char wxStripMenuCodes (char in, char *out)
	345	{
	346	if (!in)
	347	return NULL;
	348
	349	if (!out)
	350	out = copystring(in);
	351
	352	char *tmpOut = out;
	353
	354	while (*in)
	355	{
	356	if (*in == '&')
	357	{
	358	// Check && -> &, &x -> x
	359	if (*++in == '&')
	360	out++ = in++;
	361	}
	362	else if (*in == '\t')
	363	{
	364	// Remove all stuff after \t in X mode, and let the stuff as is
	365	// in Windows mode.
	366	// Accelerators are handled in wx_item.cc for Motif, and are not
	367	// YET supported in XView
	368	break;
	369	}
	370	else
	371	out++ = in++;
	372	} // while
	373
	374	*out = '\0';
	375
	376	return tmpOut;
	377	}
	378
	379
	380	/*
	381	* Window search functions
	382	*
	383	*/
	384
	385	/*
	386	* If parent is non-NULL, look through children for a label or title
	387	* matching the specified string. If NULL, look through all top-level windows.
	388	*
	389	*/
	390
	391	static wxWindow wxFindWindowByLabel1 (const wxString& title, wxWindow parent);
	392
	393	wxWindow *
	394	wxFindWindowByLabel (const wxString& title, wxWindow * parent)
	395	{
	396	if (parent)
	397	{
	398	return wxFindWindowByLabel1 (title, parent);
	399	}
	400	else
	401	{
	402	for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ())
	403	{
	404	wxWindow win = (wxWindow ) node->Data ();
	405	wxWindow *retwin = wxFindWindowByLabel1 (title, win);
	406	if (retwin)
	407	return retwin;
	408	} // for()
	409
	410	}
	411	return NULL;
	412	}
	413
	414	// Recursive
	415	static wxWindow *
	416	wxFindWindowByLabel1 (const wxString& title, wxWindow * parent)
	417	{
	418	if (parent)
	419	{
	420	if (parent->GetLabel() == title)
	421	return parent;
	422	}
	423
	424	if (parent)
	425	{
	426	for (wxNode * node = parent->GetChildren()->First (); node; node = node->Next ())
	427	{
	428	wxWindow win = (wxWindow ) node->Data ();
	429	wxWindow *retwin = wxFindWindowByLabel1 (title, win);
	430	if (retwin)
	431	return retwin;
	432	} // for()
	433
	434	}
	435
	436	return NULL; // Not found
	437
	438	}
	439
	440	/*
	441	* If parent is non-NULL, look through children for a name
	442	* matching the specified string. If NULL, look through all top-level windows.
	443	*
	444	*/
	445
	446	static wxWindow wxFindWindowByName1 (const wxString& title, wxWindow parent);
	447
	448	wxWindow *
	449	wxFindWindowByName (const wxString& title, wxWindow * parent)
	450	{
	451	if (parent)
	452	{
	453	return wxFindWindowByName1 (title, parent);
	454	}
	455	else
	456	{
	457	for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ())
	458	{
	459	wxWindow win = (wxWindow ) node->Data ();
	460	wxWindow *retwin = wxFindWindowByName1 (title, win);
	461	if (retwin)
	462	return retwin;
	463	} // for()
	464
	465	}
	466	// Failed? Try by label instead.
	467	return wxFindWindowByLabel(title, parent);
	468	}
	469
	470	// Recursive
	471	static wxWindow *
	472	wxFindWindowByName1 (const wxString& title, wxWindow * parent)
	473	{
	474	if (parent)
	475	{
	476	if ( parent->GetName() == title )
	477	return parent;
	478	}
	479
	480	if (parent)
	481	{
	482	for (wxNode * node = parent->GetChildren()->First (); node; node = node->Next ())
	483	{
	484	wxWindow win = (wxWindow ) node->Data ();
	485	wxWindow *retwin = wxFindWindowByName1 (title, win);
	486	if (retwin)
	487	return retwin;
	488	} // for()
	489
	490	}
	491
	492	return NULL; // Not found
	493
	494	}
	495
	496	// Returns menu item id or -1 if none.
	497	int
	498	wxFindMenuItemId (wxFrame * frame, const wxString& menuString, const wxString& itemString)
	499	{
	500	wxMenuBar *menuBar = frame->GetMenuBar ();
	501	if (!menuBar)
	502	return -1;
	503	return menuBar->FindMenuItem (menuString, itemString);
	504	}
	505
	506	/*
	507	* wxDebugStreamBuf
	508	*/
	509	#if !defined(_WINDLL)
	510
	511	wxDebugStreamBuf::wxDebugStreamBuf(void)
	512	{
	513	if (allocate()) setp(base(),ebuf());
	514	}
	515
	516	int wxDebugStreamBuf::overflow(int WXUNUSED(i))
	517	{
	518	int len = pptr() - pbase();
	519	char *txt = new char[len+1];
	520	strncpy(txt, pbase(), len);
	521	txt[len] = '\0';
	522	#ifdef __WXMSW__
	523	OutputDebugString((LPCSTR)txt);
	524	#else
	525	fprintf(stderr, txt);
	526	#endif
	527	setp(pbase(), epptr());
	528	delete[] txt;
	529	return EOF;
	530	}
	531
	532	int wxDebugStreamBuf::sync(void)
	533	{
	534	int len = pptr() - pbase();
	535	char *txt = new char[len+1];
	536	strncpy(txt, pbase(), len);
	537	txt[len] = '\0';
	538	#ifdef __WXMSW__
	539	OutputDebugString((LPCSTR)txt);
	540	#else
	541	fprintf(stderr, txt);
	542	#endif
	543	setp(pbase(), epptr());
	544	delete[] txt;
	545	return 0;
	546	}
	547
	548	#endif
	549
	550	/*
	551	On Fri, 21 Jul 1995, Paul Craven wrote:
	552
	553	> Is there a way to find the path of running program's executable? I can get
	554	> my home directory, and the current directory, but I don't know how to get the
	555	> executable directory.
	556	>
	557
	558	The code below (warty as it is), does what you want on most Unix,
	559	DOS, and Mac platforms (it's from the ALS Prolog main).
	560
	561	\|\| Ken Bowen Applied Logic Systems, Inc. PO Box 180,
	562	\|\|==== Voice: +1 (617)965-9191 Newton Centre,
	563	\|\| FAX: +1 (617)965-1636 MA 02159 USA
	564	Email: ken@als.com WWW: http://www.als.com
	565	------------------------------------------------------------------------
	566	*/
	567
	568	// This code is commented out but it may be integrated with wxWin at
	569	// a later date, after testing. Thanks Ken!
	570	#if 0
	571
	572	/--------------------------------------------------------------------
	573	\| whereami is given a filename f in the form: whereami(argv[0])
	574	\| It returns the directory in which the executable file (containing
	575	\| this code [main.c] ) may be found. A dot will be returned to indicate
	576	\| the current directory.
	577	--------------------------------------------------------------------/
	578
	579	static void
	580	whereami(name)
	581	char *name;
	582	{
	583	register char cutoff = NULL; / stifle -Wall */
	584	register char *s;
	585	register char *t;
	586	int cc;
	587	char ebuf[4096];
	588
	589	/*
	590	* See if the file is accessible either through the current directory
	591	* or through an absolute path.
	592	*/
	593
	594	if (access(name, R_OK) == 0) {
	595
	596	/-------------------------------------------------------------
	597	* The file was accessible without any other work. But the current
	598	* working directory might change on us, so if it was accessible
	599	* through the cwd, then we should get it for later accesses.
	600	-------------------------------------------------------------/
	601
	602	t = imagedir;
	603	if (!absolute_pathname(name)) {
	604	#if defined(DOS) \|\| defined(__WIN32__)
	605	int drive;
	606	char *newrbuf;
	607
	608	newrbuf = imagedir;
	609	#ifndef __DJGPP__
	610	if (*(name + 1) == ':') {
	611	if (name >= 'a' && name <= 'z')
	612	drive = (int) (*name - 'a' + 1);
	613	else
	614	drive = (int) (*name - 'A' + 1);
	615	newrbuf++ = name;
	616	newrbuf++ = (name + 1);
	617	*newrbuf++ = DIR_SEPARATOR;
	618	}
	619	else {
	620	drive = 0;
	621	*newrbuf++ = DIR_SEPARATOR;
	622	}
	623	if (getcwd(newrbuf, drive) == 0) { /* } */
	624	#else
	625	if (getcwd(newrbuf, 1024) == 0) { /* } */
	626	#endif
	627	#else /* DOS */
	628	#ifdef HAVE_GETWD
	629	if (getwd(imagedir) == 0) { /* } */
	630	#else /* !HAVE_GETWD */
	631	if (getcwd(imagedir, 1024) == 0) {
	632	#endif /* !HAVE_GETWD */
	633	#endif /* DOS */
	634	fatal_error(FE_GETCWD, 0);
	635	}
	636	for (; t; t++) / Set t to end of buffer */
	637	;
	638	if ((t - 1) == DIR_SEPARATOR) / leave slash if already
	639	* last char
	640	*/
	641	cutoff = t - 1;
	642	else {
	643	cutoff = t; /* otherwise put one in */
	644	*t++ = DIR_SEPARATOR;
	645	}
	646	}
	647	#if (!defined(__MAC__) && !defined(__DJGPP__) && !defined(__GO32__) && !defined(__WIN32__))
	648	else
	649	(*t++ = DIR_SEPARATOR);
	650	#endif
	651
	652	/-------------------------------------------------------------
	653	* Copy the rest of the string and set the cutoff if it was not
	654	* already set. If the first character of name is a slash, cutoff
	655	* is not presently set but will be on the first iteration of the
	656	* loop below.
	657	-------------------------------------------------------------/
	658
	659	for ((*name == DIR_SEPARATOR ? (s = name+1) : (s = name));;) {
	660	if (*s == DIR_SEPARATOR)
	661	cutoff = t;
	662	if (!(t++ = s++))
	663	break;
	664	}
	665
	666	}
	667	else {
	668
	669	/-------------------------------------------------------------
	670	* Get the path list from the environment. If the path list is
	671	* inaccessible for any reason, leave with fatal error.
	672	-------------------------------------------------------------/
	673
	674	#ifdef __MAC__
	675	if ((s = getenv("Commands")) == (char *) 0)
	676	#else
	677	if ((s = getenv("PATH")) == (char *) 0)
	678	#endif
	679	fatal_error(FE_PATH, 0);
	680
	681	/*
	682	* Copy path list into ebuf and set the source pointer to the
	683	* beginning of this buffer.
	684	*/
	685
	686	strcpy(ebuf, s);
	687	s = ebuf;
	688
	689	for (;;) {
	690	t = imagedir;
	691	while (s && s != PATH_SEPARATOR)
	692	t++ = s++;
	693	if (t > imagedir && *(t - 1) == DIR_SEPARATOR)
	694	; /* do nothing -- slash already is in place */
	695	else
	696	t++ = DIR_SEPARATOR; / put in the slash */
	697	cutoff = t - 1; /* set cutoff */
	698	strcpy(t, name);
	699	if (access(imagedir, R_OK) == 0)
	700	break;
	701
	702	if (*s)
	703	s++; /* advance source pointer */
	704	else
	705	fatal_error(FE_INFND, 0);
	706	}
	707
	708	}
	709
	710	/-------------------------------------------------------------
	711	\| At this point the full pathname should exist in imagedir and
	712	\| cutoff should be set to the final slash. We must now determine
	713	\| whether the file name is a symbolic link or not and chase it down
	714	\| if it is. Note that we reuse ebuf for getting the link.
	715	-------------------------------------------------------------/
	716
	717	#ifdef HAVE_SYMLINK
	718	while ((cc = readlink(imagedir, ebuf, 512)) != -1) {
	719	ebuf[cc] = 0;
	720	s = ebuf;
	721	if (*s == DIR_SEPARATOR) {
	722	t = imagedir;
	723	}
	724	else {
	725	t = cutoff + 1;
	726	}
	727	for (;;) {
	728	if (*s == DIR_SEPARATOR)
	729	cutoff = t; /* mark the last slash seen */
	730	if (!(t++ = s++)) /* copy the character */
	731	break;
	732	}
	733	}
	734
	735	#endif /* HAVE_SYMLINK */
	736
	737	strcpy(imagename, cutoff + 1); /* keep the image name */
	738	(cutoff + 1) = 0; / chop off the filename part */
	739	}
	740
	741	#endif
	742