Subversion Repositories openrisc_2011-10-31

//####COPYRIGHTBEGIN####
//                                                                          
// ----------------------------------------------------------------------------
// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
// Copyright (C) 2003 John Dallaway
//
// This program is part of the eCos host tools.
//
// This program is free software; you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by the Free 
// Software Foundation; either version 2 of the License, or (at your option) 
// any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT 
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
// more details.
// 
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// ----------------------------------------------------------------------------
//                                                                          
//####COPYRIGHTEND####
//
//===========================================================================
//===========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): 	sdf, jld
// Contact(s):	sdf
// Date:		1998/08/11
// Version:		0.01
// Purpose:	
// Description:	This is a collection of utility functions.
//              Modified by julians for wxWindows (originally CTUtils.h)
// Requires:	
// Provides:	
// See also:    
// Known bugs:	
// Usage:	
//
//####DESCRIPTIONEND####
//
//===========================================================================
 
#ifdef __GNUG__
#pragma implementation "ecutils.h"
#endif
 
// Includes other headers for precompiled compilation
#include "ecpch.h"
 
#ifdef __BORLANDC__
#pragma hdrstop
#endif
 
#include "ecutils.h"
#include "wx/listctrl.h"
#include "wx/stream.h"
 
#include <float.h> // for DBL_DIG macro
#include <sys/types.h>
#include <sys/stat.h>
 
#ifndef __WXMSW__
#include <errno.h>
#endif
 
#ifdef __WXMSW__
#include <tlhelp32.h>
#endif
 
#ifdef __CYGWIN__
#include <sys/cygwin.h> /* for cygwin_conv_to_*_path() */
#endif
 
#if 0
 
#define INCLUDEFILE <string>
#include "IncludeSTL.h"
 
#endif
 
// Chop str into pieces, using cSep as separator.
// " and \ have usual semantics
// Return value is array of pieces found.
 
int ecUtils::Chop(const wxString& psz, wxArrayString &ar, wxChar cSep,
                  bool bObserveStrings/*=false*/,bool bBackslashQuotes/*=false*/)
 
{
    if(wxT(' ') == cSep)
    {
        return Chop(psz, ar, wxT("\t\n\v\f\r "), bObserveStrings, bBackslashQuotes);
    } else {
        wxASSERT(wxT('\0')!=cSep);
        wxChar c[2]={cSep,wxT('\0')};
        return Chop(psz,ar,wxString(c),bObserveStrings,bBackslashQuotes);
    }
}
 
int ecUtils::Chop(const wxString& str, wxArrayString &ar, const wxString& sep,
                  bool bObserveStrings/*=false*/,bool bBackslashQuotes/*=false*/)
{
    ar.Clear();
 
    const wxChar* pszSep = (const wxChar*) sep;
    const wxChar* psz = (const wxChar*) str;
 
    int i=0;
    for(;;){
        // Skip multiple separators
        while(*psz && wxStrchr(pszSep,*psz)){
            psz++;
        }
        if(!*psz){
            return i;
        }
        wxString strTok;
        if(bObserveStrings){
            bool bInString=FALSE;
            do{
                if(*psz == wxT('\\') && bBackslashQuotes && psz[1]){
                    strTok += psz[1];
                    psz++;
                } else if(*psz == wxT('"')){
                    bInString ^= 1;
                } else if (!bInString && *psz && NULL != wxStrchr(pszSep,*psz)) {
                    break;
                } else {
                    strTok+=*psz;
                }
            } while (*++psz);
        } else {
            const wxChar* pszStart=psz;
            do {
                psz++;
            } while (*psz && ! wxStrchr(pszSep,*psz));
            strTok=wxString(pszStart,psz-pszStart);
        }
        ar.Add(strTok);
        i++;
    }
    return ar.GetCount();
}
 
#if 0
 
// vararg-style message box formatter
int ecUtils::MessageBoxF (LPCTSTR pszFormat, ...)
{
  int rc;
  va_list args;
  va_start(args, pszFormat);
  rc=ecUtils::vMessageBox(MB_OK, pszFormat,args);
  va_end(args);
  return rc;
}
 
// As above, but with type as first parameter.
int ecUtils::MessageBoxFT (UINT nType, LPCTSTR pszFormat, ...)
{
  int rc;
  va_list args;
  va_start(args, pszFormat);
  rc=ecUtils::vMessageBox(nType, pszFormat,args);
  va_end(args);
  return rc;
}
 
int ecUtils::vMessageBox(UINT nType, LPCTSTR  pszFormat, va_list marker)
{
  int rc=0;
  for(int nLength=100;nLength;) {
    TCHAR *buf=new TCHAR[1+nLength];
    int n=_vsntprintf(buf, nLength, pszFormat, marker ); 
    if(-1==n){
      nLength*=2;  // NT behavior
    } else if (n<nLength){
      rc=AfxMessageBox(buf,nType);
      nLength=0;   // trigger exit from loop
    } else {
      nLength=n+1; // UNIX behavior generally, or NT behavior when buffer size exactly matches required length
    }
    delete [] buf;
  }
  return rc;
}
 
#endif
 
bool ecUtils::StrToItemIntegerType(const wxString & str, long &d)
{
	wxChar* pEnd;
	bool rc;
	errno=0;
	bool bHex=(str.Len() > 2 && str[0]==wxT('0') && (str[1]==wxT('x')||str[1]==wxT('X')));
	//d=_tcstol(str,&pEnd,bHex?16:10);
	d=wxStrtol(str,&pEnd,bHex?16:10);
	rc=(0==errno && (*pEnd==wxT('\0')));
	return rc;
}
 
const wxString ecUtils::IntToStr(long d,bool bHex)
{
  wxString s;
  s.Printf(bHex?wxT("0x%08x"):wxT("%d"),d);
  return s;
}
 
const wxString ecUtils::DoubleToStr (double dValue)
{
  wxString s;
  s.Printf(wxT("%.*e"), DBL_DIG, dValue);
  return s;
}
 
bool ecUtils::StrToDouble (const wxString & strValue, double &dValue)
{
	wxChar* pEnd;
	errno = 0;
	//dValue = _tcstod (strValue, &pEnd);
	dValue = wxStrtod(strValue, &pEnd);
	return (0 == errno) && (*pEnd == wxT('\0'));
}
 
