1. the common helper functions are now in src/unix/utilsunx.cpp

2. POSIX threads are in src/unix/threadpsx.cpp
3. some more functions are detected using configure and not  guessed from the
   platform type


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1867 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

configure.in

@@ -449,14 +449,28 @@ AC_SUBST(GTK_JOYSTICK)
 
 dnl check for vprintf/vsprintf() which are GNU extensions
 AC_FUNC_VPRINTF
-dnl check for vsnprintf() which is another GNU extension
+
-AC_CHECK_FUNCS(vsnprintf)
+dnl check for several standard functions we use if they are available
+AC_CHECK_FUNCS(vsnprintf vfork)
 
 dnl check for usleep() and nanosleep() which is better in MT programs
-AC_CHECK_FUNCS(nanosleep,
+dnl AC_CHECK_FUNCS(nanosleep, AC_DEFINE(HAVE_NANOSLEEP),
-        AC_DEFINE(HAVE_NANOSLEEP),
+dnl                [
-        [AC_CHECK_LIB(posix4, nanosleep, AC_DEFINE(HAVE_NANOSLEEP))])
+dnl                 AC_CHECK_LIB(posix4, nanosleep,
-AC_CHECK_FUNCS(usleep)
+dnl                    AC_DEFINE(HAVE_NANOSLEEP),
+dnl                    AC_CHECK_FUNCS(usleep))
+dnl                ]
+dnl               )
+AC_CHECK_FUNCS(nanosleep, AC_DEFINE(HAVE_NANOSLEEP),
+[AC_CHECK_LIB(posix4, nanosleep, AC_DEFINE(HAVE_NANOSLEEP),
+ [AC_CHECK_FUNCS(usleep, AC_DEFINE(HAVE_USLEEP),
+                         AC_MSG_WARN(Sleep() function will not work)
+  )]
+ )]
+)
+
+dnl check for uname (POSIX) and gethostname (BSD)
+AC_CHECK_FUNCS(uname gethostname, break)
 
 AC_LANG_SAVE
 AC_LANG_CPLUSPLUS
@@ -1383,7 +1397,7 @@ if test "$wxUSE_THREADS" = "1"; then
      dnl For glibc 2 users who have the old libc 5 too
 
      AC_CHECK_LIB(pthread-0.7, pthread_create, [
-       UNIX_THREAD="gtk/threadpsx.cpp"
+       UNIX_THREAD="unix/threadpsx.cpp"
        THREADS_LINK="pthread-0.7"
      ],[
        AC_CHECK_HEADER(sys/prctl.h, [
@@ -1394,7 +1408,7 @@ if test "$wxUSE_THREADS" = "1"; then
      dnl the case for pthread_setcanceltype.
 
      AC_CHECK_LIB(pthread, pthread_setcanceltype, [
-       UNIX_THREAD="gtk/threadpsx.cpp"
+       UNIX_THREAD="unix/threadpsx.cpp"
        THREADS_LINK="pthread"
      ])
     ])
@@ -1403,7 +1417,7 @@ if test "$wxUSE_THREADS" = "1"; then
         dnl thread functions are in libc_r under FreeBSD
         AC_CHECK_LIB(c_r, pthread_create,
                     [
-                        UNIX_THREAD="gtk/threadpsx.cpp"
+                        UNIX_THREAD="unix/threadpsx.cpp"
                         THREADS_LINK="c_r"
                     ])
     fi
@@ -1413,10 +1427,6 @@ if test "$wxUSE_THREADS" = "1"; then
     fi
 fi
 
-if test "$wxUSE_MOTIF" = "1"; then
-  UNIX_THREAD="motif/thread.cpp"
-fi
-
 if test -z "$UNIX_THREAD"; then
   wxUSE_THREADS=0
 fi
@@ -1580,3 +1590,4 @@ AC_CONFIG_HEADER(./include/wx/gtk/setup.h:./setup/setup.hin)
 AC_OUTPUT(./setup/substit ./wx-config:./wx-config.in,./setup/general/createall)
 
 AC_OVERRIDES_DONE
+

include/wx/thread.h

@@ -352,6 +352,8 @@ void WXDLLEXPORT wxMutexGuiLeave();
 
 #else // !wxUSE_THREADS
 
+#include <wx/defs.h> // for WXDLLEXPORT
+
 // no thread support
 inline void WXDLLEXPORT wxMutexGuiEnter() { }
 inline void WXDLLEXPORT wxMutexGuiLeave() { }

include/wx/unix/execute.h

@@ -0,0 +1,32 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        unix/execute.h
+// Purpose:     private details of wxExecute() implementation
+// Author:      Vadim Zeitlin
+// Id:          $Id$
+// Copyright:   (c) 1998 Robert Roebling, Julian Smart, Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_UNIX_EXECUTE_H
+#define _WX_UNIX_EXECUTE_H
+
+// if pid > 0, the execution is async and the data is freed in the callback
+// executed when the process terminates, if pid < 0, the execution is
+// synchronous and the caller (wxExecute) frees the data
+struct wxEndProcessData
+{
+    int pid,                // pid of the process
+        tag;                // port dependent value
+    wxProcess *process;     // if !NULL: notified on process termination
+    int  exitcode;          // the exit code
+};
+
+// this function is called when the process terminates from port specific
+// callback function and is common to all ports (src/unix/utilsunx.cpp)
+extern void wxHandleProcessTermination(wxEndProcessData *proc_data);
+
+// this function is called to associate the port-specific callback with the
+// child process. The return valus is port-specific.
+extern int wxAddProcessCallback(wxEndProcessData *proc_data, int fd);
+
+#endif // _WX_UNIX_EXECUTE_H

setup/setup.hin

@@ -380,8 +380,14 @@
 /* Define if you have nanosleep() */
 #undef HAVE_NANOSLEEP
 
-/* Define if you have usleep() */
+/* Define if you have vfork() */
-#undef HAVE_USLEEP
+#undef HAVE_VFORK
+
+/* Define if you have uname() */
+#undef HAVE_UNAME
+
+/* Define if you have gethostname() */
+#undef HAVE_GETHOSTNAME
 
 /* Define if you have sched_yield */
 #undef HAVE_SCHED_YIELD

src/common/utilscmn.cpp

@@ -801,19 +801,6 @@ int isascii( int c )
 }
 #endif
 
-// Overloaded functions, taking a wxString
-bool wxGetHostName(wxString& name)
-{
-    bool success = wxGetHostName(wxBuffer, 500);
-    if (success)
-    {
-        name = wxBuffer;
-        return TRUE;
-    }
-    else
-        return FALSE;
-}
-
 bool wxGetUserId(wxString& buf)
 {
     bool success = wxGetUserId(wxBuffer, 500);
@@ -838,3 +825,13 @@ bool wxGetUserName(wxString& buf)
         return FALSE;
 }
 
+bool wxGetHostName(wxString& buf)
+{
+    static const size_t hostnameSize = 257;
+    bool ok = wxGetHostName(buf.GetWriteBuf(hostnameSize), hostnameSize);
+
+    buf.UngetWriteBuf();
+
+    return ok;
+}
+

src/gtk.inc

@@ -124,6 +124,8 @@ LIB_CPP_SRC=\
  gtk/utilsgtk.cpp \
  gtk/utilsres.cpp \
  gtk/window.cpp \
+\
+ unix/utilsunx.cpp \
 \
  generic/choicdgg.cpp \
  generic/dcpsg.cpp \

src/gtk/threadno.cpp

@@ -8,6 +8,7 @@
 // Copyright:   (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
+
 #ifdef __GNUG__
     #pragma implementation "thread.h"
 #endif
@@ -25,7 +26,7 @@ wxMutex::wxMutex()
 wxMutex::~wxMutex()
 {
     if (m_locked)
-    wxLogDebug( "wxMutex warning: destroying a locked mutex (%d locks)\n", m_locked );
+        wxLogDebug( "wxMutex warning: destroying a locked mutex (%d locks)", m_locked );
 }
 
 wxMutexError wxMutex::Lock()
@@ -76,7 +77,8 @@ void wxCondition::Broadcast()
 {
 }
 
-struct wxThreadInternal {
+struct wxThreadInternal
+{
     int thread_id;
     void* exit_status;
 };
@@ -159,7 +161,6 @@ void wxThread::OnExit()
     Join();
 }
 
-
 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 
 bool wxThreadModule::OnInit()

src/gtk/utilsgtk.cpp

@@ -15,6 +15,8 @@
 
 #include "wx/process.h"
 
+#include "wx/unix/execute.h"
+
 #include <stdarg.h>
 #include <dirent.h>
 #include <string.h>
@@ -27,7 +29,6 @@
 #include <netdb.h>
 #include <signal.h>
 #include <fcntl.h>          // for O_WRONLY and friends
-#include <time.h>           // nanosleep() and/or usleep()
 
 #include <glib.h>
 #include <gdk/gdk.h>
@@ -35,85 +36,18 @@
 #include <gtk/gtkfeatures.h>
 #include <gdk/gdkx.h>
 
-#ifdef __SVR4__
+// ----------------------------------------------------------------------------
-  #include <sys/systeminfo.h>
-#endif
-
-// many versions of Unices have this function, but it is not defined in system
-// headers - please add your system here if it is the case for your OS.
-// SunOS < 5.6 (i.e. Solaris < 2.6) and DG-UX are like this.
-#if (defined(__SUN__) && !defined(__SunOs_5_6) && \
-                         !defined(__SunOs_5_7) && !defined(__SUNPRO_CC)) || \
-     defined(__osf__)
-    extern "C"
-    {
-        void usleep(unsigned long usec);
-    };
-#endif // Unices without usleep()
-
-// many versions of Unices have this function, but it is not defined in system
-// headers - please add your system here if it is the case for your OS.
-// SunOS (and Solaris) and DG-UX are like this.
-#if defined(__SOLARIS__) || defined(__osf__)
-    extern "C"
-    {
-        pid_t wait4(pid_t pid, int *statusp, int options,
-                    struct rusage *rusage);
-    }
-
-    #define wxWait4(pid, stat, flags, rusage) wait4(pid, stat, flags, rusage)
-#elif defined(__sgi) || defined(__HPUX__)
-    // no wait4() at all on these systems
-    // TODO verify whether wait3() really works in this situation
-    #define wxWait4(pid, stat, flags, rusage) wait3(stat, flags, rusage)
-#else
-    // other Unices: assume have wait4(), although it's not standard (but
-    // Linux and FreeBSD do have it)
-    #define wxWait4(pid, stat, flags, rusage) wait4(pid, stat, flags, rusage)
-#endif // wait4()
-
-//------------------------------------------------------------------------
 // misc.
-//------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-void wxBell(void)
+void wxBell()
 {
     gdk_beep();
 }
 
