attempt to get the 'new focus' window parameter of a focus kill event set correctly

[wxWidgets.git] / src / common / ffile.cpp

diff --git a/src/common/ffile.cpp b/src/common/ffile.cpp
index 4a1be06f8b2fc57c1cdc52398e05a2e2bb26c9f5..932498efcd724cc5485088b8747ad03f14823fde 100644 (file)
--- a/src/common/ffile.cpp
+++ b/src/common/ffile.cpp
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        ffile.cpp
-// Purpose:     wxFFile - encapsulates "FILE *" IO stream
+// Name:        src/common/ffile.cpp
+// Purpose:     wxFFile encapsulates "FILE *" IO stream

 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     14.07.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     14.07.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


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

-#ifdef __GNUG__
-    #pragma implementation "ffile.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"
 


@@ -28,11 +24,16 @@
   #pragma hdrstop
 #endif
 
   #pragma hdrstop
 #endif
 

-#if wxUSE_FILE
+#if wxUSE_FFILE

 
 #ifndef WX_PRECOMP
     #include "wx/intl.h"
     #include "wx/log.h"
 
 #ifndef WX_PRECOMP
     #include "wx/intl.h"
     #include "wx/log.h"

+    #include "wx/crt.h"
+#endif
+
+#ifdef __WINDOWS__
+#include "wx/msw/mslu.h"

 #endif
 
 #include "wx/ffile.h"
 #endif
 
 #include "wx/ffile.h"


@@ -45,43 +46,29 @@
 // opening the file
 // ----------------------------------------------------------------------------
 
 // opening the file
 // ----------------------------------------------------------------------------
 

-wxFFile::wxFFile(const wxChar *filename, const char *mode)
+wxFFile::wxFFile(const wxString& filename, const wxString& mode)

 {
     Detach();
 
     (void)Open(filename, mode);
 }
 
 {
     Detach();
 
     (void)Open(filename, mode);
 }
 

-bool wxFFile::Open(const wxChar *filename, const char *mode)
+bool wxFFile::Open(const wxString& filename, const wxString& mode)

 {
 {

-    wxASSERT_MSG( !m_fp, T("should close or detach the old file first") );
-
-#if wxUSE_UNICODE
-    char *tmp_fname;
-    size_t fname_len;
-
-    fname_len = wxStrlen(filename)+1;
-    tmp_fname = new char[fname_len];
-    wxWX2MB(tmp_fname, filename, fname_len);
-
-    m_fp = fopen(tmp_fname, mode);
-
-    delete tmp_fname;
-#else
-    m_fp = fopen(filename, mode);
-#endif
+    wxASSERT_MSG( !m_fp, wxT("should close or detach the old file first") );

 
 

+    m_fp = wxFopen(filename, mode);

 
     if ( !m_fp )
     {
         wxLogSysError(_("can't open file '%s'"), filename);
 
 
     if ( !m_fp )
     {
         wxLogSysError(_("can't open file '%s'"), filename);
 

-        return FALSE;
+        return false;

     }
 
     m_name = filename;
 
     }
 
     m_name = filename;
 

-    return TRUE;
+    return true;

 }
 
 bool wxFFile::Close()
 }
 
 bool wxFFile::Close()


@@ -92,53 +79,55 @@ bool wxFFile::Close()
         {
             wxLogSysError(_("can't close file '%s'"), m_name.c_str());
 
         {
             wxLogSysError(_("can't close file '%s'"), m_name.c_str());
 

-            return FALSE;
+            return false;

         }
 
         Detach();
     }
 
         }
 
         Detach();
     }
 

-    return TRUE;
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 // read/write
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // read/write
 // ----------------------------------------------------------------------------
 