#if 0
const wxString ecUtils::Explanation(CFileException & exc)
{
	wxString strMsg;
	switch(exc.m_cause){
		case CFileException::none: strMsg=wxT("No error occurred.");break;
		case CFileException::generic: strMsg=wxT("   An unspecified error occurred.");break;
		case CFileException::fileNotFound: strMsg=wxT("   The file could not be located.");break;
		case CFileException::badPath: strMsg=wxT("   All or part of the path is invalid.");break;
		case CFileException::tooManyOpenFiles: strMsg=wxT("   The permitted number of open files was exceeded.");break;
		case CFileException::accessDenied: strMsg=wxT("   The file could not be accessed.");break;
		case CFileException::invalidFile: strMsg=wxT("   There was an attempt to use an invalid file handle.");break;
		case CFileException::removeCurrentDir: strMsg=wxT("   The current working directory cannot be removed.");break;
		case CFileException::directoryFull: strMsg=wxT("   There are no more directory entries.");break;
		case CFileException::badSeek: strMsg=wxT("   There was an error trying to set the file pointer.");break;
		case CFileException::hardIO: strMsg=wxT("   There was a hardware error.");break;
		case CFileException::sharingViolation: strMsg=wxT("   SHARE.EXE was not loaded, or a shared region was locked.");break;
		case CFileException::lockViolation: strMsg=wxT("   There was an attempt to lock a region that was already locked.");break;
		case CFileException::diskFull: strMsg=wxT("   The disk is full.");break;
		case CFileException::endOfFile: strMsg=wxT("   The end of file was reached. ");break;
		default:
			strMsg=wxT(" Unknown cause");
			break;
	}
	return strMsg;
}
 
 
const wxString ecUtils::LoadString(UINT id)
{
	wxString str;
	str.LoadString(id);
	return str;
}
#endif
 
const wxString ecUtils::NativeToPosixPath(const wxString & native)
{
#ifdef __CYGWIN__
    if (native.IsEmpty())
        return native;
    else
    {
        wxString posix;
        cygwin_conv_to_posix_path(native.c_str(), posix.GetWriteBuf(MAXPATHLEN + 1));
        posix.UngetWriteBuf();
        return posix;
    }
#else
    return native;
#endif
}
 
const wxString ecUtils::PosixToNativePath(const wxString & posix)
{
#ifdef __CYGWIN__
    if (posix.IsEmpty())
        return posix;
    else
    {
        wxString native;
        cygwin_conv_to_win32_path(posix.c_str(), native.GetWriteBuf(MAXPATHLEN + 1));
        native.UngetWriteBuf();
        return native;
    }
#else
    return posix;
#endif
}
 
bool ecUtils::AddToPath(const ecFileName & strFolder, bool bAtFront)
{
    wxString strPath,strOldPath;
 
    if (wxGetEnv(wxT("PATH"), & strOldPath))
    {
        // Place the user tools folders at the head or tail of the new path
        if(bAtFront)
        {
            strPath.Printf(wxT("%s;%s"), (const wxChar*) strFolder.ShortName(), (const wxChar*) strOldPath);
        } else
        {
            strPath.Printf(wxT("%s;%s"), (const wxChar*) strOldPath, (const wxChar*) strFolder.ShortName());
        }
    } else
    {
        // unlikely, but ...
        strPath = strFolder;
    }
    return (TRUE == wxSetEnv(wxT("PATH"),strPath));
}
 
#if 0		
wxString ecUtils::GetLastErrorMessageString()
{
	wxString str;
	PTCHAR pszMsg;
	FormatMessage( 
		FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
		NULL,
		GetLastError(),
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
		(LPTSTR)&pszMsg,
		0,
		NULL 
	);
 
	// Display the string.
	str=pszMsg;
  str.TrimRight();
	// Free the buffer.
	LocalFree(pszMsg);
	return str;
 
}
 
bool ecUtils::Launch(const ecFileName &strFileName, const ecFileName &strViewer)
{
	bool rc=false;
 
	if(!strViewer.IsEmpty())//use custom editor
	{
		wxString strCmdline(strViewer);
 
		PTCHAR pszCmdLine=strCmdline.GetBuffer(strCmdline.GetLength());
		GetShortPathName(pszCmdLine,pszCmdLine,strCmdline.GetLength());
		strCmdline.ReleaseBuffer();
 
		strCmdline+=_TCHAR(' ');
		strCmdline+=strFileName;
		PROCESS_INFORMATION pi;
		STARTUPINFO si;
 
		si.cb = sizeof(STARTUPINFO); 
		si.lpReserved = NULL; 
		si.lpReserved2 = NULL; 
		si.cbReserved2 = 0; 
		si.lpDesktop = NULL; 
		si.dwFlags = 0; 
		si.lpTitle=NULL;
 
		if(CreateProcess(
			NULL, // app name
			//strCmdline.GetBuffer(strCmdline.GetLength()),    // command line
			strCmdline.GetBuffer(strCmdline.GetLength()),    // command line
			NULL, // process security
			NULL, // thread security
			TRUE, // inherit handles
			0,
			NULL, // environment
			NULL, // current dir
			&si, // startup info
			&pi)){
            CloseHandle(pi.hProcess);
            CloseHandle(pi.hThread);
			rc=true;
		} else {
			MessageBoxF(wxT("Failed to invoke %s.\n"),strCmdline);
		}
		strCmdline.ReleaseBuffer();
	} else {// Use association
		TCHAR szExe[MAX_PATH];
		HINSTANCE h=FindExecutable(strFileName,wxT("."),szExe);
		if(int(h)<=32){
			wxString str;
			switch(int(h)){
				case 0:  str=wxT("The system is out of memory or resources.");break;
				case 31: str=wxT("There is no association for the specified file type.");break;
				case ERROR_FILE_NOT_FOUND: str=wxT("The specified file was not found.");break;
				case ERROR_PATH_NOT_FOUND: str=wxT("The specified path was not found.");break;
				case ERROR_BAD_FORMAT:     str=wxT("The .EXE file is invalid (non-Win32 .EXE or error in .EXE image).");break;
				default: break;
			}
			MessageBoxF(wxT("Failed to open document %s.\r\n%s"),strFileName,str);
		} else {
 
			SHELLEXECUTEINFO sei = {sizeof(sei), 0, AfxGetMainWnd()->GetSafeHwnd(), wxT("open"),
					strFileName, NULL, NULL, SW_SHOWNORMAL, AfxGetInstanceHandle( )};
 
			sei.hInstApp=0;
			HINSTANCE hInst=ShellExecute(AfxGetMainWnd()->GetSafeHwnd(),wxT("open"), strFileName, NULL, wxT("."), 0)/*ShellExecuteEx(&sei)*/;
			if(int(hInst)<=32/*sei.hInstApp==0*/)
			{
				wxString str;
				switch(int(hInst))
				{
					case 0 : str=wxT("The operating system is out of memory or resources. ");break;
					case ERROR_FILE_NOT_FOUND : str=wxT("The specified file was not found. ");break;
					case ERROR_PATH_NOT_FOUND : str=wxT("The specified path was not found. ");break;
					case ERROR_BAD_FORMAT : str=wxT("The .EXE file is invalid (non-Win32 .EXE or error in .EXE image). ");break;
					case SE_ERR_ACCESSDENIED : str=wxT("The operating system denied access to the specified file. ");break;
					case SE_ERR_ASSOCINCOMPLETE : str=wxT("The filename association is incomplete or invalid. ");break;
					case SE_ERR_DDEBUSY : str=wxT("The DDE transaction could not be completed because other DDE transactions were being processed. ");break;
					case SE_ERR_DDEFAIL : str=wxT("The DDE transaction failed. ");break;
					case SE_ERR_DDETIMEOUT : str=wxT("The DDE transaction could not be completed because the request timed out. ");break;
					case SE_ERR_DLLNOTFOUND : str=wxT("The specified dynamic-link library was not found. ");break;
					//case SE_ERR_FNF : str=wxT("The specified file was not found. ");break;
					case SE_ERR_NOASSOC : str=wxT("There is no application associated with the given filename extension. ");break;
					case SE_ERR_OOM : str=wxT("There was not enough memory to complete the operation. ");break;
					//case SE_ERR_PNF : str=wxT("The specified path was not found. ");break;
					case SE_ERR_SHARE : str=wxT("A sharing violation occurred. ");break;
					default: str=wxT("An unexpected error occurred");break;
				}
				MessageBoxF(wxT("Failed to open document %s using %s.\r\n%s"),strFileName,szExe,str);
			} else {
				rc=true;
			}
		}
	}
	return rc;
}
 