-void wxSleep(int nSecs)
+// ----------------------------------------------------------------------------
-{
+// display characterstics
-    sleep(nSecs);
+// ----------------------------------------------------------------------------
-}
-
-void wxUsleep(unsigned long milliseconds)
-{
-#if defined(HAVE_NANOSLEEP)
-    timespec tmReq;
-    tmReq.tv_sec = milliseconds / 1000;
-    tmReq.tv_nsec = (milliseconds % 1000) * 1000 * 1000;
-
-    // we're not interested in remaining time nor in return value
-    (void)nanosleep(&tmReq, (timespec *)NULL);
-#elif defined(HAVE_USLEEP)
-    // uncomment this if you feel brave or if you are sure that your version
-    // of Solaris has a safe usleep() function but please notice that usleep()
-    // is known to lead to crashes in MT programs in Solaris 2.[67] and is not
-    // documented as MT-Safe
-    #if defined(__SUN__) && defined(wxUSE_THREADS)
-        #error "usleep() cannot be used in MT programs under Solaris."
-    #endif // Sun
-
-    usleep(milliseconds * 1000); // usleep(3) wants microseconds
-#else // !sleep function
-    #error "usleep() or nanosleep() function required for wxUsleep"
-#endif // sleep function
-}
-
-int wxKill(long pid, int sig)
-{
-    return kill(pid, sig);
-}
 
 void wxDisplaySize( int *width, int *height )
 {
@@ -126,12 +60,12 @@ void wxGetMousePosition( int* x, int* y )
     gdk_window_get_pointer( (GdkWindow*) NULL, x, y, (GdkModifierType*) NULL );
 }
 
-bool wxColourDisplay(void)
+bool wxColourDisplay()
 {
     return TRUE;
 }
 
-int wxDisplayDepth(void)
+int wxDisplayDepth()
 {
     return gdk_window_get_visual( (GdkWindow*) &gdk_root_parent )->depth;
 }
@@ -144,312 +78,28 @@ int wxGetOsVersion(int *majorVsn, int *minorVsn)
   return wxGTK;
 }
 
-//------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-// user and home routines
-//------------------------------------------------------------------------
-
-const char* wxGetHomeDir( wxString *home  )
-{
-    *home = wxGetUserHome( wxString() );
-    if (home->IsNull()) *home = "/";
-    return *home;
-}
-
-char *wxGetUserHome( const wxString &user )
-{
-    struct passwd *who = (struct passwd *) NULL;
-
-    if (user.IsNull() || (user== ""))
-    {
-        register char *ptr;
-
-        if ((ptr = getenv("HOME")) != NULL)
-	{
-            return ptr;
-	}
-        if ((ptr = getenv("USER")) != NULL || (ptr = getenv("LOGNAME")) != NULL)
-	{
-            who = getpwnam(ptr);
-        }
-
-        /* We now make sure the the user exists! */
-        if (who == NULL)
-	{
-            who = getpwuid(getuid());
-	}
-    }
-    else
-    {
-      who = getpwnam (user);
-    }
-
-    return who ? who->pw_dir : (char*)NULL;
-}
-
-//------------------------------------------------------------------------
-// id routines
-//------------------------------------------------------------------------
-
-bool wxGetHostName(char *buf, int sz)
-{
-    *buf = '\0';
-#if defined(__SVR4__) && !defined(__sgi)
-    //KB: does this return the fully qualified host.domain name?
-    return (sysinfo(SI_HOSTNAME, buf, sz) != -1);
-#else /* BSD Sockets */
-    char name[255], domain[255];
-    //struct hostent *h;
-    // Get hostname
-    if (gethostname(name, sizeof(name)/sizeof(char)-1) == -1)
-        return FALSE;
-    if (getdomainname(domain, sizeof(domain)/sizeof(char)-1) == -1)
-        return FALSE;
-    // Get official full name of host
-    // doesn't return the full qualified name, replaced by following
-    // code (KB)
-    // strncpy(buf, (h=gethostbyname(name))!=NULL ? h->h_name : name, sz-1);
-    if((unsigned)sz > strlen(name)+strlen(domain)+1)
-    {
-        strcpy(buf, name);
-        if(strcmp(domain,"(none)") == 0) // standalone machine
-        {
-            strcat(buf,".");
-            strcat(buf,domain);
-        }
-    }
-    else
-        return FALSE;
-    return TRUE;
-#endif
-}
-
-bool wxGetUserId(char *buf, int sz)
-{
-    struct passwd *who;
-
-    *buf = '\0';
-    if ((who = getpwuid(getuid ())) != NULL) {
-        strncpy (buf, who->pw_name, sz-1);
-        return TRUE;
-    }
-    return FALSE;
-}
-
-bool wxGetUserName(char *buf, int sz)
-{
-    struct passwd *who;
-    char *comma;
-
-    *buf = '\0';
-    if ((who = getpwuid (getuid ())) != NULL) {
-       comma = strchr(who->pw_gecos,'c');
-       if(comma) *comma = '\0'; // cut off non-name comment fields
-       strncpy (buf, who->pw_gecos, sz - 1);
-        return TRUE;
-    }
-    return FALSE;
-}
-
-//------------------------------------------------------------------------
-// error and debug output routines
-//------------------------------------------------------------------------
-
-void wxDebugMsg( const char *format, ... )
-{
-  va_list ap;
-  va_start( ap, format );
-  vfprintf( stderr, format, ap );
-  fflush( stderr );
-  va_end(ap);
-}
-
-void wxError( const wxString &msg, const wxString &title )
-{
-  fprintf( stderr, "Error " );
-  if (!title.IsNull()) fprintf( stderr, "%s ", WXSTRINGCAST(title) );
-  if (!msg.IsNull()) fprintf( stderr, ": %s", WXSTRINGCAST(msg) );
-  fprintf( stderr, ".\n" );
-}
-
-void wxFatalError( const wxString &msg, const wxString &title )
-{
-  fprintf( stderr, "Error " );
-  if (!title.IsNull()) fprintf( stderr, "%s ", WXSTRINGCAST(title) );
-  if (!msg.IsNull()) fprintf( stderr, ": %s", WXSTRINGCAST(msg) );
-  fprintf( stderr, ".\n" );
-  exit(3); // the same exit code as for abort()
-}
-
-//------------------------------------------------------------------------
-// directory routines
-//------------------------------------------------------------------------
-
-bool wxDirExists( const wxString& dir )
-{
-    char buf[500];
-    strcpy( buf, WXSTRINGCAST(dir) );
-    struct stat sbuf;
-    return ((stat(buf, &sbuf) != -1) && S_ISDIR(sbuf.st_mode) ? TRUE : FALSE);
-}
-
-//------------------------------------------------------------------------
 // subprocess routines
-//------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-
-// if pid > 0, the execution is async and the data is freed in
-// GTK_EndProcessDetector, if pid < 0, the execution is synchronous and the
-// caller (wxExecute) frees the data
-struct wxEndProcessData
-{
-    gint pid, tag;
-    wxProcess *process;
-    int  exitcode;
-};
 
 static void GTK_EndProcessDetector(gpointer data, gint source,
                                    GdkInputCondition WXUNUSED(condition) )
 {
     wxEndProcessData *proc_data = (wxEndProcessData *)data;
-    int pid;
 
-    pid = (proc_data->pid > 0) ? proc_data->pid : -(proc_data->pid);
+    wxHandleProcessTermination(proc_data);
-
-    int status = 0;
-    wxWait4(pid, &status, 0, (rusage *) NULL);
 
     close(source);
     gdk_input_remove(proc_data->tag);
+}
 
-    if (proc_data->process)
+int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
-        proc_data->process->OnTerminate(proc_data->pid, status);
-
-    if (proc_data->pid > 0)
 {
-        delete proc_data;
+    int tag = gdk_input_add(fd,
-    }
+                            GDK_INPUT_READ,
-    else
+                            GTK_EndProcessDetector,
-    {
+                            (gpointer)proc_data);
-        // wxExecute() will know about it
-        proc_data->exitcode = status;
 
-        proc_data->pid = 0;
+    return tag;
-    }
 }
 
-long wxExecute( char **argv, bool sync, wxProcess *process )
-{
-    wxEndProcessData *data = new wxEndProcessData;
-    int end_proc_detect[2];
-
-    wxCHECK_MSG( *argv, 0, "can't exec empty command" );
-
-    /* Create pipes */
-    if (pipe(end_proc_detect) == -1)
-    {
-        wxLogSysError( _("Pipe creation failed") );
-        return 0;
-    }
-
-    /* fork the process */
-#if defined(sun) || defined(__ultrix) || defined(__bsdi__)
-    pid_t pid = vfork();
-#else
-    pid_t pid = fork();
-#endif
-    if (pid == -1)
-    {
-        wxLogSysError( _("Fork failed") );
-        return 0;
-    }
-    else if (pid == 0)
-    {
-        // we're in child
-        close(end_proc_detect[0]); // close reading side
-
-        // These three lines close the open file descriptors to to avoid any
-        // input/output which might block the process or irritate the user. If
-        // one wants proper IO for the subprocess, the "right thing to do is
-        // to start an xterm executing it.
-        close(STDIN_FILENO);
-        close(STDOUT_FILENO);
-
-        // leave stderr opened, it won't do any hurm
-#if 0
-        close(STDERR_FILENO);
-
-        // some programs complain about stderr not being open, so redirect
-        // them:
-        open("/dev/null", O_RDONLY);  // stdin
-        open("/dev/null", O_WRONLY);  // stdout
-        open("/dev/null", O_WRONLY);  // stderr
-#endif
-
-#ifdef _AIX
-        execvp ((const char *)*argv, (const char **)argv);
-#else
-        execvp (*argv, argv);
-#endif
-
-        // there is no return after successful exec()
-        fprintf(stderr, _("Can't execute '%s'\n"), *argv);
-
-        _exit(-1);
-    }
-    else
-    {
-        // we're in parent
-        close(end_proc_detect[1]); // close writing side
-        data->tag = gdk_input_add(end_proc_detect[0], GDK_INPUT_READ,
-                                  GTK_EndProcessDetector, (gpointer)data);
-        if ( sync )
-        {
-            wxASSERT_MSG( !process, "wxProcess param ignored for sync exec" );
-            data->process = NULL;
-
-            // sync execution: indicate it by negating the pid
-            data->pid = -pid;
-
-            // it will be set to 0 from GTK_EndProcessDetector
-            while (data->pid != 0)
-                wxYield();
-
-            int exitcode = data->exitcode;
-
-            delete data;
-
-            return exitcode;
-        }
-        else
-        {
-            // async execution, nothing special to do - caller will be
-            // notified about the process terminationif process != NULL, data
-            // will be deleted in GTK_EndProcessDetector
-            data->process = process;
-            data->pid = pid;
-
-            return pid;
-        }
-    }
-}
-
-long wxExecute( const wxString& command, bool sync, wxProcess *process )
-{
-    static const char *IFS = " \t\n";
-
-    wxCHECK_MSG( !command.IsEmpty(), 0, "can't exec empty command" );
-
-    int argc = 0;
-    char *argv[127];
-    char *tmp = new char[command.Len() + 1];
-    strcpy(tmp, command);
-
-    argv[argc++] = strtok(tmp, IFS);
-    while ((argv[argc++] = strtok((char *) NULL, IFS)) != NULL)
-        /* loop */ ;
-
-    long lRc = wxExecute(argv, sync, process);
-
-    delete [] tmp;
-
-    return lRc;
-}