-bool wxFFile::ReadAll(wxString *str)
+bool wxFFile::ReadAll(wxString *str, const wxMBConv& conv)

 {
 {

-    wxCHECK_MSG( str, FALSE, T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, T("can't read from closed file") );
+    wxCHECK_MSG( str, false, wxT("invalid parameter") );
+    wxCHECK_MSG( IsOpened(), false, wxT("can't read from closed file") );
+    wxCHECK_MSG( Length() >= 0, false, wxT("invalid length") );
+    size_t length = wx_truncate_cast(size_t, Length());
+    wxCHECK_MSG( (wxFileOffset)length == Length(), false, wxT("huge file not supported") );

 
     clearerr(m_fp);
 
 
     clearerr(m_fp);
 

-    str->Empty();
-    str->Alloc(Length());
+    wxCharBuffer buf(length);

 
 

-    wxChar buf[1024];
-    static const size_t nSize = WXSIZEOF(buf) - 1; // -1 for trailing '\0'
-    while ( !Eof() )
-    {
-        size_t nRead = fread(buf, sizeof(wxChar), nSize, m_fp);
-        if ( (nRead < nSize) && Error() )
-        {
-            wxLogSysError(_("Read error on file '%s'"), m_name.c_str());
+    // note that real length may be less than file length for text files with DOS EOLs
+    // ('\r's get dropped by CRT when reading which means that we have
+    // realLen = fileLen - numOfLinesInTheFile)
+    length = fread(buf.data(), 1, length, m_fp);

 
 

-            return FALSE;
-        }
-        //else: just EOF
+    if ( Error() )
+    {
+        wxLogSysError(_("Read error on file '%s'"), m_name.c_str());

 
 

-        buf[nRead] = 0;
-        *str += buf;
+        return false;

     }
 
     }
 

-    return TRUE;
+    buf.data()[length] = 0;
+
+    wxString strTmp(buf, conv);
+    str->swap(strTmp);
+
+    return true;

 }
 
 size_t wxFFile::Read(void *pBuf, size_t nCount)
 {
 }
 
 size_t wxFFile::Read(void *pBuf, size_t nCount)
 {

-    wxCHECK_MSG( pBuf, FALSE, T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, T("can't read from closed file") );
+    wxCHECK_MSG( pBuf, 0, wxT("invalid parameter") );
+    wxCHECK_MSG( IsOpened(), 0, wxT("can't read from closed file") );

 
     size_t nRead = fread(pBuf, 1, nCount, m_fp);
     if ( (nRead < nCount) && Error() )
 
     size_t nRead = fread(pBuf, 1, nCount, m_fp);
     if ( (nRead < nCount) && Error() )


@@ -151,8 +140,8 @@ size_t wxFFile::Read(void *pBuf, size_t nCount)
 
 size_t wxFFile::Write(const void *pBuf, size_t nCount)
 {
 
 size_t wxFFile::Write(const void *pBuf, size_t nCount)
 {

-    wxCHECK_MSG( pBuf, FALSE, T("invalid parameter") );
-    wxCHECK_MSG( IsOpened(), FALSE, T("can't write to closed file") );
+    wxCHECK_MSG( pBuf, 0, wxT("invalid parameter") );
+    wxCHECK_MSG( IsOpened(), 0, wxT("can't write to closed file") );

 
     size_t nWritten = fwrite(pBuf, 1, nCount, m_fp);
     if ( nWritten < nCount )
 
     size_t nWritten = fwrite(pBuf, 1, nCount, m_fp);
     if ( nWritten < nCount )


@@ -163,36 +152,44 @@ size_t wxFFile::Write(const void *pBuf, size_t nCount)
     return nWritten;
 }
 
     return nWritten;
 }
 

+bool wxFFile::Write(const wxString& s, const wxMBConv& conv)
+{
+  const wxWX2MBbuf buf = s.mb_str(conv);
+  if ( !buf )
+      return false;
+
+  const size_t size = strlen(buf); // FIXME: use buf.length() when available
+  return Write(buf, size) == size;
+}
+

 bool wxFFile::Flush()
 {
     if ( IsOpened() )
     {
 bool wxFFile::Flush()
 {
     if ( IsOpened() )
     {

-        // fflush returns non-zero on error
-        //
-        if ( fflush(m_fp) )
+        if ( fflush(m_fp) != 0 )

         {
             wxLogSysError(_("failed to flush the file '%s'"), m_name.c_str());
 
         {
             wxLogSysError(_("failed to flush the file '%s'"), m_name.c_str());
 

-            return FALSE;
+            return false;

         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 // seeking
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // seeking
 // ----------------------------------------------------------------------------
 

-bool wxFFile::Seek(long ofs, wxSeekMode mode)
+bool wxFFile::Seek(wxFileOffset ofs, wxSeekMode mode)

 {
 {

-    wxCHECK_MSG( IsOpened(), FALSE, T("can't seek on closed file") );
+    wxCHECK_MSG( IsOpened(), false, wxT("can't seek on closed file") );

 
     int origin;
     switch ( mode )
     {
         default:
 
     int origin;
     switch ( mode )
     {
         default:

-            wxFAIL_MSG(T("unknown seek mode"));
+            wxFAIL_MSG(wxT("unknown seek mode"));

             // still fall through
 
         case wxFromStart:
             // still fall through
 
         case wxFromStart:


@@ -208,38 +205,55 @@ bool wxFFile::Seek(long ofs, wxSeekMode mode)
             break;
     }
 
             break;
     }
 

-    if ( fseek(m_fp, ofs, origin) != 0 )
+#ifndef wxHAS_LARGE_FFILES
+    if ((long)ofs != ofs)
+    {
+        wxLogError(_("Seek error on file '%s' (large files not supported by stdio)"), m_name.c_str());
+
+        return false;
+    }
+
+    if ( wxFseek(m_fp, (long)ofs, origin) != 0 )
+#else
+    if ( wxFseek(m_fp, ofs, origin) != 0 )
+#endif

     {
         wxLogSysError(_("Seek error on file '%s'"), m_name.c_str());
 
     {
         wxLogSysError(_("Seek error on file '%s'"), m_name.c_str());
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 }
 

-size_t wxFFile::Tell() const
+wxFileOffset wxFFile::Tell() const

 {
 {

-    long rc = ftell(m_fp);
-    if ( rc == -1 )
+    wxCHECK_MSG( IsOpened(), wxInvalidOffset,
+                 wxT("wxFFile::Tell(): file is closed!") );
+
+    wxFileOffset rc = wxFtell(m_fp);
+    if ( rc == wxInvalidOffset )

     {
         wxLogSysError(_("Can't find current position in file '%s'"),
                       m_name.c_str());
     }
 
     {
         wxLogSysError(_("Can't find current position in file '%s'"),
                       m_name.c_str());
     }
 

-    return (size_t)rc;
+    return rc;

 }
 
 }
 

-size_t wxFFile::Length() const
+wxFileOffset wxFFile::Length() const

 {
 {

-    wxFFile& self = *(wxFFile *)this;   // const_cast
+    wxCHECK_MSG( IsOpened(), wxInvalidOffset,
+                 wxT("wxFFile::Length(): file is closed!") );
+
+    wxFFile& self = *const_cast<wxFFile *>(this);

 
 

-    size_t posOld = Tell();
-    if ( posOld != (size_t)-1 )
+    wxFileOffset posOld = Tell();
+    if ( posOld != wxInvalidOffset )

     {
         if ( self.SeekEnd() )
         {
     {
         if ( self.SeekEnd() )
         {

-            size_t len = Tell();
+            wxFileOffset len = Tell();

 
             (void)self.Seek(posOld);
 
 
             (void)self.Seek(posOld);
 


@@ -247,7 +261,7 @@ size_t wxFFile::Length() const
         }
     }
 
         }
     }
 

-    return (size_t)-1;
+    return wxInvalidOffset;

 }
 
 }
 

-#endif // wxUSE_FILE
+#endif // wxUSE_FFILE