#endif
 
void ecUtils::UnicodeToCStr(const wxChar* str,char *&psz)
{
    int nLength=1 + wxStrlen(str);
    psz=new char[nLength];
#ifdef _UNICODE
    WideCharToMultiByte(CP_ACP, 0, str, -1, psz, nLength, NULL, NULL);
#else
    strcpy(psz,str);
#endif
}
 
std::string ecUtils::UnicodeToStdStr(const wxChar* str)
{
    std::string stdstr;
    char *psz;
    UnicodeToCStr(str,psz);
    stdstr=std::string(psz);
    delete psz;
    return stdstr;
}
 
// ecUtils::StripExtraWhitespace() returns a modified version of
// a string in which each sequence of whitespace characters is
// replaced by a single space
 
static bool ecIsSpace(wxChar ch)
{
	return (ch == wxT(' ') || ch == wxT('\r') || ch == wxT('\n') || ch == wxT('\t'));
}
 
wxString ecUtils::StripExtraWhitespace (const wxString & strInput)
{
    wxString strOutput;
    wxChar* o=strOutput.GetWriteBuf(1+strInput.Len());
    for(const wxChar* c=strInput.GetData();*c;c++){
        if(ecIsSpace(*c)){
            *o++=wxT(' ');
            if (ecIsSpace(c[1])){
                for(c=c+2; ecIsSpace(*c);c++);
                c--;
            }
        } else {
            *o++=*c;
        }
    }
    *o=0;
    strOutput.UngetWriteBuf();
    strOutput.Trim(TRUE);
    strOutput.Trim(FALSE);
    return strOutput;
#if 0    
    wxString strOutput;
    LPTSTR o=strOutput.GetBuffer(1+strInput.GetLength());
    for(LPCTSTR c=strInput;*c;c++){
        if(_istspace(*c)){
            *o++=_TCHAR(' ');
            if (_istspace(c[1])){
                for(c=c+2;_istspace(*c);c++);
                c--;
            }
        } else {
            *o++=*c;
        }
    }
    *o=0;
    strOutput.ReleaseBuffer();
    strOutput.TrimLeft();
    strOutput.TrimRight();
    return strOutput;
#endif
}
 
#if 0
ecFileName ecUtils::WPath(const std::string &str)
{
  // Convert a path as read from cdl into host format
  // Change / to \ throughout
  ecFileName
    strPath(str.c_str());
  strPath.Replace (_TCHAR('/'), _TCHAR('\\'));
  return strPath;
}
 
// Copy file helper function.
// This makes sure the destination file is only touched as necessary.
// It is written using Posix calls lest it should be more broadly applicable.
 
bool ecUtils::CopyFile(LPCTSTR pszSource,LPCTSTR pszDest)
{
  // Compare the files.  First set rc to the result of the comparison (true if the same)
  bool rc=false;
 
  struct _stat s1,s2;
  if(-1!=_tstat(pszSource,&s1) && -1!=_tstat(pszDest,&s2) && s1.st_size==s2.st_size){
    // Files both exist and are of equal size
    FILE *f1=_tfopen(pszSource,wxT("rb"));
    if(f1){
      FILE *f2=_tfopen(pszDest,wxT("rb"));
      if(f2){
        int nSize1,nSize2;
        rc=true;
        do{
          char buf1[4096],buf2[4096];
          nSize1=fread(buf1,1,sizeof buf1,f1);
          nSize2=fread(buf2,1,sizeof buf2,f2);
          if(nSize1!=nSize2 || 0!=memcmp(buf1,buf2,nSize1)){
            rc=false;
            break;
          }
        } while (nSize1>0);
        fclose(f2);
      }
      fclose(f1);
    }
  }
 
  if(rc){
    // Files are identical
  } else {
    rc=TRUE==::CopyFile(pszSource,pszDest,FALSE);
    if(rc){
    } else {
      MessageBoxF(wxT("Failed to copy '%s' to '%s' - %s"),pszSource,pszDest,GetLastErrorMessageString());
    }
  }
 
  return rc;
}
 
#endif
 
/*
 * wxStringToStringMap
 *
 * Stores string values keyed by strings
 */
 
void wxStringToStringMap::Set(const wxString& key, const wxString& value)
{
    wxString oldValue;
    if (Find(key, oldValue))
        Remove(key);
    m_hashTable.Put(key, (wxObject*) new wxString(value));
}
 
