Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
Vadim Zeitlin
1999-03-06 00:11:27 +00:00
parent cf6c13a14f
commit 518b5d2ffb
15 changed files with 2152 additions and 1621 deletions
Download Patch File Download Diff File Expand all files Collapse all files

511
configure vendored
View File

File diff suppressed because it is too large Load Diff

37
configure.in
View File

@@ -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,
AC_DEFINE(HAVE_NANOSLEEP),
[AC_CHECK_LIB(posix4, nanosleep, AC_DEFINE(HAVE_NANOSLEEP))])
AC_CHECK_FUNCS(usleep)
dnl AC_CHECK_FUNCS(nanosleep, AC_DEFINE(HAVE_NANOSLEEP),
dnl [
dnl AC_CHECK_LIB(posix4, nanosleep,
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

2
include/wx/thread.h
View File

@@ -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() { }

32
include/wx/unix/execute.h Normal file
View File

@@ -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

10
setup/setup.hin
View File

@@ -380,8 +380,14 @@
/* Define if you have nanosleep() */
#undef HAVE_NANOSLEEP
/* Define if you have usleep() */
#undef HAVE_USLEEP
/* Define if you have vfork() */
#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

23
src/common/utilscmn.cpp
View File

@@ -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;
}

2
src/gtk.inc
View File

@@ -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 \

9
src/gtk/threadno.cpp
View File

@@ -8,8 +8,9 @@
// Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "thread.h"
#pragma implementation "thread.h"
#endif
#include "wx/wx.h"
@@ -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()

388
src/gtk/utilsgtk.cpp
View File

@@ -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)
{
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);
}
// ----------------------------------------------------------------------------
// display characterstics
// ----------------------------------------------------------------------------
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);
int status = 0;
wxWait4(pid, &status, 0, (rusage *) NULL);
wxHandleProcessTermination(proc_data);
close(source);
gdk_input_remove(proc_data->tag);
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 )
int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
{
wxEndProcessData *data = new wxEndProcessData;
int end_proc_detect[2];
int tag = gdk_input_add(fd,
GDK_INPUT_READ,
GTK_EndProcessDetector,
(gpointer)proc_data);
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;
}
}
return tag;
}
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;
}

9
src/gtk1/threadno.cpp
View File

@@ -8,8 +8,9 @@
// Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "thread.h"
#pragma implementation "thread.h"
#endif
#include "wx/wx.h"
@@ -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()

388
src/gtk1/utilsgtk.cpp
View File

@@ -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)
{
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);
}
// ----------------------------------------------------------------------------
// display characterstics
// ----------------------------------------------------------------------------
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);
int status = 0;
wxWait4(pid, &status, 0, (rusage *) NULL);
wxHandleProcessTermination(proc_data);
close(source);
gdk_input_remove(proc_data->tag);
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 )
int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
{
wxEndProcessData *data = new wxEndProcessData;
int end_proc_detect[2];
int tag = gdk_input_add(fd,
GDK_INPUT_READ,
GTK_EndProcessDetector,
(gpointer)proc_data);
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;
}
}
return tag;
}
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;
}

6
src/motif/app.cpp
View File

@@ -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;
}

406
src/motif/utils.cpp
View File

