Add support for bilinear resize algorithm to wxImage.

[wxWidgets.git] / src / unix / snglinst.cpp

diff --git a/src/unix/snglinst.cpp b/src/unix/snglinst.cpp
index f3c5b3e6819321845e8cf0cafd58f79ac29d4ebc..43674249af60d0c3fdb10864a3dbdf7f5a9c6f2d 100644 (file)
--- a/src/unix/snglinst.cpp
+++ b/src/unix/snglinst.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        unix/snglinst.cpp
+// Name:        src/unix/snglinst.cpp

 // Purpose:     implements wxSingleInstanceChecker class for Unix using
 //              lock files with fcntl(2) or flock(2)
 // Author:      Vadim Zeitlin
 // Purpose:     implements wxSingleInstanceChecker class for Unix using
 //              lock files with fcntl(2) or flock(2)
 // Author:      Vadim Zeitlin


@@ -18,10 +18,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "snglinst.h"
-#endif
-

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


@@ -35,10 +31,10 @@
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"

+    #include "wx/utils.h"           // wxGetHomeDir()

 #endif //WX_PRECOMP
 
 #include "wx/file.h"
 #endif //WX_PRECOMP
 
 #include "wx/file.h"

-#include "wx/utils.h"           // wxGetHomeDir()

 
 #include "wx/snglinst.h"
 
 
 #include "wx/snglinst.h"
 


@@ -89,9 +85,9 @@ static int wxLockFile(int fd, LockOperation lock)
     fl.l_type = lock == LOCK ? F_WRLCK : F_UNLCK;
 
     // lock the entire file
     fl.l_type = lock == LOCK ? F_WRLCK : F_UNLCK;
 
     // lock the entire file

-    fl.l_whence =

     fl.l_start =
     fl.l_start =

-    fl.l_len = 0;
+    fl.l_len =
+    fl.l_whence = 0;

 
     // is this needed?
     fl.l_pid = getpid();
 
     // is this needed?
     fl.l_pid = getpid();


@@ -187,7 +183,7 @@ LockResult wxSingleInstanceCheckerImpl::CreateLockFile()
                               m_nameLock.c_str());
 
                 Unlock();
                               m_nameLock.c_str());
 
                 Unlock();

-                
+

                 return LOCK_ERROR;
             }
 
                 return LOCK_ERROR;
             }
 


@@ -230,28 +226,28 @@ bool wxSingleInstanceCheckerImpl::Create(const wxString& name)
 
         case LOCK_CREATED:
             // nothing more to do
 
         case LOCK_CREATED:
             // nothing more to do

-            return TRUE;
+            return true;

 
         case LOCK_ERROR:
             // oops...
 
         case LOCK_ERROR:
             // oops...

-            return FALSE;
+            return false;

     }
 
     // Check if the file is owned by current user and has 0600 permissions.
     // If it doesn't, it's a fake file, possibly meant as a DoS attack, and
     // so we refuse to touch it:
     }
 
     // Check if the file is owned by current user and has 0600 permissions.
     // If it doesn't, it's a fake file, possibly meant as a DoS attack, and
     // so we refuse to touch it:

-    wxStructStat stat;
-    if ( wxStat(name, &stat) != 0 )
+    wxStructStat stats;
+    if ( wxStat(name, &stats) != 0 )

     {
         wxLogSysError(_("Failed to inspect the lock file '%s'"), name.c_str());
         return false;
     }
     {
         wxLogSysError(_("Failed to inspect the lock file '%s'"), name.c_str());
         return false;
     }

-    if ( stat.st_uid != getuid() )
+    if ( stats.st_uid != getuid() )

     {
         wxLogError(_("Lock file '%s' has incorrect owner."), name.c_str());
         return false;
     }
     {
         wxLogError(_("Lock file '%s' has incorrect owner."), name.c_str());
         return false;
     }

-    if ( stat.st_mode != (S_IFREG | S_IRUSR | S_IWUSR) )
+    if ( stats.st_mode != (S_IFREG | S_IRUSR | S_IWUSR) )

     {
         wxLogError(_("Lock file '%s' has incorrect permissions."), name.c_str());
         return false;
     {
         wxLogError(_("Lock file '%s' has incorrect permissions."), name.c_str());
         return false;


@@ -273,11 +269,11 @@ bool wxSingleInstanceCheckerImpl::Create(const wxString& name)
         // rarely in practice that we don't care
         wxLogError(_("Failed to access lock file."));
 
         // rarely in practice that we don't care
         wxLogError(_("Failed to access lock file."));
 

-        return FALSE;
+        return false;

     }
 
     char buf[256];
     }
 
     char buf[256];