bool wxStringToStringMap::Remove(const wxString& key)
{
    wxString* str = (wxString*) m_hashTable.Delete(key);
    if (str)
    {
        delete str;
        return TRUE;
    }
    else
        return FALSE;
}
 
bool wxStringToStringMap::Find(const wxString& key, wxString& value)
{
    wxString* str = (wxString*) m_hashTable.Get(key);
    if (str)
    {
        value = * str;
        return TRUE;
    }
    else
        return FALSE;
}
 
void wxStringToStringMap::Clear()
{
    m_hashTable.BeginFind();
    wxNode* node;
    while ((node = m_hashTable.Next()))
    {
        wxString* str = (wxString*) node->Data();
        delete str;
    }
}
 
void wxStringToStringMap::BeginFind()
{
    m_hashTable.BeginFind();
}
 
bool wxStringToStringMap::Next(wxString& key, wxString& value)
{
    wxNode* node = m_hashTable.Next();
    if (node)
    {
        value = * (wxString*) node->Data();
        return TRUE;
    }
    else
        return FALSE;
}
 
// Is str a member of arr?
bool wxArrayStringIsMember(const wxArrayString& arr, const wxString& str)
{
    size_t i;
    for (i = (size_t) 0; i < arr.GetCount(); i++)
        if (arr[i] == str)
            return TRUE;
 
    return FALSE;
}
 
// Eliminate .. and .
wxString wxGetRealPath(const wxString& path)
{
    wxChar* p = new wxChar[path.Len() + 1];
    wxStrcpy(p, (const wxChar*) path);
    wxRealPath(p);
 
    wxString str(p);
    delete[] p;
    return str;
}
 
// A version of the above but prepending 'cwd' (current path) first
// if 'path' is relative
wxString wxGetRealPath(const wxString& cwd, const wxString& path)
{
    wxString path1(path);
 
    if (!wxIsAbsolutePath(path))
    {
        path1 = cwd;
        if (path1.Last() != wxFILE_SEP_PATH)
            path1 += wxFILE_SEP_PATH;
        path1 += path;
    }
 
    return wxGetRealPath(path1);
}
 
// Find the absolute path where this application has been run from.
// argv0 is wxTheApp->argv[0]
// cwd is the current working directory (at startup)
// appVariableName is the name of a variable containing the directory for this app, e.g.
// MYAPPDIR. This is checked first.
 
wxString wxFindAppPath(const wxString& argv0, const wxString& cwd, const wxString& appVariableName)
{
    wxString str;
 
    // Try appVariableName
    if (!appVariableName.IsEmpty())
    {
        str = wxGetenv(appVariableName);
        if (!str.IsEmpty())
            return str;
    }
 
    if (wxIsAbsolutePath(argv0))
        return wxPathOnly(argv0);
    else
    {
        // Is it a relative path?
        wxString currentDir(cwd);
        if (currentDir.Last() != wxFILE_SEP_PATH)
            currentDir += wxFILE_SEP_PATH;
 
        str = currentDir + argv0;
        if (wxFileExists(str))
            return wxPathOnly(str);
    }
 
    // OK, it's neither an absolute path nor a relative path.
    // Search PATH.
 
    wxPathList pathList;
    pathList.AddEnvList(wxT("PATH"));
    str = pathList.FindAbsoluteValidPath(argv0);
    if (!str.IsEmpty())
        return wxPathOnly(str);
 
    // Failed
    return wxEmptyString;
}
 
// Make a path name with no separators, out of a full pathname,
// e.g. opt_ecos_ecos-1.4.5 out of /opt/ecos/ecos-1.4.5
wxString ecMakeNameFromPath(const wxString& path)
{
    wxString p(path);
    p.Replace(wxT("/"), wxT("_"));
    p.Replace(wxT("\\"), wxT("_"));
    p.Replace(wxT(":"), wxT("_"));
    return p;
}
 
 
// Find the text of the list control item at the given column
wxString wxListCtrlGetItemTextColumn(wxListCtrl& listCtrl, long item, int col)
{
    wxListItem listItem;
    listItem.m_mask = wxLIST_MASK_TEXT;
    listItem.m_itemId = item;
    listItem.m_col = col;
 
    if (listCtrl.GetItem(listItem))
        return listItem.m_text;
    else
        return wxEmptyString;
}
 