src/gtk1/threadno.cpp

@@ -8,6 +8,7 @@
 // Copyright:   (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
+
 #ifdef __GNUG__
     #pragma implementation "thread.h"
 #endif
@@ -25,7 +26,7 @@ wxMutex::wxMutex()
 wxMutex::~wxMutex()
 {
     if (m_locked)
-    wxLogDebug( "wxMutex warning: destroying a locked mutex (%d locks)\n", m_locked );
+        wxLogDebug( "wxMutex warning: destroying a locked mutex (%d locks)", m_locked );
 }
 
 wxMutexError wxMutex::Lock()
@@ -76,7 +77,8 @@ void wxCondition::Broadcast()
 {
 }
 
-struct wxThreadInternal {
+struct wxThreadInternal
+{
     int thread_id;
     void* exit_status;
 };
@@ -159,7 +161,6 @@ void wxThread::OnExit()
     Join();
 }
 
-
 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 
 bool wxThreadModule::OnInit()

src/gtk1/utilsgtk.cpp

@@ -15,6 +15,8 @@
 
 #include "wx/process.h"
 
+#include "wx/unix/execute.h"
+
 #include <stdarg.h>
 #include <dirent.h>
 #include <string.h>
@@ -27,7 +29,6 @@
 #include <netdb.h>
 #include <signal.h>
 #include <fcntl.h>          // for O_WRONLY and friends
-#include <time.h>           // nanosleep() and/or usleep()
 
 #include <glib.h>
 #include <gdk/gdk.h>
@@ -35,85 +36,18 @@
 #include <gtk/gtkfeatures.h>
 #include <gdk/gdkx.h>
 
-#ifdef __SVR4__
+// ----------------------------------------------------------------------------
-  #include <sys/systeminfo.h>
-#endif
-
-// many versions of Unices have this function, but it is not defined in system
-// headers - please add your system here if it is the case for your OS.
-// SunOS < 5.6 (i.e. Solaris < 2.6) and DG-UX are like this.
-#if (defined(__SUN__) && !defined(__SunOs_5_6) && \
-                         !defined(__SunOs_5_7) && !defined(__SUNPRO_CC)) || \
-     defined(__osf__)
-    extern "C"
-    {
-        void usleep(unsigned long usec);
-    };
-#endif // Unices without usleep()
-
-// many versions of Unices have this function, but it is not defined in system
-// headers - please add your system here if it is the case for your OS.
-// SunOS (and Solaris) and DG-UX are like this.
-#if defined(__SOLARIS__) || defined(__osf__)
-    extern "C"
-    {
-        pid_t wait4(pid_t pid, int *statusp, int options,
-                    struct rusage *rusage);
-    }
-
-    #define wxWait4(pid, stat, flags, rusage) wait4(pid, stat, flags, rusage)
-#elif defined(__sgi) || defined(__HPUX__)
-    // no wait4() at all on these systems
-    // TODO verify whether wait3() really works in this situation
-    #define wxWait4(pid, stat, flags, rusage) wait3(stat, flags, rusage)
-#else
-    // other Unices: assume have wait4(), although it's not standard (but
-    // Linux and FreeBSD do have it)
-    #define wxWait4(pid, stat, flags, rusage) wait4(pid, stat, flags, rusage)
-#endif // wait4()
-
-//------------------------------------------------------------------------
 // misc.
-//------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-void wxBell(void)
+void wxBell()
 {
     gdk_beep();
 }
 
-void wxSleep(int nSecs)
+// ----------------------------------------------------------------------------
-{
+// display characterstics
-    sleep(nSecs);
+// ----------------------------------------------------------------------------
-}
-
-void wxUsleep(unsigned long milliseconds)
-{
-#if defined(HAVE_NANOSLEEP)
-    timespec tmReq;
-    tmReq.tv_sec = milliseconds / 1000;
-    tmReq.tv_nsec = (milliseconds % 1000) * 1000 * 1000;
-
-    // we're not interested in remaining time nor in return value
-    (void)nanosleep(&tmReq, (timespec *)NULL);
-#elif defined(HAVE_USLEEP)
-    // uncomment this if you feel brave or if you are sure that your version
-    // of Solaris has a safe usleep() function but please notice that usleep()
-    // is known to lead to crashes in MT programs in Solaris 2.[67] and is not
-    // documented as MT-Safe
-    #if defined(__SUN__) && defined(wxUSE_THREADS)
-        #error "usleep() cannot be used in MT programs under Solaris."
-    #endif // Sun
-
-    usleep(milliseconds * 1000); // usleep(3) wants microseconds
-#else // !sleep function
-    #error "usleep() or nanosleep() function required for wxUsleep"
-#endif // sleep function
-}
-
-int wxKill(long pid, int sig)
-{
-    return kill(pid, sig);
-}
 
 void wxDisplaySize( int *width, int *height )
 {
@@ -126,12 +60,12 @@ void wxGetMousePosition( int* x, int* y )
     gdk_window_get_pointer( (GdkWindow*) NULL, x, y, (GdkModifierType*) NULL );
 }
 
-bool wxColourDisplay(void)
+bool wxColourDisplay()
 {
     return TRUE;
 }
 
-int wxDisplayDepth(void)
+int wxDisplayDepth()
 {
     return gdk_window_get_visual( (GdkWindow*) &gdk_root_parent )->depth;
 }
@@ -144,312 +78,28 @@ int wxGetOsVersion(int *majorVsn, int *minorVsn)
   return wxGTK;
 }
 
-//------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-// user and home routines
-//------------------------------------------------------------------------
-
-const char* wxGetHomeDir( wxString *home  )
-{
-    *home = wxGetUserHome( wxString() );
-    if (home->IsNull()) *home = "/";
-    return *home;
-}
-
-char *wxGetUserHome( const wxString &user )
-{
-    struct passwd *who = (struct passwd *) NULL;
-
-    if (user.IsNull() || (user== ""))
-    {
-        register char *ptr;
-
-        if ((ptr = getenv("HOME")) != NULL)
-	{
-            return ptr;
-	}
-        if ((ptr = getenv("USER")) != NULL || (ptr = getenv("LOGNAME")) != NULL)
-	{
-            who = getpwnam(ptr);
-        }
-
-        /* We now make sure the the user exists! */
-        if (who == NULL)
-	{
-            who = getpwuid(getuid());
-	}
-    }
-    else
-    {
-      who = getpwnam (user);
-    }
-
-    return who ? who->pw_dir : (char*)NULL;
-}
-
-//------------------------------------------------------------------------
-// id routines
-//------------------------------------------------------------------------
-
-bool wxGetHostName(char *buf, int sz)
-{
-    *buf = '\0';
-#if defined(__SVR4__) && !defined(__sgi)
-    //KB: does this return the fully qualified host.domain name?
-    return (sysinfo(SI_HOSTNAME, buf, sz) != -1);
-#else /* BSD Sockets */
-    char name[255], domain[255];
-    //struct hostent *h;
-    // Get hostname
-    if (gethostname(name, sizeof(name)/sizeof(char)-1) == -1)
-        return FALSE;
-    if (getdomainname(domain, sizeof(domain)/sizeof(char)-1) == -1)
-        return FALSE;
-    // Get official full name of host
-    // doesn't return the full qualified name, replaced by following
-    // code (KB)
-    // strncpy(buf, (h=gethostbyname(name))!=NULL ? h->h_name : name, sz-1);
-    if((unsigned)sz > strlen(name)+strlen(domain)+1)
-    {
-        strcpy(buf, name);
-        if(strcmp(domain,"(none)") == 0) // standalone machine
-        {
-            strcat(buf,".");
-            strcat(buf,domain);
-        }
-    }
-    else
-        return FALSE;
-    return TRUE;
-#endif
-}
-
-bool wxGetUserId(char *buf, int sz)
-{
-    struct passwd *who;
-
-    *buf = '\0';
-    if ((who = getpwuid(getuid ())) != NULL) {
-        strncpy (buf, who->pw_name, sz-1);
-        return TRUE;
-    }
-    return FALSE;
-}
-
-bool wxGetUserName(char *buf, int sz)
-{
-    struct passwd *who;
-    char *comma;
-
-    *buf = '\0';
-    if ((who = getpwuid (getuid ())) != NULL) {
-       comma = strchr(who->pw_gecos,'c');
-       if(comma) *comma = '\0'; // cut off non-name comment fields
-       strncpy (buf, who->pw_gecos, sz - 1);
-        return TRUE;
-    }
-    return FALSE;
-}
-
-//------------------------------------------------------------------------
-// error and debug output routines
-//------------------------------------------------------------------------
-
-void wxDebugMsg( const char *format, ... )
-{
-  va_list ap;
-  va_start( ap, format );
-  vfprintf( stderr, format, ap );
-  fflush( stderr );
-  va_end(ap);
-}
-
-void wxError( const wxString &msg, const wxString &title )
-{
-  fprintf( stderr, "Error " );
-  if (!title.IsNull()) fprintf( stderr, "%s ", WXSTRINGCAST(title) );
-  if (!msg.IsNull()) fprintf( stderr, ": %s", WXSTRINGCAST(msg) );
-  fprintf( stderr, ".\n" );
-}
-
-void wxFatalError( const wxString &msg, const wxString &title )
-{
-  fprintf( stderr, "Error " );
-  if (!title.IsNull()) fprintf( stderr, "%s ", WXSTRINGCAST(title) );
-  if (!msg.IsNull()) fprintf( stderr, ": %s", WXSTRINGCAST(msg) );
-  fprintf( stderr, ".\n" );
-  exit(3); // the same exit code as for abort()
-}
-
-//------------------------------------------------------------------------
-// directory routines
-//------------------------------------------------------------------------
-
-bool wxDirExists( const wxString& dir )
-{
-    char buf[500];
-    strcpy( buf, WXSTRINGCAST(dir) );
-    struct stat sbuf;
-    return ((stat(buf, &sbuf) != -1) && S_ISDIR(sbuf.st_mode) ? TRUE : FALSE);
-}
-
-//------------------------------------------------------------------------
 // subprocess routines