@@ -9,11 +9,13 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
// Note: this is done in utilscmn.cpp now.
// #pragma implementation
// #pragma implementation "utils.h"
#endif
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/setup.h"
#include "wx/utils.h"
@@ -34,137 +36,37 @@
#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>
#include <sysent.h>
#endif
#include <Xm/Xm.h>
#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
# define DEFAULT_XRESOURCE_DIR "/usr/openwin/lib/app-defaults"
#define DEFAULT_XRESOURCE_DIR "/usr/openwin/lib/app-defaults"
#else
# define DEFAULT_XRESOURCE_DIR "/usr/lib/X11/app-defaults"
#define DEFAULT_XRESOURCE_DIR "/usr/lib/X11/app-defaults"
#endif
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)
{
#if defined(__SOLARIS__) || defined(__SVR4__) && !defined(__HPUX__)
return (sysinfo (SI_HOSTNAME, buf, maxSize) != -1);
#else /* BSD Sockets */
char name[255];
struct hostent *h;
// ============================================================================
// implementation
// ============================================================================
// Get hostname
if (gethostname (name, sizeof (name) / sizeof (char) - 1) == -1)
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);
}
// ----------------------------------------------------------------------------
// async event processing
// ----------------------------------------------------------------------------
// Consume all events until no more left
void wxFlushEvents()
@@ -184,36 +86,70 @@ void wxFlushEvents()
}
}
// Output a debug message, in a system dependent fashion.
void wxDebugMsg(const char *fmt ...)
// Check whether this window wants to process messages, e.g. Stop button
// in long calculations.
bool wxCheckForInterrupt(wxWindow *wnd)
{
va_list ap;
char buffer[BUFSIZ];
wxCHECK_MSG( wnd, FALSE, "NULL window in wxCheckForInterrupt" );
if (!wxTheApp->GetWantDebugOutput())
return ;
Display *dpy=(Display*) wnd->GetXDisplay();
Window win=(Window) wnd->GetXWindow();
XEvent event;
XFlush(dpy);
if (wnd->GetMainWidget())
{
XmUpdateDisplay((Widget)(wnd->GetMainWidget()));
}
va_start (ap, fmt);
bool hadEvents = FALSE;
while( XCheckMaskEvent(dpy,
ButtonPressMask|ButtonReleaseMask|ButtonMotionMask|
PointerMotionMask|KeyPressMask|KeyReleaseMask,
&event) )
{
if ( event.xany.window == win )
{
hadEvents = TRUE;
vsprintf (buffer, fmt, ap);
cerr << buffer;
XtDispatchEvent(&event);
}
}
va_end (ap);
return hadEvents;
}
// Non-fatal error: pop up message box and (possibly) continue
void wxError(const wxString& msg, const wxString& title)
// ----------------------------------------------------------------------------
// wxExecute stuff
// ----------------------------------------------------------------------------
static void xt_notify_end_process(XtPointer client, int *fid,
XtInputId *id)
{
cerr << (const char*) title << ": " << (const char*) msg << "\n";
wxEndProcessData *proc_data = (wxEndProcessData *)data;
wxHandleProcessTermination(proc_data);
// VZ: I think they should be the same...
wxASSERT( (int)*id == proc_data->tag );
XtRemoveInput(*id);
}
// Fatal error: pop up message box and abort
void wxFatalError(const wxString& msg, const wxString& title)
int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
{
cerr << (const char*) title << ": " << (const char*) msg << "\n";
exit (1);
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 )
{
*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?
}
}
// ----------------------------------------------------------------------------
// display info
// ----------------------------------------------------------------------------
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();
if (DefaultDepth (dpy, DefaultScreen (dpy)) < 2)
return FALSE;
else
return TRUE;
return wxDisplayDepth() > 1;
}
// 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
@@ -761,19 +675,22 @@ bool wxSetDisplay(const wxString& display_name)
(const char*) wxTheApp->GetAppName(),
(const char*) wxTheApp->GetClassName(),
NULL,
# if XtSpecificationRelease < 5
0, &argc, NULL);
# else
0, (int *)&argc, NULL);
# endif
#if XtSpecificationRelease < 5
0, &argc,
#else
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
// 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
*/
// ----------------------------------------------------------------------------
// Some colour manipulation routines
// ----------------------------------------------------------------------------
void wxHSVToXColor(wxHSV *hsv,XColor *rgb)
{
@@ -1282,4 +1183,3 @@ void wxDoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, boo
NULL);
}

773
src/unix/threadpsx.cpp Normal file
View File

@@ -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();
}

439
src/unix/utilsunx.cpp Normal file
View File

@@ -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);
}