// Select the given item
void wxListCtrlSelectItem(wxListCtrl& listCtrl, long sel, bool deselectOthers)
{
    long n = listCtrl.GetItemCount();
    long i;
    if (deselectOthers)
    {
        for (i = 0; i < n; i++)
        {
            if (listCtrl.GetItemState(i, wxLIST_STATE_SELECTED) & wxLIST_STATE_SELECTED)
            {
                listCtrl.SetItemState(i, wxLIST_STATE_SELECTED, 0);
            }
        }
    }
    listCtrl.SetItemState(sel, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}
 
// Find the selection
long wxListCtrlGetSelection(wxListCtrl& listCtrl)
{
    long n = listCtrl.GetItemCount();
    long i;
    for (i = 0; i < n; i++)
    {
        if (listCtrl.GetItemState(i, wxLIST_STATE_SELECTED) & wxLIST_STATE_SELECTED)
        {
            return i;
        }
    }
    return -1;
}
 
// Find which column the cursor is on
int wxListCtrlFindColumn(wxListCtrl& listCtrl, int noCols, int x)
{
    int col = 0;
 
    // Find which column we're on
    int width = 0;
    int i;
    for (i = 0; i < noCols; i++)
    {
        width += listCtrl.GetColumnWidth(i);
        if (x <= width)
        {
            col = i;
            break;
        }
    }
    return col;
}
 
// Utility function
void wxRefreshControls(wxWindow* win)
{
    wxNode *node = win->GetChildren().First();
    while (node)
    {
        wxWindow* win = (wxWindow*) node->Data();
        win->Refresh();
        node = node->Next();
    }
}
 
wxOutputStream& operator <<(wxOutputStream& stream, const wxString& s)
{
    stream.Write(s, s.Length());
    return stream;
}
 
wxOutputStream& operator <<(wxOutputStream& stream, long l)
{
    wxString str;
    str.Printf("%ld", l);
    return stream << str;
}
 
wxOutputStream& operator <<(wxOutputStream& stream, const char c)
{
    wxString str;
    str.Printf("%c", c);
    return stream << str;
}
 
/*
 * ecDialog
 * Supports features we want to have for all dialogs in the application.
 * So far, this just allows dialogs to be resizeable under MSW by
 * refreshing the controls in OnSize (otherwise there's a mess)
 */
 
IMPLEMENT_CLASS(ecDialog, wxDialog)
 
BEGIN_EVENT_TABLE(ecDialog, wxDialog)
#ifdef __WXMSW__
    EVT_SIZE(ecDialog::OnSize)
#endif
END_EVENT_TABLE()
 
void ecDialog::OnSize(wxSizeEvent& event)
{
    wxDialog::OnSize(event);
 
    wxRefreshControls(this);
}
 
/*
 * Implements saving/loading of window settings - fonts only for now
 */
 
wxWindowSettingsObject* wxWindowSettings::FindSettings(const wxString& windowName) const
{
    wxNode* node = m_settings.First();
    while (node)
    {
        wxWindowSettingsObject* obj = (wxWindowSettingsObject*) node->Data();
        if (obj->m_windowName.CmpNoCase(windowName) == 0)
            return obj;
        node = node->Next();
    }
    return NULL;
}
 
bool wxWindowSettings::LoadConfig(wxConfigBase& config)
{
    unsigned int i = 0;
    for (i = 0; i < GetCount(); i++)
    {
        wxWindowSettingsObject* obj = GetNth(i);
 
        wxString name(obj->m_windowName);
        name.Replace(wxT(" "), wxT(""));
 
        LoadFont(config, name, obj->m_font);
    }
 
    return TRUE;
}
 
bool wxWindowSettings::SaveConfig(wxConfigBase& config)
{
    unsigned int i = 0;
    for (i = 0; i < GetCount(); i++)
    {
        wxWindowSettingsObject* obj = GetNth(i);
 
        wxString name(obj->m_windowName);
        name.Replace(wxT(" "), wxT(""));
 
        SaveFont(config, name, obj->m_font);
    }
 
    return TRUE;
}
 
// Load and save font descriptions
bool wxWindowSettings::LoadFont(wxConfigBase& config, const wxString& windowName, wxFont& font)
{
    wxString pathBase(wxT("/Fonts/"));
    pathBase += windowName;
    pathBase += wxT("/");
 
    int pointSize, family, style, weight;
    bool underlined = FALSE;
    wxString faceName;
 
    if (!config.Read(pathBase + wxT("PointSize"), & pointSize))
        return FALSE;
 
    if (!config.Read(pathBase + wxT("Family"), & family))
        return FALSE;
 
    if (!config.Read(pathBase + wxT("Style"), & style))
        return FALSE;
 
    if (!config.Read(pathBase + wxT("Weight"), & weight))
        return FALSE;
 
    config.Read(pathBase + wxT("Underlined"), (bool*) & underlined);
    config.Read(pathBase + wxT("FaceName"), & faceName);
 
    wxFont font1(pointSize, family, style, weight, underlined, faceName);
    font = font1;
 
    return TRUE;    
}
 
bool wxWindowSettings::SaveFont(wxConfigBase& config, const wxString& windowName, const wxFont& font)
{
    if (!font.Ok())
        return FALSE;
 
    wxString pathBase(wxT("/Fonts/"));
    pathBase += windowName;
    pathBase += wxT("/");
 
    config.Write(pathBase + wxT("PointSize"), (long) font.GetPointSize());
    config.Write(pathBase + wxT("Family"), (long) font.GetFamily());
    config.Write(pathBase + wxT("Style"), (long) font.GetStyle());
    config.Write(pathBase + wxT("Weight"), (long) font.GetWeight());
    config.Write(pathBase + wxT("Underlined"), (long) font.GetUnderlined());
    config.Write(pathBase + wxT("FaceName"), font.GetFaceName());
 
    return TRUE;    
}
 
wxFont wxWindowSettings::GetFont(const wxString& name) const
{
    wxWindowSettingsObject* obj = FindSettings(name);
    if (!obj)
        return wxFont();
    else
        return obj->m_font;
}
 
void wxWindowSettings::SetFont(const wxString& name, const wxFont& font)
{
    wxWindowSettingsObject* obj = FindSettings(name);
    if (!obj)
    {
        obj = new wxWindowSettingsObject(name, NULL) ;
        obj->m_font = font;
        m_settings.Append(obj);
    }
    obj->m_font = font;
}
 
wxWindow* wxWindowSettings::GetWindow(const wxString& name) const
{
    wxWindowSettingsObject* obj = FindSettings(name);
    if (!obj)
        return NULL;
    if (obj->m_arrWindow.GetCount() > 0)
        return (wxWindow*) obj->m_arrWindow[0];
    else
        return NULL;
}
 
void wxWindowSettings::SetWindow(const wxString& name, wxWindow* win)
{
    wxWindowSettingsObject* obj = FindSettings(name);
    if (!obj)
    {
        obj = new wxWindowSettingsObject(name, win) ;
        m_settings.Append(obj);
    }
    obj->m_arrWindow.Clear();
 
    if (win)
        obj->m_arrWindow.Add(win);
}
 
wxArrayPtrVoid* wxWindowSettings::GetWindows(const wxString& name) const
{
    wxWindowSettingsObject* obj = FindSettings(name);
    if (!obj)
        return NULL;
    return & obj->m_arrWindow ;
}
 
void wxWindowSettings::SetWindows(const wxString& name, wxArrayPtrVoid& arr)
{
    wxWindowSettingsObject* obj = FindSettings(name);
    if (!obj)
    {
        obj = new wxWindowSettingsObject(name, NULL) ;
        m_settings.Append(obj);
    }
    obj->m_arrWindow.Clear() ;
    obj->m_arrWindow = arr;
}
 
bool wxWindowSettings::ApplyFontsToWindows()
{
    if (m_useDefaults)
        return FALSE;
 
    unsigned int i = 0;
    for (i = 0; i < GetCount(); i++)
    {
        wxWindowSettingsObject* obj = GetNth(i);
 
        unsigned int j = 0;
        for (j = 0; j < obj->m_arrWindow.GetCount(); j++)
        {
            wxWindow* win = (wxWindow*) obj->m_arrWindow[j];
            win->SetFont(obj->m_font);
            win->Refresh();
        }
    }
    return TRUE;
}
 
#ifdef __WIN32__
// This will be obsolete when we switch to using the version included
// in wxWindows (from wxWin 2.3.1 onwards)
enum ecKillError
{
    ecKILL_OK,              // no error
    ecKILL_BAD_SIGNAL,      // no such signal
    ecKILL_ACCESS_DENIED,   // permission denied
    ecKILL_NO_PROCESS,      // no such process
    ecKILL_ERROR            // another, unspecified error
};
#endif
 
// ----------------------------------------------------------------------------
// process management
// ----------------------------------------------------------------------------
 
#ifdef __WIN32__
 
// structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
struct wxNewFindByPidParams
{
    wxNewFindByPidParams() { hwnd = 0; pid = 0; }
 
    // the HWND used to return the result
    HWND hwnd;
 
    // the PID we're looking from
    DWORD pid;
};
 
// wxKill helper: EnumWindows() callback which is used to find the first (top
// level) window belonging to the given process
static BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)
{
    DWORD pid;
    (void)::GetWindowThreadProcessId(hwnd, &pid);
 
    wxNewFindByPidParams *params = (wxNewFindByPidParams *)lParam;
    if ( pid == params->pid )
    {
        // remember the window we found
        params->hwnd = hwnd;
 
        // return FALSE to stop the enumeration
        return FALSE;
    }
 
    // continue enumeration
    return TRUE;
}
 