-//------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-
-// if pid > 0, the execution is async and the data is freed in
-// GTK_EndProcessDetector, if pid < 0, the execution is synchronous and the
-// caller (wxExecute) frees the data
-struct wxEndProcessData
-{
-    gint pid, tag;
-    wxProcess *process;
-    int  exitcode;
-};
 
 static void GTK_EndProcessDetector(gpointer data, gint source,
                                    GdkInputCondition WXUNUSED(condition) )
 {
     wxEndProcessData *proc_data = (wxEndProcessData *)data;
-    int pid;
 
-    pid = (proc_data->pid > 0) ? proc_data->pid : -(proc_data->pid);
+    wxHandleProcessTermination(proc_data);
-
-    int status = 0;
-    wxWait4(pid, &status, 0, (rusage *) NULL);
 
     close(source);
     gdk_input_remove(proc_data->tag);
+}
 
-    if (proc_data->process)
+int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
-        proc_data->process->OnTerminate(proc_data->pid, status);
-
-    if (proc_data->pid > 0)
 {
-        delete proc_data;
+    int tag = gdk_input_add(fd,
-    }
+                            GDK_INPUT_READ,
-    else
+                            GTK_EndProcessDetector,
-    {
+                            (gpointer)proc_data);
-        // wxExecute() will know about it
-        proc_data->exitcode = status;
 
-        proc_data->pid = 0;
+    return tag;
-    }
 }
 
-long wxExecute( char **argv, bool sync, wxProcess *process )
-{
-    wxEndProcessData *data = new wxEndProcessData;
-    int end_proc_detect[2];
-
-    wxCHECK_MSG( *argv, 0, "can't exec empty command" );
-
-    /* Create pipes */
-    if (pipe(end_proc_detect) == -1)
-    {
-        wxLogSysError( _("Pipe creation failed") );
-        return 0;
-    }
-
-    /* fork the process */
-#if defined(sun) || defined(__ultrix) || defined(__bsdi__)
-    pid_t pid = vfork();
-#else
-    pid_t pid = fork();
-#endif
-    if (pid == -1)
-    {
-        wxLogSysError( _("Fork failed") );
-        return 0;
-    }
-    else if (pid == 0)
-    {
-        // we're in child
-        close(end_proc_detect[0]); // close reading side
-
-        // These three lines close the open file descriptors to to avoid any
-        // input/output which might block the process or irritate the user. If
-        // one wants proper IO for the subprocess, the "right thing to do is
-        // to start an xterm executing it.
-        close(STDIN_FILENO);
-        close(STDOUT_FILENO);
-
-        // leave stderr opened, it won't do any hurm
-#if 0
-        close(STDERR_FILENO);
-
-        // some programs complain about stderr not being open, so redirect
-        // them:
-        open("/dev/null", O_RDONLY);  // stdin
-        open("/dev/null", O_WRONLY);  // stdout
-        open("/dev/null", O_WRONLY);  // stderr
-#endif
-
-#ifdef _AIX
-        execvp ((const char *)*argv, (const char **)argv);
-#else
-        execvp (*argv, argv);
-#endif
-
-        // there is no return after successful exec()
-        fprintf(stderr, _("Can't execute '%s'\n"), *argv);
-
-        _exit(-1);
-    }
-    else
-    {
-        // we're in parent
-        close(end_proc_detect[1]); // close writing side
-        data->tag = gdk_input_add(end_proc_detect[0], GDK_INPUT_READ,
-                                  GTK_EndProcessDetector, (gpointer)data);
-        if ( sync )
-        {
-            wxASSERT_MSG( !process, "wxProcess param ignored for sync exec" );
-            data->process = NULL;
-
-            // sync execution: indicate it by negating the pid
-            data->pid = -pid;
-
-            // it will be set to 0 from GTK_EndProcessDetector
-            while (data->pid != 0)
-                wxYield();
-
-            int exitcode = data->exitcode;
-
-            delete data;
-
-            return exitcode;
-        }
-        else
-        {
-            // async execution, nothing special to do - caller will be
-            // notified about the process terminationif process != NULL, data
-            // will be deleted in GTK_EndProcessDetector
-            data->process = process;
-            data->pid = pid;
-
-            return pid;
-        }
-    }
-}
-
-long wxExecute( const wxString& command, bool sync, wxProcess *process )
-{
-    static const char *IFS = " \t\n";
-
-    wxCHECK_MSG( !command.IsEmpty(), 0, "can't exec empty command" );
-
-    int argc = 0;
-    char *argv[127];
-    char *tmp = new char[command.Len() + 1];
-    strcpy(tmp, command);
-
-    argv[argc++] = strtok(tmp, IFS);
-    while ((argv[argc++] = strtok((char *) NULL, IFS)) != NULL)
-        /* loop */ ;
-
-    long lRc = wxExecute(argv, sync, process);
-
-    delete [] tmp;
-
-    return lRc;
-}

src/motif/app.cpp

@@ -603,6 +603,12 @@ bool wxYield()
 {
     while (wxTheApp && wxTheApp->Pending())
         wxTheApp->Dispatch();
+
+    // VZ: is it the same as this (taken from old wxExecute)?
+#if 0
+    XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMAll);
+#endif
+
     return TRUE;
 }
 

src/motif/utils.cpp

@@ -9,11 +9,13 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
+// ============================================================================
-// Note: this is done in utilscmn.cpp now.
+// declarations
-// #pragma implementation
+// ============================================================================
-// #pragma implementation "utils.h"
+
-#endif
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
 
 #include "wx/setup.h"
 #include "wx/utils.h"
@@ -34,10 +36,6 @@
 #include <netdb.h>
 #include <signal.h>
 
-#if defined(__SOLARIS__) || defined(__SVR4__) && !defined(__HPUX__)
-#include <sys/systeminfo.h>
-#endif
-
 #if (defined(__SUNCC__) || defined(__CLCC__))
     #include <sysent.h>
 #endif
@@ -46,6 +44,10 @@
 
 #include "wx/motif/private.h"
 
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
 // Yuck this is really BOTH site and platform dependent
 // so we should use some other strategy!
 #ifdef sun
@@ -58,113 +60,13 @@ static char *GetIniFile (char *dest, const char *filename);
 
 extern wxList wxTopLevelWindows;
 
-// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
+// ============================================================================
-bool wxGetHostName(char *buf, int maxSize)
+// implementation
-{
+// ============================================================================
-#if defined(__SOLARIS__) || defined(__SVR4__) && !defined(__HPUX__)
-    return (sysinfo (SI_HOSTNAME, buf, maxSize) != -1);
-#else /* BSD Sockets */
-    char name[255];
-    struct hostent *h;
 
-    // Get hostname
+// ----------------------------------------------------------------------------
-    if (gethostname (name, sizeof (name) / sizeof (char) - 1) == -1)
+// async event processing
-        return FALSE;
+// ----------------------------------------------------------------------------
-    // Get official full name of host
-    strncpy (buf
-        ,(h = gethostbyname (name)) != NULL ? h->h_name : name
-        ,maxSize - 1);
-    return TRUE;
-#endif
-}
-
-// Get user ID e.g. jacs
-bool wxGetUserId(char *buf, int maxSize)
-{
-#ifdef VMS
-    *buf = '\0'; // return empty string
-    return FALSE;
-#else
-    struct passwd *who;
-    
-    if ((who = getpwuid (getuid ())) != NULL)
-    {
-        strncpy (buf, who->pw_name, maxSize - 1);
-        return TRUE;
-    }
-    return FALSE;
-#endif
-}
-
-// Get user name e.g. Julian Smart
-bool wxGetUserName(char *buf, int maxSize)
-{
-#ifdef VMS
-    *buf = '\0'; // return empty string
-    return FALSE;
-#else
-    struct passwd *who;
-    
-    if ((who = getpwuid (getuid ())) != NULL)
-    {
-        strncpy (buf, who->pw_gecos, maxSize - 1);
-        return TRUE;
-    }
-    return FALSE;
-#endif
-}
-
-int wxKill(long pid, int sig)
-{
-    int unixSignal = 0;
-    switch (sig)
-    {
-    case wxSIGTERM:
-    default:
-        unixSignal = SIGTERM;
-    }
-    return kill( (int)pid, unixSignal);
-}
-
-//
-// Execute a program in an Interactive Shell
-//
-bool wxShell(const wxString& command)
-{
-#ifdef VMS
-    return(FALSE);
-#else
-#if defined(sun) || defined(__ultrix) || defined(__bsdi__)
-    pid_t pid = vfork ();
-#else
-    pid_t pid = fork ();
-#endif
-    switch( pid ) {
-    case -1:			/* error */
-        return(FALSE);
-    case 0:			/* child */
-        // Generic X windows terminal window
-        if (command != "")
-            execlp("xterm", "-e", (char *) (const char*) command, NULL);
-        else
-            execlp("xterm", NULL);
-        _exit(127);
-    }
-    return TRUE;
-#endif
-    // End VMS
-}
-
-// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
-long wxGetFreeMemory()
-{
-    return -1;
-}
-
-void wxSleep(int nSecs)
-{
-    sleep(nSecs);
-}
 
 // Consume all events until no more left
 void wxFlushEvents()
@@ -184,36 +86,70 @@ void wxFlushEvents()
     }
 }
 
