[wxWidgets.git] / 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"
#include "wx/msgdlg.h"
#include "wx/textdlg.h"
#endif

#if wxUSE_IOSTREAMH
#include <iostream.h>
#include <fstream.h>
#else
#include <iostream>
#include <fstream>
#  ifdef _MSC_VER
      using namespace std;
#  endif
#endif

#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>
#ifndef __MWERKS__
#include <sys/types.h>
#include <sys/stat.h>
#endif

// 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 __WXMAC__
int strcasecmp(const char *str_1, const char *str_2)
{
  register char c1, c2;
  do {
    c1 = tolower(*str_1++);
    c2 = tolower(*str_2++);
  } while ( c1 && (c1 == c2) );

  return c1 - c2;
}

int strncasecmp(const char *str_1, const char *str_2, size_t maxchar)
{

  register char c1, c2;
  while( maxchar--) 
  {
    c1 = tolower(*str_1++);
    c2 = tolower(*str_2++);
    
    if ( !c1 || c1!=c2 )
  		return c1 - c2;
  		    
  } ;

  return 0 ;

}
#endif
#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 __WINDOWS__

#ifndef __GNUWIN32__
#ifndef __MWERKS__
#define strcasecmp stricmp
#define strncasecmp strnicmp
#else
#define strcasecmp _stricmp
#define strncasecmp _strnicmp
#endif
#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, (char **) NULL);
}

void 
StringToDouble (char *s, double *number)
{
  if (s && *s && number)
    *number = strtod (s, (char **) 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, (char **) NULL, 10);
}

void 
StringToLong (char *s, long *number)
{
  if (s && *s && number)
    *number = strtol (s, (char **) 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(const wxString& buf)
{
  int firstDigit, secondDigit;
  
  if (buf.GetChar(0) >= 'A')
    firstDigit = buf.GetChar(0) - 'A' + 10;
  else
    firstDigit = buf.GetChar(0) - '0';

  if (buf.GetChar(1) >= 'A')
    secondDigit = buf.GetChar(1) - 'A' + 10;
  else
    secondDigit = buf.GetChar(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;
}

// Convert decimal integer to 2-character hex string
wxString wxDecToHex(int dec)
{
    char buf[3];
    wxDecToHex(dec, buf);
    return wxString(buf);
}

// 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((time_t *) 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 (char *) 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;
}

wxString wxStripMenuCodes(const wxString& str)
{
    char *buf = new char[str.Length() + 1];
    wxStripMenuCodes((char*) (const char*) str, buf);
    wxString str1(buf);
    delete[] buf;
    return str1;
}

/*
 * 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 (wxWindow *) 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 (wxWindow *) 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 (wxWindow *) 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);
}

/*
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

/*
 * N.B. these convenience functions must be separate from msgdlgg.cpp, textdlgg.cpp
 * since otherwise the generic code may be pulled in unnecessarily.
 */

int wxMessageBox(const wxString& message, const wxString& caption, long style,
                 wxWindow *parent, int WXUNUSED(x), int WXUNUSED(y) )
{
    wxMessageDialog dialog(parent, message, caption, style);

    int ans = dialog.ShowModal();
    switch ( ans )
    {
        case wxID_OK:
            return wxOK;
            break;
        case wxID_YES:
            return wxYES;
            break;
        case wxID_NO:
            return wxNO;
            break;
        default:
        case wxID_CANCEL:
            return wxCANCEL;
            break;
    }
    return ans;
}

wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
                        const wxString& defaultValue, wxWindow *parent,
                        int x, int y, bool WXUNUSED(centre) )
{
    wxTextEntryDialog dialog(parent, message, caption, defaultValue, wxOK|wxCANCEL, wxPoint(x, y));
    if (dialog.ShowModal() == wxID_OK)
        return dialog.GetValue();
    else
        return wxString("");
}

#ifdef __MWERKS__
char *strdup(const char *s) 
{
	return strcpy( (char*) malloc( strlen( s ) + 1 ) , s ) ;
}

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