// This will be obsolete when we switch to using the version included
// in wxWindows (from wxWin 2.3.1 onwards)
int wxNewKill(long pid, wxSignal sig, ecKillError *krc = NULL)
{
#ifdef __WIN32__
    // get the process handle to operate on
    HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
                                    PROCESS_TERMINATE |
                                    PROCESS_QUERY_INFORMATION,
                                    FALSE, // not inheritable
                                    (DWORD)pid);
    if ( hProcess == NULL )
    {
        if ( krc )
        {
            if ( ::GetLastError() == ERROR_ACCESS_DENIED )
            {
                *krc = ecKILL_ACCESS_DENIED;
            }
            else
            {
                *krc = ecKILL_NO_PROCESS;
            }
        }
 
        return -1;
    }
 
    bool ok = TRUE;
    switch ( sig )
    {
        case wxSIGKILL:
            // kill the process forcefully returning -1 as error code
            if ( !::TerminateProcess(hProcess, (UINT)-1) )
            {
                wxLogSysError(_("Failed to kill process %d"), pid);
 
                if ( krc )
                {
                    // this is not supposed to happen if we could open the
                    // process
                    *krc = ecKILL_ERROR;
                }
 
                ok = FALSE;
            }
            break;
 
        case wxSIGNONE:
            // do nothing, we just want to test for process existence
            break;
 
        default:
            // any other signal means "terminate"
            {
                wxNewFindByPidParams params;
                params.pid = (DWORD)pid;
 
                // EnumWindows() has nice semantics: it returns 0 if it found
                // something or if an error occured and non zero if it
                // enumerated all the window
                if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
                {
                    // did we find any window?
                    if ( params.hwnd )
                    {
                        // tell the app to close
                        //
                        // NB: this is the harshest way, the app won't have
                        //     opportunity to save any files, for example, but
                        //     this is probably what we want here. If not we
                        //     can also use SendMesageTimeout(WM_CLOSE)
                        if ( !::PostMessage(params.hwnd, WM_QUIT, 0, 0) )
                        {
                            wxLogLastError(_T("PostMessage(WM_QUIT)"));
                        }
                    }
                    else // it was an error then
                    {
                        wxLogLastError(_T("EnumWindows"));
 
                        ok = FALSE;
                    }
                }
                else // no windows for this PID
                {
                    if ( krc )
                    {
                        *krc = ecKILL_ERROR;
                    }
 
                    ok = FALSE;
                }
            }
    }
 
    // the return code
    DWORD rc;
 
    if ( ok )
    {
        // as we wait for a short time, we can use just WaitForSingleObject()
        // and not MsgWaitForMultipleObjects()
        switch ( ::WaitForSingleObject(hProcess, 500 /* msec */) )
        {
            case WAIT_OBJECT_0:
                // process terminated
                if ( !::GetExitCodeProcess(hProcess, &rc) )
                {
                    wxLogLastError(_T("GetExitCodeProcess"));
                }
                break;
 
            default:
                wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
                // fall through
 
            case WAIT_FAILED:
                wxLogLastError(_T("WaitForSingleObject"));
                // fall through
 
            case WAIT_TIMEOUT:
                if ( krc )
                {
                    *krc = ecKILL_ERROR;
                }
 
                rc = STILL_ACTIVE;
                break;
        }
    }
    else // !ok
    {
        // just to suppress the warnings about uninitialized variable
        rc = 0;
    }
 
    ::CloseHandle(hProcess);
 
    // the return code is the same as from Unix kill(): 0 if killed
    // successfully or -1 on error
    if ( sig == wxSIGNONE )
    {
        if ( ok && rc == STILL_ACTIVE )
        {
            // there is such process => success
            return 0;
        }
    }
    else // not SIGNONE
    {
        if ( ok && rc != STILL_ACTIVE )
        {
            // killed => success
            return 0;
        }
    }
#else // Win15
    wxFAIL_MSG( _T("not implemented") );
#endif // Win32/Win16
 
    // error
    return -1;
}
#endif
 
int ecKill(long pid, wxSignal sig)
{
#if defined(__UNIX__) && !defined(__CYGWIN__)
    return wxKill(pid, sig);
#elif defined(__WXMSW__)
    return wxNewKill(pid, sig);
#else
    return -1;
#endif
}
 
#ifdef _WIN32
  #include <tlhelp32.h>
 
  WXHINSTANCE wxProcessKiller::hInstLib1 = VER_PLATFORM_WIN32_NT==wxProcessKiller::GetPlatform()? (WXHINSTANCE) LoadLibrary(_T("PSAPI.DLL")) : (WXHINSTANCE) LoadLibrary(_T("Kernel32.DLL")) ;
  WXHINSTANCE wxProcessKiller::hInstLib2 = VER_PLATFORM_WIN32_NT==wxProcessKiller::GetPlatform()? (WXHINSTANCE) LoadLibrary(_T("NTDLL.DLL")): (WXHINSTANCE) NULL;
 
#endif
 
const unsigned int wxProcessKiller::PROCESS_KILL_EXIT_CODE=0xCCFFCCFF;
 
wxProcessKiller::wxProcessKiller(int pid):
  m_bVerbose(false),
  m_nExitCode(-1),
  m_idProcess(pid)
{
#ifdef _WIN32
      m_hProcess = (WXHANDLE) ::OpenProcess(SYNCHRONIZE |
          PROCESS_TERMINATE |
          PROCESS_QUERY_INFORMATION,
          FALSE, // not inheritable
          (DWORD) m_idProcess);
#endif
}
 