-// Output a debug message, in a system dependent fashion.
+// Check whether this window wants to process messages, e.g. Stop button
-void wxDebugMsg(const char *fmt ...)
+// in long calculations.
+bool wxCheckForInterrupt(wxWindow *wnd)
 {
-    va_list ap;
+    wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
-    char buffer[BUFSIZ];
 
-    if (!wxTheApp->GetWantDebugOutput())
+    Display *dpy=(Display*) wnd->GetXDisplay();
-        return ;
+    Window win=(Window) wnd->GetXWindow();
-    
+    XEvent event;
-    va_start (ap, fmt);
+    XFlush(dpy);
-    
+    if (wnd->GetMainWidget())
-    vsprintf (buffer, fmt, ap);
+    {
-    cerr << buffer;
+        XmUpdateDisplay((Widget)(wnd->GetMainWidget()));
-    
-    va_end (ap);
     }
 
-// Non-fatal error: pop up message box and (possibly) continue
+    bool hadEvents = FALSE;
-void wxError(const wxString& msg, const wxString& title)
+    while( XCheckMaskEvent(dpy,
+                           ButtonPressMask|ButtonReleaseMask|ButtonMotionMask|
+                           PointerMotionMask|KeyPressMask|KeyReleaseMask,
+                           &event) )
     {
-    cerr << (const char*) title << ": " << (const char*) msg << "\n";
+        if ( event.xany.window == win )
+        {
+            hadEvents = TRUE;
+
+            XtDispatchEvent(&event);
+        }
     }
 
-// Fatal error: pop up message box and abort
+    return hadEvents;
-void wxFatalError(const wxString& msg, const wxString& title)
-{
-    cerr << (const char*) title << ": " << (const char*) msg << "\n";
-    exit (1);
 }
 
+// ----------------------------------------------------------------------------
+// wxExecute stuff
+// ----------------------------------------------------------------------------
+
+static void xt_notify_end_process(XtPointer client, int *fid,
+                                  XtInputId *id)
+{
+    wxEndProcessData *proc_data = (wxEndProcessData *)data;
+
+    wxHandleProcessTermination(proc_data);
+
+    // VZ: I think they should be the same...
+    wxASSERT( (int)*id == proc_data->tag );
+
+    XtRemoveInput(*id);
+}
+
+int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
+{
+    XtInputId id = XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
+                                 fd,
+                                 (XtPointer *) XtInputReadMask,
+                                 (XtInputCallbackProc) xt_notify_end_process,
+                                 (XtPointer) process_data);
+
+    return (int)id;
+}
+
+// ----------------------------------------------------------------------------
+// misc
+// ----------------------------------------------------------------------------
+
 // Emit a beeeeeep
 void wxBell()
 {
@@ -223,19 +159,53 @@ void wxBell()
 
 int wxGetOsVersion(int *majorVsn, int *minorVsn)
 {
-    // TODO
+    // FIXME TODO
     // This code is WRONG!! Does NOT return the
     // Motif version of the libs but the X protocol
-    // version! @@@@@ Fix ME!!!!!!!!!
+    // version!
     Display *display = XtDisplay ((Widget) wxTheApp->GetTopLevelWidget());
     if (majorVsn)
         *majorVsn = ProtocolVersion (display);
     if (minorVsn)
         *minorVsn = ProtocolRevision (display);
+
     return wxMOTIF_X;
 }
 
+// ----------------------------------------------------------------------------
 // Reading and writing resources (eg WIN.INI, .Xdefaults)
+// ----------------------------------------------------------------------------
+
+// Read $HOME for what it says is home, if not
+// read $USER or $LOGNAME for user name else determine
+// the Real User, then determine the Real home dir.
+static char * GetIniFile (char *dest, const char *filename)
+{
+    char *home = NULL;
+    if (filename && wxIsAbsolutePath(filename))
+    {
+        strcpy(dest, filename);
+    }
+    else if ((home = wxGetUserHome("")) != NULL)
+    {
+        strcpy(dest, home);
+        if (dest[strlen(dest) - 1] != '/')
+            strcat (dest, "/");
+        if (filename == NULL)
+        {
+            if ((filename = getenv ("XENVIRONMENT")) == NULL)
+                filename = ".Xdefaults";
+        }
+        else if (*filename != '.')
+            strcat (dest, ".");
+        strcat (dest, filename);
+    } else
+    {
+        dest[0] = '\0';
+    }
+    return dest;
+}
+
 #if wxUSE_RESOURCES
 
 static char *GetResourcePath(char *buf, const char *name, bool create = FALSE)
@@ -547,6 +517,10 @@ wxSetDefaultResources (const Widget w, const char **resourceSpec, const char *na
 
 #endif // wxUSE_RESOURCES
 
+// ----------------------------------------------------------------------------
+// busy cursor stuff
+// ----------------------------------------------------------------------------
+
 static int wxBusyCursorCount = 0;
 
 // Helper function
@@ -622,76 +596,17 @@ bool wxIsBusy()
     return (wxBusyCursorCount > 0);
 }
 
-const char* wxGetHomeDir( wxString *home  )
+// ----------------------------------------------------------------------------
-{
+// display info
-    *home = wxGetUserHome( wxString() );
+// ----------------------------------------------------------------------------
-    if (home->IsNull()) *home = "/";
-    return *home;
-};
-
-char *wxGetUserHome (const wxString& user)
-{
-#ifdef VMS
-    return(NULL);
-#else
-    struct passwd *who = NULL;
-    
-    if (user == "") {
-        register char *ptr;
-        
-        if ((ptr = getenv("HOME")) != NULL) 
-            return ptr;
-        if ((ptr = getenv("USER")) != NULL ||
-            (ptr = getenv("LOGNAME")) != NULL)
-        {
-            who = getpwnam( ptr );
-        }
-        // We now make sure the the user exists!
-        if (who == NULL)
-            who = getpwuid( getuid() );
-    } else
-        who = getpwnam ((const char*) user);
-    
-    return who ? who->pw_dir : (char*) NULL;
-#endif
-    // ifdef VMS
-}
-
-// Check whether this window wants to process messages, e.g. Stop button
-// in long calculations.
-bool wxCheckForInterrupt(wxWindow *wnd)
-{
-    if(wnd){
-        Display *dpy=(Display*) wnd->GetXDisplay();
-        Window win=(Window) wnd->GetXWindow();
-        XEvent event;
-        XFlush(dpy);
-        if(wnd->GetMainWidget()){
-            XmUpdateDisplay((Widget)(wnd->GetMainWidget()));
-        }
-        while(XCheckMaskEvent(dpy,
-            ButtonPressMask|ButtonReleaseMask|ButtonMotionMask|
-            PointerMotionMask|KeyPressMask|KeyReleaseMask,
-            &event)){
-            if(event.xany.window==win)
-                XtDispatchEvent(&event);
-            //		else
-            //			XBell(dpy,50);
-        }
-        return TRUE;//*** temporary?
-    }
-    else{
-        wxMessageBox("wnd==NULL !!!");
-        return FALSE;//*** temporary?
-    }
-}
 
 void wxGetMousePosition( int* x, int* y )
 {
     XMotionEvent xev;
     Window root, child;
     XQueryPointer((Display*) wxGetDisplay(),
-        DefaultRootWindow((Display*) wxGetDisplay()), &root, &child,
+                  DefaultRootWindow((Display*) wxGetDisplay()),
+                  &root, &child,
                   &(xev.x_root), &(xev.y_root),
                   &(xev.x),      &(xev.y),
                   &(xev.state));
@@ -702,18 +617,14 @@ void wxGetMousePosition( int* x, int* y )
 // Return TRUE if we have a colour display
 bool wxColourDisplay()
 {
-    Display *dpy = (Display*) wxGetDisplay();
+    return wxDisplayDepth() > 1;
-    
-    if (DefaultDepth (dpy, DefaultScreen (dpy)) < 2)
-        return FALSE;
-    else
-        return TRUE;
 }
 
 // Returns depth of screen
 int wxDisplayDepth()
 {
     Display *dpy = (Display*) wxGetDisplay();
+
     return DefaultDepth (dpy, DefaultScreen (dpy));
 }
 
@@ -722,11 +633,13 @@ void wxDisplaySize(int *width, int *height)
 {
     Display *dpy = (Display*) wxGetDisplay();
 
+    if ( width )
         *width = DisplayWidth (dpy, DefaultScreen (dpy));
+    if ( height )
         *height = DisplayHeight (dpy, DefaultScreen (dpy));
 }
 
-/* Configurable display in Motif */
+// Configurable display in Motif
 static WXDisplay *gs_currentDisplay = NULL;
 static wxString gs_displayName;
 
@@ -747,9 +660,10 @@ bool wxSetDisplay(const wxString& display_name)
 {
     gs_displayName = display_name;
 
-    if (display_name.IsNull() || display_name.IsEmpty())
+    if ( !display_name )
     {
         gs_currentDisplay = NULL;
+
         return TRUE;
     }
     else
@@ -762,18 +676,21 @@ bool wxSetDisplay(const wxString& display_name)
             (const char*) wxTheApp->GetClassName(),
             NULL,
 #if XtSpecificationRelease < 5
-            0, &argc, NULL);
+            0, &argc,
 #else
-        0, (int *)&argc, NULL);
+            0, (int *)&argc,
 #endif
+            NULL);
 
         if (display)
         {
             gs_currentDisplay = (WXDisplay*) display;
             return TRUE;
-        } else
+        }
+        else
             return FALSE;
     }
+
     return FALSE;
 }
 
@@ -782,6 +699,10 @@ wxString wxGetDisplayName()
     return gs_displayName;
 }
 
+// ----------------------------------------------------------------------------
+// accelerators
+// ----------------------------------------------------------------------------
+
 // Find the letter corresponding to the mnemonic, for Motif
 char wxFindMnemonic (const char *s)
 {
@@ -869,12 +790,19 @@ XmString wxFindAcceleratorText (char *s)
     return text;
 }
 
+// ----------------------------------------------------------------------------
+// keycode translations
+// ----------------------------------------------------------------------------
+
 #include <X11/keysym.h>
 
+// FIXME what about tables??
+
 int wxCharCodeXToWX(KeySym keySym)
 {
     int id;
-    switch (keySym) {
+    switch (keySym)
+    {
         case XK_Shift_L:
         case XK_Shift_R:
             id = WXK_SHIFT; break;
@@ -1022,7 +950,8 @@ int wxCharCodeXToWX(KeySym keySym)
             id = WXK_F24; break;
         default:
             id = (keySym <= 255) ? (int)keySym : -1;
-  } // switch
+    }
+
     return id;
 }
 
@@ -1030,7 +959,8 @@ KeySym wxCharCodeWXToX(int id)
 {
     KeySym keySym;
 
-    switch (id) {
+    switch (id)
+    {
         case WXK_CANCEL:            keySym = XK_Cancel; break;
         case WXK_BACK:              keySym = XK_BackSpace; break;
         case WXK_TAB:            keySym = XK_Tab; break;
@@ -1098,43 +1028,14 @@ KeySym wxCharCodeWXToX(int id)
         case WXK_NUMLOCK:    keySym = XK_Num_Lock; break;
         case WXK_SCROLL:     keySym = XK_Scroll_Lock; break;
         default:             keySym = id <= 255 ? (KeySym)id : 0;
-    } // switch
+    }
+
     return keySym;
 }
 
-// Read $HOME for what it says is home, if not
+// ----------------------------------------------------------------------------
-// read $USER or $LOGNAME for user name else determine
+// Some colour manipulation routines
-// the Real User, then determine the Real home dir.
+// ----------------------------------------------------------------------------
-static char * GetIniFile (char *dest, const char *filename)
-{
-    char *home = NULL;
-    if (filename && wxIsAbsolutePath(filename))
-    {
-        strcpy(dest, filename);
-    }
-    else if ((home = wxGetUserHome("")) != NULL)
-    {
-        strcpy(dest, home);
-        if (dest[strlen(dest) - 1] != '/')
-            strcat (dest, "/");
-        if (filename == NULL)
-        {
-            if ((filename = getenv ("XENVIRONMENT")) == NULL)
-                filename = ".Xdefaults";
-        }
-        else if (*filename != '.')
-            strcat (dest, ".");
-        strcat (dest, filename);
-    } else
-    {
-        dest[0] = '\0';    
-    }
-    return dest;
-}
-
-/*
-* Some colour manipulation routines
-*/
 
 void wxHSVToXColor(wxHSV *hsv,XColor *rgb)
 {
@@ -1282,4 +1183,3 @@ void wxDoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, boo
         NULL);
 }
 
-

src/unix/threadpsx.cpp