-    off_t count = file.Read(buf, WXSIZEOF(buf));
+    ssize_t count = file.Read(buf, WXSIZEOF(buf));

     if ( count == wxInvalidOffset )
     {
         wxLogError(_("Failed to read PID from lock file."));
     if ( count == wxInvalidOffset )
     {
         wxLogError(_("Failed to read PID from lock file."));


@@ -293,7 +289,7 @@ bool wxSingleInstanceCheckerImpl::Create(const wxString& name)
                     wxLogError(_("Failed to remove stale lock file '%s'."),
                                name.c_str());
 
                     wxLogError(_("Failed to remove stale lock file '%s'."),
                                name.c_str());
 

-                    // return TRUE in this case for now...
+                    // return true in this case for now...

                 }
                 else
                 {
                 }
                 else
                 {


@@ -312,7 +308,7 @@ bool wxSingleInstanceCheckerImpl::Create(const wxString& name)
         }
     }
 
         }
     }
 

-    // return TRUE if we could get the PID of the process owning the lock file
+    // return true if we could get the PID of the process owning the lock file

     // (whether it is still running or not), FALSE otherwise as it is
     // unexpected
     return m_pidLocker != 0;
     // (whether it is still running or not), FALSE otherwise as it is
     // unexpected
     return m_pidLocker != 0;


@@ -352,10 +348,10 @@ bool wxSingleInstanceChecker::Create(const wxString& name,
                                      const wxString& path)
 {
     wxASSERT_MSG( !m_impl,
                                      const wxString& path)
 {
     wxASSERT_MSG( !m_impl,

-                  _T("calling wxSingleInstanceChecker::Create() twice?") );
+                  wxT("calling wxSingleInstanceChecker::Create() twice?") );

 
     // must have the file name to create a lock file
 
     // must have the file name to create a lock file

-    wxASSERT_MSG( !name.empty(), _T("lock file name can't be empty") );
+    wxASSERT_MSG( !name.empty(), wxT("lock file name can't be empty") );

 
     m_impl = new wxSingleInstanceCheckerImpl;
 
 
     m_impl = new wxSingleInstanceCheckerImpl;
 


@@ -365,9 +361,9 @@ bool wxSingleInstanceChecker::Create(const wxString& name,
         fullname = wxGetHomeDir();
     }
 
         fullname = wxGetHomeDir();
     }
 

-    if ( fullname.Last() != _T('/') )
+    if ( fullname.Last() != wxT('/') )

     {
     {

-        fullname += _T('/');
+        fullname += wxT('/');

     }
 
     fullname << name;
     }
 
     fullname << name;


@@ -377,11 +373,21 @@ bool wxSingleInstanceChecker::Create(const wxString& name,
 
 bool wxSingleInstanceChecker::IsAnotherRunning() const
 {
 
 bool wxSingleInstanceChecker::IsAnotherRunning() const
 {

-    wxCHECK_MSG( m_impl, FALSE, _T("must call Create() first") );
+    wxCHECK_MSG( m_impl, false, wxT("must call Create() first") );
+
+    const pid_t lockerPid = m_impl->GetLockerPID();
+
+    if ( !lockerPid )
+    {
+        // we failed to open the lock file, return false as we're definitely
+        // not sure that another our process is running and so it's better not
+        // to prevent this one from starting up
+        return false;
+    }

 
     // if another instance is running, it must own the lock file - otherwise
     // we have it and the locker PID is ours one
 
     // if another instance is running, it must own the lock file - otherwise
     // we have it and the locker PID is ours one

-    return m_impl->GetLockerPID() != getpid();
+    return lockerPid != getpid();

 }
 
 wxSingleInstanceChecker::~wxSingleInstanceChecker()
 }
 
 wxSingleInstanceChecker::~wxSingleInstanceChecker()


@@ -390,4 +396,3 @@ wxSingleInstanceChecker::~wxSingleInstanceChecker()
 }
 
 #endif // wxUSE_SNGLINST_CHECKER
 }
 
 #endif // wxUSE_SNGLINST_CHECKER

-