wxProcessKiller::~wxProcessKiller()
{
#ifdef _WIN32
    if (m_hProcess)
    {
        ::CloseHandle((HANDLE) m_hProcess);
    }
#endif
}
 
bool wxProcessKiller::Kill(bool bRecurse)
{
    wxPInfoArray arPinfo;
    bool rc=false;
    if(m_idProcess && -1!=m_idProcess){
        // Start of with the easy one:
        if(bRecurse) {
            // Need to gather this information before we orphan our grandchildren:
            PSExtract(arPinfo);
        }
 
#ifdef _WIN32
 
        if(m_hProcess){
            rc=(TRUE==::TerminateProcess((HANDLE) m_hProcess,PROCESS_KILL_EXIT_CODE));
            // dtor's (or subsequent Run's) responsibility to close the handle
        }
 
#else
        rc=(0==kill(m_idProcess,SIGTERM));
        int status;
        waitpid(m_idProcess,&status,WNOHANG);
#endif
 
        if(bRecurse) {
            // kill process *and* its children
            // FIXME: needs to be top-down
            for(int i=0;i<(signed)arPinfo.size();i++){
                if(arPinfo[i].IsChildOf(m_idProcess)){
 
#ifdef _WIN32
                    // begin hack
                    // WHY NECESSARY??
                    const wxString strName(Name(arPinfo[i].PID));
                    if(_tcsstr(strName,_T("eCosTest")) || _tcsstr(strName,_T("cmd.EXE")) || _tcsstr(strName,_T("CMD.EXE")) || arPinfo[i].PID==(signed)GetCurrentProcessId()){
                        continue;
                    }
                    // end hack
                    HANDLE hProcess=::OpenProcess(PROCESS_TERMINATE,false,arPinfo[i].PID);
                    if(hProcess){
                        rc&=(TRUE==::TerminateProcess(hProcess,PROCESS_KILL_EXIT_CODE));
                        CloseHandle(hProcess);
                    } else {
                        rc=false;
                    }
#else
                    rc&=(0==kill(arPinfo[i].PID,SIGTERM));
                    int status;
                    waitpid(arPinfo[i].PID,&status,WNOHANG);
#endif
                }
            }
        }
    }
    return rc;
}
 
#ifdef _WIN32
bool wxProcessKiller::PSExtract(wxProcessKiller::wxPInfoArray &arPinfo)
{
    bool rc=false;
    arPinfo.clear();
    // If Windows NT:
    switch(GetPlatform()) {
    case VER_PLATFORM_WIN32_NT:
        if(hInstLib1) {
 
            // Get procedure addresses.
            static BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * ) = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))GetProcAddress( (HINSTANCE) hInstLib1, "EnumProcesses" ) ;
            if( lpfEnumProcesses) {
 
                if(hInstLib2) {
 
                    static DWORD (WINAPI *lpfNtQueryInformationProcess)( HANDLE, int, void *, DWORD, LPDWORD ) =
                        (DWORD(WINAPI *)(HANDLE, int, void *, DWORD, LPDWORD)) GetProcAddress( (HINSTANCE) hInstLib2,"NtQueryInformationProcess" ) ;
 
                    if(lpfNtQueryInformationProcess){
                        DWORD dwMaxPids=256;
                        DWORD dwPidSize;
                        DWORD *arPids = NULL ;
                        do {
                            delete [] arPids;
                            arPids=new DWORD[dwMaxPids];
                        } while(lpfEnumProcesses(arPids, dwMaxPids, &dwPidSize) && dwPidSize/sizeof(DWORD)==dwMaxPids) ;
 
                        if(dwPidSize/sizeof(DWORD)<dwMaxPids){
                            rc=true;
                            for( DWORD dwIndex = 0 ; (signed)dwIndex < dwPidSize/sizeof(DWORD); dwIndex++ ) {
                                // Regardless of OpenProcess success or failure, we
                                // still call the enum func with the ProcID.
                                DWORD pid=arPids[dwIndex];
                                HANDLE hProcess=::OpenProcess( PROCESS_QUERY_INFORMATION, FALSE, pid ); 
                                if (hProcess ) {
                                    struct {
                                        DWORD ExitStatus; // receives process termination status
                                        DWORD PebBaseAddress; // receives process environment block address
                                        DWORD AffinityMask; // receives process affinity mask
                                        DWORD BasePriority; // receives process priority class
                                        ULONG UniqueProcessId; // receives process identifier
                                        ULONG InheritedFromUniqueProcessId; // receives parent process identifier
                                    } pbi;
                                    memset( &pbi, 0, sizeof(pbi)); 
                                    DWORD retLen; 
                                    __int64 ftCreation,ftExit,ftKernel,ftUser;
                                    if(lpfNtQueryInformationProcess(hProcess, 0 /*ProcessBasicInformation*/, &pbi, sizeof(pbi), &retLen)>=0 &&
                                        TRUE==::GetProcessTimes (hProcess,(FILETIME *)&ftCreation,(FILETIME *)&ftExit,(FILETIME *)&ftKernel,(FILETIME *)&ftUser)){
                                        // The second test is important.  It excludes orphaned processes who appear to have been adopted by virtue of a new
                                        // process having been created with the same ID as their original parent.
                                        wxPInfo p;
                                        p.PID=pid;
                                        p.PPID=pbi.InheritedFromUniqueProcessId;
                                        p.tCreation=ftCreation;
                                        p.tCpu=Time((ftKernel+ftUser)/10000);
                                        arPinfo.push_back(p);
                                    }
 
                                    CloseHandle(hProcess); 
 
                                }
                            }
                        }
                        delete [] arPids;
                    }          
                }
            }      
        }
        break;
    case VER_PLATFORM_WIN32_WINDOWS:
 
        if( hInstLib1) {
 
            static HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD)=
                (HANDLE(WINAPI *)(DWORD,DWORD))GetProcAddress( (HINSTANCE) hInstLib1,"CreateToolhelp32Snapshot" ) ;
            static BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32)=
                (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( (HINSTANCE) hInstLib1, "Process32First" ) ;
            static BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32)=
                (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))GetProcAddress( (HINSTANCE) hInstLib1, "Process32Next" ) ;
            if( lpfProcess32Next && lpfProcess32First && lpfCreateToolhelp32Snapshot) {
 
                // Get a handle to a Toolhelp snapshot of the systems
                // processes.
                HANDLE hSnapShot = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) ;
                if(INVALID_HANDLE_VALUE != hSnapShot) {
                    // Get the first process' information.
                    PROCESSENTRY32 procentry;
                    procentry.dwSize = sizeof(PROCESSENTRY32) ;
                    if(lpfProcess32First( hSnapShot, &procentry )){
                        rc=true;
                        do {
                            wxPInfo p;
                            p.PID=procentry.th32ProcessID;
                            p.PPID=procentry.th32ParentProcessID;
                            arPinfo.push_back(p);
                        } while(lpfProcess32Next( hSnapShot, &procentry ));
                    }
                    CloseHandle(hSnapShot);
                }
            }
        }
        break;
    default:
        break;
    }    
 
    SetParents(arPinfo);
 
    if(!rc){
        wxLogError(_T("Couldn't get process information!\n"));
    }
    return rc;
}
 