@@ -0,0 +1,773 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        threadpsx.cpp
+// Purpose:     wxThread (Posix) Implementation
+// Author:      Original from Wolfram Gloger/Guilhem Lavaux
+// Modified by:
+// Created:     04/22/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Wolfram Gloger (1996, 1997)
+//                  Guilhem Lavaux (1998)
+//                  Vadim Zeitlin (1999)
+//                  Robert Roebling (1999)
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declaration
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "thread.h"
+#endif
+
+#include "wx/thread.h"
+
+#if !wxUSE_THREADS
+    #error This file needs wxUSE_THREADS
+#endif
+
+#include "wx/module.h"
+#include "wx/utils.h"
+#include "wx/log.h"
+#include "wx/intl.h"
+#include "wx/dynarray.h"
+
+#include <stdio.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <errno.h>
+#include <time.h>
+
+#ifdef HAVE_SCHED_H
+    #include <sched.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+enum thread_state
+{
+    STATE_NEW,          // didn't start execution yet (=> RUNNING)
+    STATE_RUNNING,
+    STATE_PAUSED,
+    STATE_CANCELED,
+    STATE_EXITED
+};
+
+WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+
+// -----------------------------------------------------------------------------
+// global data
+// -----------------------------------------------------------------------------
+
+// we keep the list of all threads created by the application to be able to
+// terminate them on exit if there are some left - otherwise the process would
+// be left in memory
+static wxArrayThread gs_allThreads;
+
+// the id of the main thread
+static pthread_t gs_tidMain;
+
+// the key for the pointer to the associated wxThread object
+static pthread_key_t gs_keySelf;
+
+// this mutex must be acquired before any call to a GUI function
+static wxMutex *gs_mutexGui;
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+//--------------------------------------------------------------------
+// wxMutex (Posix implementation)
+//--------------------------------------------------------------------
+
+class wxMutexInternal
+{
+public:
+    pthread_mutex_t p_mutex;
+};
+
+wxMutex::wxMutex()
+{
+    p_internal = new wxMutexInternal;
+    pthread_mutex_init( &(p_internal->p_mutex), (const pthread_mutexattr_t*) NULL );
+    m_locked = 0;
+}
+
+wxMutex::~wxMutex()
+{
+    if (m_locked > 0)
+        wxLogDebug("Freeing a locked mutex (%d locks)", m_locked);
+
+    pthread_mutex_destroy( &(p_internal->p_mutex) );
+    delete p_internal;
+}
+
+wxMutexError wxMutex::Lock()
+{
+    int err = pthread_mutex_lock( &(p_internal->p_mutex) );
+    if (err == EDEADLK)
+    {
+        wxLogDebug("Locking this mutex would lead to deadlock!");
+
+        return wxMUTEX_DEAD_LOCK;
+    }
+
+    m_locked++;
+
+    return wxMUTEX_NO_ERROR;
+}
+
+wxMutexError wxMutex::TryLock()
+{
+    if (m_locked)
+    {
+        return wxMUTEX_BUSY;
+    }
+
+    int err = pthread_mutex_trylock( &(p_internal->p_mutex) );
+    switch (err)
+    {
+        case EBUSY: return wxMUTEX_BUSY;
+    }
+
+    m_locked++;
+
+    return wxMUTEX_NO_ERROR;
+}
+
+wxMutexError wxMutex::Unlock()
+{
+    if (m_locked > 0)
+    {
+        m_locked--;
+    }
+    else
+    {
+        wxLogDebug("Unlocking not locked mutex.");
+
+        return wxMUTEX_UNLOCKED;
+    }
+
+    pthread_mutex_unlock( &(p_internal->p_mutex) );
+
+    return wxMUTEX_NO_ERROR;
+}
+
+//--------------------------------------------------------------------
+// wxCondition (Posix implementation)
+//--------------------------------------------------------------------
+
+class wxConditionInternal
+{
+public:
+  pthread_cond_t p_condition;
+};
+
+wxCondition::wxCondition()
+{
+    p_internal = new wxConditionInternal;
+    pthread_cond_init( &(p_internal->p_condition), (const pthread_condattr_t *) NULL );
+}
+
+wxCondition::~wxCondition()
+{
+    pthread_cond_destroy( &(p_internal->p_condition) );
+
+    delete p_internal;
+}
+
+void wxCondition::Wait(wxMutex& mutex)
+{
+    pthread_cond_wait( &(p_internal->p_condition), &(mutex.p_internal->p_mutex) );
+}
+
+bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec)
+{
+    struct timespec tspec;
+
+    tspec.tv_sec = time(0L)+sec;
+    tspec.tv_nsec = nsec;
+    return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
+}
+
+void wxCondition::Signal()
+{
+    pthread_cond_signal( &(p_internal->p_condition) );
+}
+
+void wxCondition::Broadcast()
+{
+    pthread_cond_broadcast( &(p_internal->p_condition) );
+}
+
+//--------------------------------------------------------------------
+// wxThread (Posix implementation)
+//--------------------------------------------------------------------
+
+class wxThreadInternal
+{
+public:
+    wxThreadInternal();
+    ~wxThreadInternal();
+
+    // thread entry function
+    static void *PthreadStart(void *ptr);
+
+    // thread actions
+        // start the thread
+    wxThreadError Run();
+        // ask the thread to terminate
+    void Cancel();
+        // wake up threads waiting for our termination
+    void SignalExit();
+        // go to sleep until Resume() is called
+    void Pause();
+        // resume the thread
+    void Resume();
+
+    // accessors
+        // priority
+    int GetPriority() const { return m_prio; }
+    void SetPriority(int prio) { m_prio = prio; }
+        // state
+    thread_state GetState() const { return m_state; }
+    void SetState(thread_state state) { m_state = state; }
+        // id
+    pthread_t GetId() const { return thread_id; }
+        // "cancelled" flag
+    bool WasCancelled() const { return m_cancelled; }
+
+//private: -- should be!
+    pthread_t thread_id;
+
+private:
+    thread_state m_state;    // see thread_state enum
+    int          m_prio;     // in wxWindows units: from 0 to 100
+
+    // set when the thread should terminate
+    bool m_cancelled;
+
+    // this (mutex, cond) pair is used to synchronize the main thread and this
+    // thread in several situations:
+    //  1. The thread function blocks until condition is signaled by Run() when
+    //     it's initially created - this allows create thread in "suspended"
+    //     state
+    //  2. The Delete() function blocks until the condition is signaled when the
+    //     thread exits.
+    wxMutex     m_mutex;
+    wxCondition m_cond;
+
+    // another (mutex, cond) pair for Pause()/Resume() usage
+    //
+    // VZ: it's possible that we might reuse the mutex and condition from above
+    //     for this too, but as I'm not at all sure that it won't create subtle
+    //     problems with race conditions between, say, Pause() and Delete() I
+    //     prefer this may be a bit less efficient but much safer solution
+    wxMutex     m_mutexSuspend;
+    wxCondition m_condSuspend;
+};
+
+void *wxThreadInternal::PthreadStart(void *ptr)
+{
+    wxThread *thread = (wxThread *)ptr;
+    wxThreadInternal *pthread = thread->p_internal;
+
+    if ( pthread_setspecific(gs_keySelf, thread) != 0 )
+    {
+        wxLogError(_("Can not start thread: error writing TLS."));
+
+        return (void *)-1;
+    }
+
+    // wait for the condition to be signaled from Run()
+    // mutex state: currently locked by the thread which created us
+    pthread->m_cond.Wait(pthread->m_mutex);
+
+    // mutex state: locked again on exit of Wait()
+
+    // call the main entry
+    void* status = thread->Entry();
+
+    // terminate the thread
+    thread->Exit(status);
+
+    wxFAIL_MSG("wxThread::Exit() can't return.");
+
+    return NULL;
+}
+
+wxThreadInternal::wxThreadInternal()
+{
+    m_state = STATE_NEW;
+    m_cancelled = FALSE;
+
+    // this mutex is locked during almost all thread lifetime - it will only be
+    // unlocked in the very end
+    m_mutex.Lock();
+
+    // this mutex is used in Pause()/Resume() and is also locked all the time
+    // unless the thread is paused
+    m_mutexSuspend.Lock();
+}
+
+wxThreadInternal::~wxThreadInternal()
+{
+    m_mutexSuspend.Unlock();
+
+    // note that m_mutex will be unlocked by the thread which waits for our
+    // termination
+}
+
+wxThreadError wxThreadInternal::Run()
+{
+    wxCHECK_MSG( GetState() == STATE_NEW, wxTHREAD_RUNNING,
+                 "thread may only be started once after successful Create()" );
+
+    // the mutex was locked on Create(), so we will be able to lock it again
+    // only when the thread really starts executing and enters the wait -
+    // otherwise we might signal the condition before anybody is waiting for it
+    wxMutexLocker lock(m_mutex);
+    m_cond.Signal();
+
+    m_state = STATE_RUNNING;
+
+    return wxTHREAD_NO_ERROR;
+
+    // now the mutex is unlocked back - but just to allow Wait() function to
+    // terminate by relocking it, so the net result is that the worker thread
+    // starts executing and the mutex is still locked
+}
+
+void wxThreadInternal::Cancel()
+{
+    // if the thread we're waiting for is waiting for the GUI mutex, we will
+    // deadlock so make sure we release it temporarily
+    if ( wxThread::IsMain() )
+        wxMutexGuiLeave();
+
+    // nobody ever writes this variable so it's safe to not use any
+    // synchronization here
+    m_cancelled = TRUE;
+
+    // entering Wait() releases the mutex thus allowing SignalExit() to acquire
+    // it and to signal us its termination
+    m_cond.Wait(m_mutex);
+
+    // mutex is still in the locked state - relocked on exit from Wait(), so
+    // unlock it - we don't need it any more, the thread has already terminated
+    m_mutex.Unlock();
+
+    // reacquire GUI mutex
+    if ( wxThread::IsMain() )
+        wxMutexGuiEnter();
+}
+
+void wxThreadInternal::SignalExit()
+{
+    // as mutex is currently locked, this will block until some other thread
+    // (normally the same which created this one) unlocks it by entering Wait()
+    m_mutex.Lock();
+
+    // wake up all the threads waiting for our termination
+    m_cond.Broadcast();
+
+    // after this call mutex will be finally unlocked
+    m_mutex.Unlock();
+}
+
+void wxThreadInternal::Pause()
+{
+    wxCHECK_RET( m_state == STATE_PAUSED,
+                 "thread must first be paused with wxThread::Pause()." );
+
+    // wait until the condition is signaled from Resume()
+    m_condSuspend.Wait(m_mutexSuspend);
+}
+
+void wxThreadInternal::Resume()
+{
+    wxCHECK_RET( m_state == STATE_PAUSED,
+                 "can't resume thread which is not suspended." );
+
+    // we will be able to lock this mutex only when Pause() starts waiting
+    wxMutexLocker lock(m_mutexSuspend);
+    m_condSuspend.Signal();
+
+    SetState(STATE_RUNNING);
+}
+
+// -----------------------------------------------------------------------------
+// static functions
+// -----------------------------------------------------------------------------
+
+wxThread *wxThread::This()
+{
+    return (wxThread *)pthread_getspecific(gs_keySelf);
+}
+
+bool wxThread::IsMain()
+{
+    return (bool)pthread_equal(pthread_self(), gs_tidMain);
+}
+
+void wxThread::Yield()
+{
+    sched_yield();
+}
+
+void wxThread::Sleep(unsigned long milliseconds)
+{
+    wxUsleep(milliseconds);
+}
+
+// -----------------------------------------------------------------------------
+// creating thread
+// -----------------------------------------------------------------------------
+
+wxThread::wxThread()
+{
+    // add this thread to the global list of all threads
+    gs_allThreads.Add(this);
+
+    p_internal = new wxThreadInternal();
+}
+
+wxThreadError wxThread::Create()
+{
+    if (p_internal->GetState() != STATE_NEW)
+        return wxTHREAD_RUNNING;
+
+    // set up the thread attribute: right now, we only set thread priority
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+
+    int prio;
+    if ( pthread_attr_getschedpolicy(&attr, &prio) != 0 )
+    {
+        wxLogError(_("Can not retrieve thread scheduling policy."));
+    }
+
+    int min_prio = sched_get_priority_min(prio),
+        max_prio = sched_get_priority_max(prio);
+
+    if ( min_prio == -1 || max_prio == -1 )
+    {
+        wxLogError(_("Can not get priority range for scheduling policy %d."),
+                   prio);
+    }
+    else
+    {
+        struct sched_param sp;
+        pthread_attr_getschedparam(&attr, &sp);
+        sp.sched_priority = min_prio +
+                           (p_internal->GetPriority()*(max_prio-min_prio))/100;
+        pthread_attr_setschedparam(&attr, &sp);
+    }
+
+    // create the new OS thread object
+    int rc = pthread_create(&p_internal->thread_id, &attr,
+                            wxThreadInternal::PthreadStart, (void *)this);
+    pthread_attr_destroy(&attr);
+
+    if ( rc != 0 )
+    {
+        p_internal->SetState(STATE_EXITED);
+        return wxTHREAD_NO_RESOURCE;
+    }
+
+    return wxTHREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Run()
+{
+    return p_internal->Run();
+}
+
+// -----------------------------------------------------------------------------
+// misc accessors
+// -----------------------------------------------------------------------------
+
+void wxThread::SetPriority(unsigned int prio)
+{
+    wxCHECK_RET( (WXTHREAD_MIN_PRIORITY <= prio) &&
+                 (prio <= WXTHREAD_MAX_PRIORITY), "invalid thread priority" );
+
+    wxCriticalSectionLocker lock(m_critsect);
+
+    switch ( p_internal->GetState() )
+    {
+        case STATE_NEW:
+            // thread not yet started, priority will be set when it is
+            p_internal->SetPriority(prio);
+            break;
+
+        case STATE_RUNNING:
+        case STATE_PAUSED:
+            {
+                struct sched_param sparam;
+                sparam.sched_priority = prio;
+
+                if ( pthread_setschedparam(p_internal->GetId(),
+                                           SCHED_OTHER, &sparam) != 0 )
+                {
+                    wxLogError(_("Failed to set thread priority %d."), prio);
+                }
+            }
+            break;
+
+        case STATE_EXITED:
+        default:
+            wxFAIL_MSG("impossible to set thread priority in this state");
+    }
+}
+
+unsigned int wxThread::GetPriority() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
+
+    return p_internal->GetPriority();
+}
+
+unsigned long wxThread::GetID() const
+{
+    return (unsigned long)p_internal->thread_id;
+}
+
+// -----------------------------------------------------------------------------
+// pause/resume
+// -----------------------------------------------------------------------------
+
+wxThreadError wxThread::Pause()
+{
+    wxCriticalSectionLocker lock(m_critsect);
+
+    if ( p_internal->GetState() != STATE_RUNNING )
+    {
+        wxLogDebug("Can't pause thread which is not running.");
+
+        return wxTHREAD_NOT_RUNNING;
+    }
+
+    p_internal->SetState(STATE_PAUSED);
+
+    return wxTHREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+    wxCriticalSectionLocker lock(m_critsect);
+
+    if ( p_internal->GetState() == STATE_PAUSED )
+    {
+        p_internal->Resume();
+
+        return wxTHREAD_NO_ERROR;
+    }
+    else
+    {
+        wxLogDebug("Attempt to resume a thread which is not paused.");
+
+        return wxTHREAD_MISC_ERROR;
+    }
+}
+
+// -----------------------------------------------------------------------------
+// exiting thread
+// -----------------------------------------------------------------------------
+
+wxThread::ExitCode wxThread::Delete()
+{
+    m_critsect.Enter();
+    thread_state state = p_internal->GetState();
+    m_critsect.Leave();
+
+    switch ( state )
+    {
+        case STATE_NEW:
+        case STATE_EXITED:
+            // nothing to do
+            break;
+
+        case STATE_PAUSED:
+            // resume the thread first
+            Resume();
+
+            // fall through
+
+        default:
+            // set the flag telling to the thread to stop and wait
+            p_internal->Cancel();
+    }
+
+    return NULL;
+}
+
+wxThreadError wxThread::Kill()
+{
+    switch ( p_internal->GetState() )
+    {
+        case STATE_NEW:
+        case STATE_EXITED:
+            return wxTHREAD_NOT_RUNNING;
+
+        default:
+            if ( pthread_cancel(p_internal->GetId()) != 0 )
+            {
+                wxLogError(_("Failed to terminate a thread."));
+
+                return wxTHREAD_MISC_ERROR;
+            }
+
+            return wxTHREAD_NO_ERROR;
+    }
+}
+
+void wxThread::Exit(void *status)
+{
+    // first call user-level clean up code
+    OnExit();
+
+    // next wake up the threads waiting for us (OTOH, this function won't return
+    // until someone waited for us!)
+    p_internal->SignalExit();
+
+    p_internal->SetState(STATE_EXITED);
+
+    // delete both C++ thread object and terminate the OS thread object
+    delete this;
+    pthread_exit(status);
+}
+
+// also test whether we were paused
+bool wxThread::TestDestroy()
+{
+    wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+    if ( p_internal->GetState() == STATE_PAUSED )
+    {
+        // leave the crit section or the other threads will stop too if they try
+        // to call any of (seemingly harmless) IsXXX() functions while we sleep
+        m_critsect.Leave();
+
+        p_internal->Pause();
+
+        // enter it back before it's finally left in lock object dtor
+        m_critsect.Enter();
+    }
+
+    return p_internal->WasCancelled();
+}
+
+wxThread::~wxThread()
+{
+    // remove this thread from the global array
+    gs_allThreads.Remove(this);
+}
+
+// -----------------------------------------------------------------------------
+// state tests
+// -----------------------------------------------------------------------------
+
+bool wxThread::IsRunning() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
+
+    return p_internal->GetState() == STATE_RUNNING;
+}
+
+bool wxThread::IsAlive() const
+{
+    wxCriticalSectionLocker lock((wxCriticalSection&)m_critsect);
+
+    switch ( p_internal->GetState() )
+    {
+        case STATE_RUNNING:
+        case STATE_PAUSED:
+            return TRUE;
+
+        default:
+            return FALSE;
+    }
+}
+
+//--------------------------------------------------------------------
+// wxThreadModule
+//--------------------------------------------------------------------
+
+class wxThreadModule : public wxModule
+{
+public:
+    virtual bool OnInit();
+    virtual void OnExit();
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxThreadModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
+
+bool wxThreadModule::OnInit()
+{
+    if ( pthread_key_create(&gs_keySelf, NULL /* dtor function */) != 0 )
+    {
+        wxLogError(_("Thread module initialization failed: "
+                     "failed to create pthread key."));
+
+        return FALSE;
+    }
+
+    gs_mutexGui = new wxMutex();
+
+    //wxThreadGuiInit();
+
+    gs_tidMain = pthread_self();
+    gs_mutexGui->Lock();
+
+    return TRUE;
+}
+
+void wxThreadModule::OnExit()
+{
+    wxASSERT_MSG( wxThread::IsMain(), "only main thread can be here" );
+
+    // terminate any threads left
+    size_t count = gs_allThreads.GetCount();
+    if ( count != 0u )
+        wxLogDebug("Some threads were not terminated by the application.");
+
+    for ( size_t n = 0u; n < count; n++ )
+    {
+        gs_allThreads[n]->Delete();
+    }
+
+    // destroy GUI mutex
+    gs_mutexGui->Unlock();
+
+    //wxThreadGuiExit();
+
+    delete gs_mutexGui;
+
+    // and free TLD slot
+    (void)pthread_key_delete(gs_keySelf);
+}
+
+// ----------------------------------------------------------------------------
+// global functions
+// ----------------------------------------------------------------------------
+
+void wxMutexGuiEnter()
+{
+  gs_mutexGui->Lock();
+}
+
+void wxMutexGuiLeave()
+{
+  gs_mutexGui->Unlock();
+}

src/unix/utilsunx.cpp

@@ -0,0 +1,439 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        utilsunx.cpp
+// Purpose:     generic Unix implementation of many wx functions
+// Author:      Vadim Zeitlin
+// Id:          $Id$
+// Copyright:   (c) 1998 Robert Roebling, Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/defs.h"
+#include "wx/string.h"
+
+#include "wx/intl.h"
+#include "wx/log.h"
+
+#include "wx/utils.h"
+#include "wx/process.h"
+
+#include "wx/unix/execute.h"
+
+#include <stdarg.h>
+#include <dirent.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <pwd.h>
+#include <errno.h>
+#include <netdb.h>
+#include <signal.h>
+#include <fcntl.h>          // for O_WRONLY and friends
+#include <time.h>           // nanosleep() and/or usleep()
+
+#ifdef HAVE_UNAME
+    #include <sys/utsname.h> // for uname()
+#endif // HAVE_UNAME
+
+// ----------------------------------------------------------------------------
+// conditional compilation
+// ----------------------------------------------------------------------------
+
+// many versions of Unices have this function, but it is not defined in system
+// headers - please add your system here if it is the case for your OS.
+// SunOS < 5.6 (i.e. Solaris < 2.6) and DG-UX are like this.
+#if (defined(__SUN__) && !defined(__SunOs_5_6) && \
+                         !defined(__SunOs_5_7) && !defined(__SUNPRO_CC)) || \
+     defined(__osf__)
+    extern "C"
+    {
+        void usleep(unsigned long usec);
+    };
+#endif // Unices without usleep()
+
+// many versions of Unices have this function, but it is not defined in system
+// headers - please add your system here if it is the case for your OS.
+// SunOS (and Solaris) and DG-UX are like this.
+#if defined(__SOLARIS__) || defined(__osf__)
+    extern "C"
+    {
+        pid_t wait4(pid_t pid, int *statusp, int options,
+                    struct rusage *rusage);
+    }
+
+    #define wxWait4(pid, stat, flags, rusage) wait4(pid, stat, flags, rusage)
+#elif defined(__sgi) || defined(__HPUX__)
+    // no wait4() at all on these systems
+    // TODO verify whether wait3() really works in this situation
+    #define wxWait4(pid, stat, flags, rusage) wait3(stat, flags, rusage)
+#else
+    // other Unices: assume have wait4(), although it's not standard (but
+    // Linux and FreeBSD do have it)
+    #define wxWait4(pid, stat, flags, rusage) wait4(pid, stat, flags, rusage)
+#endif // wait4()
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// sleeping
+// ----------------------------------------------------------------------------
+
+void wxSleep(int nSecs)
+{
+    sleep(nSecs);
+}
+
+void wxUsleep(unsigned long milliseconds)
+{
+#if defined(HAVE_NANOSLEEP)
+    timespec tmReq;
+    tmReq.tv_sec = milliseconds / 1000;
+    tmReq.tv_nsec = (milliseconds % 1000) * 1000 * 1000;
+
+    // we're not interested in remaining time nor in return value
+    (void)nanosleep(&tmReq, (timespec *)NULL);
+#elif defined(HAVE_USLEEP)
+    // uncomment this if you feel brave or if you are sure that your version
+    // of Solaris has a safe usleep() function but please notice that usleep()
+    // is known to lead to crashes in MT programs in Solaris 2.[67] and is not
+    // documented as MT-Safe
+    #if defined(__SUN__) && defined(wxUSE_THREADS)
+        #error "usleep() cannot be used in MT programs under Solaris."
+    #endif // Sun
+
+    usleep(milliseconds * 1000); // usleep(3) wants microseconds
+#else // !sleep function
+    #error "usleep() or nanosleep() function required for wxUsleep"
+#endif // sleep function
+}
+
+// ----------------------------------------------------------------------------
+// process management
+// ----------------------------------------------------------------------------
+
+int wxKill(long pid, int sig)
+{
+    return kill(pid, sig);
+}
+
+long wxExecute( const wxString& command, bool sync, wxProcess *process )
+{
+    static const char *IFS = " \t\n";
+
+    wxCHECK_MSG( !command.IsEmpty(), 0, "can't exec empty command" );
+
+    int argc = 0;
+    char *argv[127];
+    char *tmp = new char[command.Len() + 1];
+    strcpy(tmp, command);
+
+    argv[argc++] = strtok(tmp, IFS);
+    while ((argv[argc++] = strtok((char *) NULL, IFS)) != NULL)
+        /* loop */ ;
+
+    long lRc = wxExecute(argv, sync, process);
+
+    delete [] tmp;
+
+    return lRc;
+}
+
+bool wxShell(const wxString& command)
+{
+    wxString cmd;
+    if ( !!command )
+        cmd.Printf("xterm -e %s", command.c_str());
+    else
+        cmd = command;
+
+    return wxExecute(cmd) != 0;
+}
+
+void wxHandleProcessTermination(wxEndProcessData *proc_data)
+{
+    int pid = (proc_data->pid > 0) ? proc_data->pid : -(proc_data->pid);
+
+    int status = 0;
+    wxWait4(pid, &status, 0, (rusage *) NULL);
+
+    if (proc_data->process)
+        proc_data->process->OnTerminate(proc_data->pid, status);
+
+    if (proc_data->pid > 0)
+    {
+        delete proc_data;
+    }
+    else
+    {
+        // wxExecute() will know about it
+        proc_data->exitcode = status;
+
+        proc_data->pid = 0;
+    }
+}
+
+long wxExecute( char **argv, bool sync, wxProcess *process )
+{
+    wxCHECK_MSG( *argv, 0, "can't exec empty command" );
+
+    int end_proc_detect[2];
+
+    // create pipes
+    if (pipe(end_proc_detect) == -1)
+    {
+        wxLogSysError( _("Pipe creation failed") );
+        return 0;
+    }
+
+    // fork the process
+#ifdef HAVE_VFORK
+    pid_t pid = vfork();
+#else
+    pid_t pid = fork();
+#endif
+    if (pid == -1)
+    {
+        wxLogSysError( _("Fork failed") );
+        return 0;
+    }
+    else if (pid == 0)
+    {
+        // we're in child
+        close(end_proc_detect[0]); // close reading side
+
+        // These three lines close the open file descriptors to to avoid any
+        // input/output which might block the process or irritate the user. If
+        // one wants proper IO for the subprocess, the "right thing to do is
+        // to start an xterm executing it.
+        if (sync == 0)
+        {
+            // leave stderr opened, it won't do any hurm
+            for ( int fd = 0; fd < FD_SETSIZE; fd++ )
+            {
+                if ( fd != end_proc_detect[1] && fd != STDERR_FILENO )
+                    close(fd);
+            }
+        }
+
+#if 0
+        close(STDERR_FILENO);
+
+        // some programs complain about stderr not being open, so redirect
+        // them:
+        open("/dev/null", O_RDONLY);  // stdin
+        open("/dev/null", O_WRONLY);  // stdout
+        open("/dev/null", O_WRONLY);  // stderr
+#endif
+
+#ifdef _AIX
+        execvp ((const char *)*argv, (const char **)argv);
+#else
+        execvp (*argv, argv);
+#endif
+
+        // there is no return after successful exec()
+        fprintf(stderr, _("Can't execute '%s'\n"), *argv);
+
+        _exit(-1);
+    }
+    else
+    {
+        // we're in parent
+        close(end_proc_detect[1]); // close writing side
+
+        wxEndProcessData *data = new wxEndProcessData;
+        data->tag = wxAddProcessCallback(data, end_proc_detect[0]);
+
+        if ( sync )
+        {
+            wxASSERT_MSG( !process, "wxProcess param ignored for sync exec" );
+            data->process = NULL;
+
+            // sync execution: indicate it by negating the pid
+            data->pid = -pid;
+
+            // it will be set to 0 from GTK_EndProcessDetector
+            while (data->pid != 0)
+                wxYield();
+
+            int exitcode = data->exitcode;
+
+            delete data;
+
+            return exitcode;
+        }
+        else
+        {
+            // async execution, nothing special to do - caller will be
+            // notified about the process terminationif process != NULL, data
+            // will be deleted in GTK_EndProcessDetector
+            data->process = process;
+            data->pid = pid;
+
+            return pid;
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+// file and directory functions
+// ----------------------------------------------------------------------------
+
+const char* wxGetHomeDir( wxString *home  )
+{
+    *home = wxGetUserHome( wxString() );
+    if ( home->IsEmpty() )
+        *home = "/";
+
+    return home->c_str();
+}
+
+char *wxGetUserHome( const wxString &user )
+{
+    struct passwd *who = (struct passwd *) NULL;
+
+    if (user.IsNull() || (user== ""))
+    {
+        register char *ptr;
+
+        if ((ptr = getenv("HOME")) != NULL)
+        {
+            return ptr;
+        }
+        if ((ptr = getenv("USER")) != NULL || (ptr = getenv("LOGNAME")) != NULL)
+        {
+            who = getpwnam(ptr);
+        }
+
+        // We now make sure the the user exists!
+        if (who == NULL)
+        {
+            who = getpwuid(getuid());
+        }
+    }
+    else
+    {
+      who = getpwnam (user);
+    }
+
+    return who ? who->pw_dir : (char*)NULL;
+}
+
+// ----------------------------------------------------------------------------
+// id routines
+// ----------------------------------------------------------------------------
+
+bool wxGetHostName(char *buf, int sz)
+{
+    wxCHECK_MSG( buf, FALSE, "NULL pointer in wxGetHostName" );
+
+    *buf = '\0';
+
+    // we're using uname() which is POSIX instead of less standard sysinfo()
+#if defined(HAVE_UNAME)
+    utsname uts;
+    bool ok = uname(&uts) != -1;
+    if ( ok )
+    {
+        strncpy(buf, uts.nodename, sz - 1);
+        buf[sz] = '\0';
+    }
+#elif defined(HAVE_GETHOSTNAME)
+    bool ok = gethostname(buf, sz) != -1;
+#else
+    wxFAIL_MSG("don't know host name for this machibe");
+
+    bool ok = FALSE;
+#endif
+
+    if ( !ok )
+    {
+        wxLogSysError(_("Cannot get the hostname"));
+    }
+
+    return ok;
+}
+
+bool wxGetUserId(char *buf, int sz)
+{
+    struct passwd *who;
+
+    *buf = '\0';
+    if ((who = getpwuid(getuid ())) != NULL)
+    {
+        strncpy (buf, who->pw_name, sz - 1);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+bool wxGetUserName(char *buf, int sz)
+{
+    struct passwd *who;
+    char *comma;
+
+    *buf = '\0';
+    if ((who = getpwuid (getuid ())) != NULL) {
+       comma = strchr(who->pw_gecos, ',');
+       if (comma)
+           *comma = '\0'; // cut off non-name comment fields
+       strncpy (buf, who->pw_gecos, sz - 1);
+       return TRUE;
+    }
+
+    return FALSE;
+}
+
+// ----------------------------------------------------------------------------
+// error and debug output routines (deprecated, use wxLog)
+// ----------------------------------------------------------------------------
+
+void wxDebugMsg( const char *format, ... )
+{
+  va_list ap;
+  va_start( ap, format );
+  vfprintf( stderr, format, ap );
+  fflush( stderr );
+  va_end(ap);
+}
+
+void wxError( const wxString &msg, const wxString &title )
+{
+  fprintf( stderr, _("Error ") );
+  if (!title.IsNull()) fprintf( stderr, "%s ", WXSTRINGCAST(title) );
+  if (!msg.IsNull()) fprintf( stderr, ": %s", WXSTRINGCAST(msg) );
+  fprintf( stderr, ".\n" );
+}
+
+void wxFatalError( const wxString &msg, const wxString &title )
+{
+  fprintf( stderr, _("Error ") );
+  if (!title.IsNull()) fprintf( stderr, "%s ", WXSTRINGCAST(title) );
+  if (!msg.IsNull()) fprintf( stderr, ": %s", WXSTRINGCAST(msg) );
+  fprintf( stderr, ".\n" );
+  exit(3); // the same exit code as for abort()
+}
+
+//------------------------------------------------------------------------
+// directory routines
+//------------------------------------------------------------------------
+
+bool wxDirExists( const wxString& dir )
+{
+    char buf[500];
+    strcpy( buf, WXSTRINGCAST(dir) );
+    struct stat sbuf;
+    return ((stat(buf, &sbuf) != -1) && S_ISDIR(sbuf.st_mode) ? TRUE : FALSE);
+}