#else // UNIX
 
bool wxProcessKiller::PSExtract(wxProcessKiller::wxPInfoArray &arPinfo)
{
    arPinfo.clear();
    int i;
    FILE *f=popen("ps -l",_T("r") MODE_TEXT);
    if(f){
        char buf[100];
        while(fgets(buf,sizeof(buf)-1,f)){
            TCHAR discard[100];
            wxPInfo p;
            // Output is in the form
            //  F S   UID   PID  PPID  C PRI  NI ADDR    SZ WCHAN  TTY          TIME CMD
            //100 S   490   877   876  0  70   0    -   368 wait4  pts/0    00:00:00 bash
            int F,UID,C,PRI,NI,SZ,HH,MM,SS; 
            bool rc=(15==_stscanf(buf,_T("%d %s %d %d %d %d %d %d %s %d %s %s %d:%d:%d"),&F,discard,&UID,&p.PID,&p.PPID,&C,&PRI,&NI,discard,&SZ,discard,discard,&HH,&MM,&SS));
            if(rc){
                p.tCpu=1000*(SS+60*(60*HH+MM));
                arPinfo.push_back(p);
            }
        }
        pclose(f);
        for(i=0;i<(signed)arPinfo.size();i++){
            int pid=arPinfo[i].PPID;
            arPinfo[i].pParent=0;
            for(int j=0;j<(signed)arPinfo.size();j++){
                if(i!=j && arPinfo[j].PID==pid){
                    arPinfo[i].pParent=&arPinfo[j];
                    break;
                }
            }
        }
    } else {
        wxLogError(_T("Failed to run ps -l\n"));
    }
    return true; //FIXME
}
 
#endif
 
void wxProcessKiller::SetParents(wxProcessKiller::wxPInfoArray &arPinfo)
{
    int i;
    for(i=0;i<(signed)arPinfo.size();i++){
        wxPInfo &p=arPinfo[i];
        p.pParent=0;
        for(int j=0;j<(signed)arPinfo.size();j++){
            if(arPinfo[j].PID==p.PPID 
#ifdef _WIN32
                && arPinfo[j].tCreation<p.tCreation
#endif
                )
            {
                arPinfo[i].pParent=&arPinfo[j];
                break;
            }
        }
    }
 
    // Check for circularity
    bool bCircularity=false;
    for(i=0;i<(signed)arPinfo.size();i++){
        wxPInfo *p=&arPinfo[i];
        for(int j=0;j<(signed)arPinfo.size() && p;j++){
            p=p->pParent;
        }
        // If all is well, p should be NULL here.  Otherwise we have a loop.
        if(p){
            // Make sure it can't foul things up:
            arPinfo[i].pParent=0;
            bCircularity=true;
        }
    }
 
    if(bCircularity){
        wxLogError(_T("!!! Circularly linked process list at index %d\n"),i);
        for(int k=0;k<(signed)arPinfo.size();k++){
            const wxPInfo &p=arPinfo[k];
            wxLogError(_T("%d: %s ppid=%4d\n"),k,(LPCTSTR)Name(p.PID),p.PPID);
        }
    }
}
 
bool wxProcessKiller::wxPInfo::IsChildOf(int pid) const
{
    for(wxPInfo *p=pParent;p && p!=this;p=p->pParent) { // guard against circular linkage
        if(p->PID==pid){
            return true;
        }
    }
    return false;
}
 
const wxString wxProcessKiller::Name(int pid)
{
    wxString str;
    str.Printf(_T("id=%d"),pid);
#ifdef _DEBUG
#ifdef _WIN32
    if(VER_PLATFORM_WIN32_NT==GetPlatform() && hInstLib1){
        static BOOL (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *, DWORD, LPDWORD ) =
            (BOOL(WINAPI *)(HANDLE, HMODULE *, DWORD, LPDWORD)) GetProcAddress( (HINSTANCE) hInstLib1,"EnumProcessModules" ) ;
        static DWORD (WINAPI *lpfGetModuleFileNameEx)( HANDLE, HMODULE, LPTSTR, DWORD )=
            (DWORD (WINAPI *)(HANDLE, HMODULE,LPTSTR, DWORD )) GetProcAddress( (HINSTANCE) hInstLib1,"GetModuleFileNameExA" ) ;
        if( lpfEnumProcessModules &&  lpfGetModuleFileNameEx ) {
            HANDLE hProcess=::OpenProcess(PROCESS_ALL_ACCESS,false,pid);
            if(hProcess) {
                HMODULE hMod;
                DWORD dwSize;
                if(lpfEnumProcessModules( hProcess, &hMod, sizeof(HMODULE), &dwSize ) ){
                    // Get Full pathname:
                    TCHAR buf[1+MAX_PATH];
                    lpfGetModuleFileNameEx( hProcess, hMod, buf, MAX_PATH);
                    str+=_TCHAR(' ');
                    str+=buf;
                }
                CloseHandle(hProcess);
            }
        }
    }
#endif
#endif
    return str;
}
 
#ifdef _WIN32
long wxProcessKiller::GetPlatform()
{
    OSVERSIONINFO  osver;
    osver.dwOSVersionInfoSize = sizeof( osver ) ;
    return GetVersionEx( &osver ) ? (long) osver.dwPlatformId : (long)-1;
}
#endif
 
const wxString wxProcessKiller::ErrorString() const
{
#ifdef _WIN32
    TCHAR *pszMsg;
    FormatMessage(  
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        m_nErr,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
        (LPTSTR)&pszMsg,
        0,
        NULL 
        );
    return pszMsg;
#else 
    return strerror(errno);
#endif
}