#include "wx/filefn.h"
// ----------------------------------------------------------------------------
+<<<<<<< file.h
+=======
// constants
// ----------------------------------------------------------------------------
#define wxS_DEFAULT (wxS_IRUSR | wxS_IWUSR | wxS_IRGRP | wxS_IROTH)
// ----------------------------------------------------------------------------
+>>>>>>> 1.7
// class wxFile: raw file IO
//
// NB: for space efficiency this class has no virtual functions, including
wxFile(int fd) { m_fd = fd; }
// open/close
+<<<<<<< file.h
+ bool Create(const char *szFileName, bool bOverwrite = FALSE);
+ bool Open(const char *szFileName, OpenMode mode = read);
+ inline bool Close(); // Close is a NOP if not opened
+=======
// create a new file (with the default value of bOverwrite, it will fail if
// the file already exists, otherwise it will overwrite it and succeed)
bool Create(const char *szFileName, bool bOverwrite = FALSE,
bool Open(const char *szFileName, OpenMode mode = read,
int access = wxS_DEFAULT);
bool Close(); // Close is a NOP if not opened
+>>>>>>> 1.7
// assign an existing file descriptor and get it back from wxFile object
void Attach(int fd) { Close(); m_fd = fd; }
#define off_t _off_t
#endif
+const off_t wxInvalidOffset = (off_t)-1;
+
typedef enum {
wxFromStart,
wxFromCurrent,
// Strip the extension, in situ
void WXDLLEXPORT wxStripExtension(char *buffer);
-void WXDLLEXPORT wxStripExtension(wxString& buffer);
// Get a temporary filename, opening and closing the file.
char* WXDLLEXPORT wxGetTempFileName(const wxString& prefix, char *buf = NULL);
#include <wx/stream.h>
#include <wx/file.h>
-class wxFileInputStream: virtual public wxFile, public wxInputStream {
+class wxFileInputStream: public wxInputStream, virtual public wxFile {
public:
wxFileInputStream(const wxString& fileName);
virtual ~wxFileInputStream();
- wxInputStream& Read(void *buffer, size_t size);
- off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
- off_t TellI() const;
+ virtual char Peek();
- bool Eof() const { return m_eof; }
- size_t LastRead() const { return m_lastread; }
+ virtual bool Eof() const { return wxFile::Eof(); }
bool Ok() const { return wxFile::IsOpened(); }
protected:
wxFileInputStream() {}
- protected:
- bool m_eof;
- bool m_ok_i;
- size_t m_lastread;
+ size_t DoRead(void *buffer, size_t size);
+ off_t DoSeekInput(off_t pos, wxSeekMode mode);
+ off_t DoTellInput() const;
};
-class wxFileOutputStream: virtual wxFile, public wxOutputStream {
+class wxFileOutputStream: public wxOutputStream, virtual public wxFile {
public:
wxFileOutputStream(const wxString& fileName);
virtual ~wxFileOutputStream();
- wxOutputStream& Write(const void *buffer, size_t size);
- off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
- off_t TellO() const;
-
- bool Bad() const { return m_bad; }
- size_t LastWrite() const { return m_lastwrite; }
+ // To solve an ambiguity on GCC
+ inline wxOutputStream& Write(const void *buffer, size_t size)
+ { return wxOutputStream::Write(buffer, size); }
void Sync();
- bool IsOpened() const { return wxFile::IsOpened(); }
+ bool Ok() const { return wxFile::IsOpened(); }
protected:
wxFileOutputStream() {}
- protected:
- bool m_bad;
- size_t m_lastwrite;
+ size_t DoWrite(const void *buffer, size_t size);
+ off_t DoSeekOutput(off_t pos, wxSeekMode mode);
+ off_t DoTellOutput() const;
};
class wxFileStream: public wxFileInputStream, public wxFileOutputStream {
public:
wxMemoryInputStream(const char *data, size_t length);
virtual ~wxMemoryInputStream();
-
- wxInputStream& Read(void *buffer, size_t size);
- off_t SeekI(off_t pos, wxSeekMode mode);
- off_t TellI() const { return m_position_i; }
- bool Eof() const { return m_eof; }
- size_t LastRead() const { return m_lastread; }
+ protected:
+
+ size_t DoRead(void *buffer, size_t size);
+ off_t DoSeekInput(off_t pos, wxSeekMode mode);
+ off_t DoTellInput() const { return m_position_i; }
protected:
- bool m_eof;
off_t m_position_i;
- size_t m_lastread;
};
class wxMemoryOutputStream: virtual public wxMemoryStreamBase, public wxOutputStream {
wxMemoryOutputStream(char *data = NULL, size_t length = 0);
virtual ~wxMemoryOutputStream();
- wxOutputStream& Write(const void *buffer, size_t size);
- off_t SeekO(off_t pos, wxSeekMode mode);
- off_t TellO() const { return m_position_o; }
+ char *GetData() { Sync(); return m_buffer; }
+ size_t GetLength() { Sync(); return m_length; }
- bool Bad() const { return m_bad; }
- size_t LastWrite() const { return m_lastwrite; }
+ protected:
- char *GetData() { return m_buffer; }
- size_t GetLength() { return m_length; }
+ size_t DoWrite(const void *buffer, size_t size);
+ off_t DoSeekOutput(off_t pos, wxSeekMode mode);
+ off_t DoTellOutput() const { return m_position_o; }
protected:
- bool m_bad;
off_t m_position_o;
- size_t m_lastwrite;
};
class wxMemoryStream: public wxMemoryInputStream, public wxMemoryOutputStream {
#endif
class WXDLLEXPORT wxClassInfo;
-
-class WXDLLIMPORT istream;
-class WXDLLIMPORT ostream;
+class WXDLLEXPORT ostream;
+class WXDLLEXPORT wxInputStream;
+class WXDLLIMPORT wxObjectInputStream;
+class WXDLLIMPORT wxObjectOutputStream;
/*
* Dynamic object system declarations
typedef wxObject * (*wxObjectConstructorFn) (void);
-#ifdef USE_STORABLE_CLASSES
-typedef wxObject* (*wxStorableConstructorFn) ( istream &stream, char *data );
-#endif
-
class WXDLLEXPORT wxClassInfo
{
public:
int objectSize;
wxObjectConstructorFn objectConstructor;
-#ifdef USE_STORABLE_CLASSES
- wxStorableConstructorFn storableConstructor;
-#endif
-
// Pointers to base wxClassInfos: set in InitializeClasses
// called from wx_main.cc
wxClassInfo *baseInfo1;
static wxClassInfo *first;
wxClassInfo *next;
-#ifdef USE_STORABLE_CLASSES
- wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn fn,
- wxStorableConstructorFn stoFn = NULL );
-#else
wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn fn);
-#endif
wxObject *CreateObject(void);
-#ifdef USE_STORABLE_CLASSES
- wxObject* CreateObject( istream &stream, char *data );
-#endif
-
inline char *GetClassName(void) const { return className; }
inline char *GetBaseClassName1(void) const { return baseClassName1; }
inline char *GetBaseClassName2(void) const { return baseClassName2; }
wxObject* WXDLLEXPORT wxCreateDynamicObject(char *name);
#ifdef USE_STORABLE_CLASSES
-wxObject* WXDLLEXPORT wxCreateStoredObject( char *name, istream &stream, char *data );
+wxObject* WXDLLEXPORT wxCreateStoredObject( wxInputStream& stream );
#endif
#define DECLARE_DYNAMIC_CLASS(name) \
#define DECLARE_ABSTRACT_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
#define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
-#ifdef USE_STORABLE_CLASSES
-#define DECLARE_STORABLECLASS(name) DECLARE_DYNAMIC_CLASS(name)
-#endif
-
//////
////// for concrete classes
//////
{ return new name; }\
wxClassInfo name::class##name(#name, #basename1, #basename2, sizeof(name), wxConstructorFor##name);
-//////
-////// for storable classes
-//////
-
-#ifdef USE_STORABLE_CLASSES
-
-#define IMPLEMENT_STORABLE_CLASS(name, basename) \
-wxObject* WXDLLEXPORT_CTORFN wxStorableConstructorFor##name( istream* stream, char* data )\
- { return new name( stream, data ); }\
-wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void)\
- { return new name; }\
- wxClassInfo name::class##name(#name, #basename, NULL, sizeof(name), wxConstructorFor##name,\
- wxStorableConstructorFor##name );
-
-#define IMPLEMENT_STORABLE_CLASS2(name, basename1, basename2) \
-wxObject* WXDLLEXPORT_CTORFN wxStorableConstructorFor##name( istream* stream, char* data )\
- { return new name( stream, data ); }\
-wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void)\
- { return new name; }\
- wxClassInfo name::class##name(#name, #basename1, basename2, sizeof(name), wxConstructorFor##name,\
- wxStorableConstructorFor##name );
-
-#endif
-
//////
////// for abstract classes
//////
#endif
#ifdef USE_STORABLE_CLASSES
- virtual void StoreObject( ostream &WXUNUSED(stream) ) {};
+ virtual void StoreObject( wxObjectOutputStream &WXUNUSED(stream) ) {};
+ virtual void LoadObject( wxObjectInputStream &WXUNUSED(stream) ) {};
#endif
// make a 'clone' of the object
#include <stdio.h>
#include "wx/object.h"
#include "wx/string.h"
-#include "wx/filefn.h" // for off_t and wxSeekMode
+#include "wx/filefn.h" // for off_t, wxInvalidOffset and wxSeekMode
+
+class WXDLLEXPORT wxInputStream;
+class WXDLLEXPORT wxOutputStream;
+
+typedef wxInputStream& (*__wxInputManip)(wxInputStream&);
+typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&);
+
+wxOutputStream& WXDLLEXPORT wxEndL(wxOutputStream& o_stream);
+
+class WXDLLEXPORT wxStreamBuffer {
+ public:
+ wxStreamBuffer(wxInputStream& stream);
+ wxStreamBuffer(wxOutputStream& stream);
+ ~wxStreamBuffer();
+
+ void Read(void *buffer, size_t size);
+ void Write(const void *buffer, size_t size);
+ void WriteBack(char c);
+
+ void SetBufferIO(char *buffer_start, char *buffer_end);
+ void SetBufferIO(size_t bufsize);
+ void ResetBuffer();
+
+ void SetBufferPosition(char *buffer_position)
+ { m_buffer_pos = buffer_position; }
+ void SetIntPosition(size_t pos)
+ { m_buffer_pos = m_buffer_start + pos; }
+ char *GetBufferPosition() const { return m_buffer_pos; }
+ size_t GetIntPosition() const { return m_buffer_pos - m_buffer_start; }
+
+ char *GetBufferStart() const { return m_buffer_start; }
+ char *GetBufferEnd() const { return m_buffer_end; }
+ size_t GetBufferSize() const { return m_buffer_size; }
+ size_t GetLastAccess() const { return m_buffer_end - m_buffer_start; }
+
+ protected:
+ char *m_buffer_start, *m_buffer_end, *m_buffer_pos;
+ size_t m_buffer_size;
+
+ wxInputStream *m_istream;
+ wxOutputStream *m_ostream;
+};
/*
* wxStream: base classes
*/
-class wxOutputStream;
-class wxInputStream {
+class WXDLLEXPORT wxInputStream {
public:
wxInputStream();
virtual ~wxInputStream();
- virtual wxInputStream& Read(void *buffer, size_t size) = 0;
+ // IO functions
+ virtual char Peek() = 0;
+ virtual char GetC();
+ virtual wxInputStream& Read(void *buffer, size_t size);
wxInputStream& Read(wxOutputStream& stream_out);
- virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart) = 0;
- virtual off_t TellI() const = 0;
+ // Position functions
+ off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
+ off_t TellI() const;
- virtual bool Eof() const = 0;
- virtual size_t LastRead() const = 0;
+ // State functions
+ bool Eof() const { return m_eof; }
+ size_t LastRead() { return m_lastread; }
+ wxStreamBuffer *InputStreamBuffer() { return m_i_streambuf; }
+ // Operators
wxInputStream& operator>>(wxOutputStream& out) { return Read(out); }
+ wxInputStream& operator>>(wxString& line);
+ wxInputStream& operator>>(char& c);
+ wxInputStream& operator>>(short& i);
+ wxInputStream& operator>>(long& i);
+ wxInputStream& operator>>(float& i);
+ wxInputStream& operator>>( __wxInputManip func) { return func(*this); }
+
+ protected:
+ friend class wxStreamBuffer;
+ friend class wxFilterInputStream;
+
+ wxInputStream(wxStreamBuffer *buffer);
+
+ virtual size_t DoRead(void *buffer, size_t size) = 0;
+ virtual off_t DoSeekInput(off_t pos, wxSeekMode mode) = 0;
+ virtual off_t DoTellInput() const = 0;
+
+ protected:
+ bool m_eof, m_i_destroybuf;
+ size_t m_lastread;
+ wxStreamBuffer *m_i_streambuf;
};
-class wxOutputStream {
+class WXDLLEXPORT wxOutputStream {
public:
wxOutputStream();
virtual ~wxOutputStream();
- virtual wxOutputStream& Write(const void *buffer, size_t size) = 0;
+ virtual wxOutputStream& Write(const void *buffer, size_t size);
wxOutputStream& Write(wxInputStream& stream_in);
- virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart) = 0;
- virtual off_t TellO() const = 0;
+ virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
+ virtual off_t TellO() const;
+
+ virtual bool Bad() const { return m_bad; }
+ virtual size_t LastWrite() const { return m_lastwrite; }
+ wxStreamBuffer *OutputStreamBuffer() { return m_o_streambuf; }
- virtual bool Bad() const = 0;
- virtual size_t LastWrite() const = 0;
+ virtual void Sync();
- virtual void Sync() {}
+ wxOutputStream& operator<<(wxInputStream& out) { return Write(out); }
+ wxOutputStream& operator<<(const char *string);
+ wxOutputStream& operator<<(wxString& string);
+ wxOutputStream& operator<<(char c);
+ wxOutputStream& operator<<(short i);
+ wxOutputStream& operator<<(int i);
+ wxOutputStream& operator<<(long i);
+ wxOutputStream& operator<<(double f);
+
+ wxOutputStream& operator<<(float f) { return operator<<((double)f); }
+ wxOutputStream& operator<<(unsigned char c) { return operator<<((char)c); }
+ wxOutputStream& operator<<(unsigned short i) { return operator<<((short)i); }
+ wxOutputStream& operator<<(unsigned int i) { return operator<<((int)i); }
+ wxOutputStream& operator<<(unsigned long i) { return operator<<((long)i); }
+
+ wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); }
+
+ protected:
+ friend class wxStreamBuffer;
+ friend class wxFilterOutputStream;
+
+ wxOutputStream(wxStreamBuffer *buffer);
+
+ virtual size_t DoWrite(const void *buffer, size_t size) = 0;
+ virtual off_t DoSeekOutput(off_t pos, wxSeekMode mode) = 0;
+ virtual off_t DoTellOutput() const = 0;
+
+ protected:
+ bool m_bad, m_o_destroybuf;
+ size_t m_lastwrite;
+ wxStreamBuffer *m_o_streambuf;
};
/*
* "Filter" streams
*/
-class wxFilterInputStream: public wxInputStream {
+class WXDLLEXPORT wxFilterInputStream: public wxInputStream {
public:
wxFilterInputStream(wxInputStream& stream);
virtual ~wxFilterInputStream();
- virtual wxInputStream& Read(void *buffer, size_t size)
- { return m_parent_i_stream->Read(buffer, size); }
- virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart)
- { return m_parent_i_stream->SeekI(pos, mode); }
- virtual off_t TellI() const
- { return m_parent_i_stream->TellI(); }
+ virtual char Peek() { return m_parent_i_stream->Peek(); }
virtual bool Eof() const { return m_parent_i_stream->Eof(); }
virtual size_t LastRead() const { return m_parent_i_stream->LastRead(); }
+ protected:
+ virtual size_t DoRead(void *buffer, size_t size);
+ virtual off_t DoSeekInput(off_t pos, wxSeekMode mode);
+ virtual off_t DoTellInput() const;
+
protected:
wxInputStream *m_parent_i_stream;
};
-class wxFilterOutputStream: public wxOutputStream {
+class WXDLLEXPORT wxFilterOutputStream: public wxOutputStream {
public:
wxFilterOutputStream(wxOutputStream& stream);
virtual ~wxFilterOutputStream();
- virtual wxOutputStream& Write(const void *buffer, size_t size)
- { return m_parent_o_stream->Write(buffer, size); }
- virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart)
- { return m_parent_o_stream->SeekO(pos, mode); }
- virtual off_t TellO() const
- { return m_parent_o_stream->TellO(); }
-
virtual bool Bad() const { return m_parent_o_stream->Bad(); }
virtual size_t LastWrite() const { return m_parent_o_stream->LastWrite(); }
+ protected:
+
+ // The forward is implicitely done by wxStreamBuffer.
+
+ virtual size_t DoWrite(const void *buffer, size_t size);
+ virtual off_t DoSeekOutput(off_t pos, wxSeekMode mode);
+ virtual off_t DoTellOutput() const;
+
protected:
wxOutputStream *m_parent_o_stream;
};
#endif
#include <wx/stream.h>
-#include "../../src/zlib/zlib.h"
+#include "zlib.h"
class wxZlibInputStream: public wxFilterInputStream {
public:
wxZlibInputStream(wxInputStream& stream);
virtual ~wxZlibInputStream();
- wxInputStream& Read(void *buffer, size_t size);
- off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
- off_t TellI() const;
-
- size_t LastRead() const { return m_lastread; }
bool Eof() const;
protected:
- size_t m_lastread;
+ size_t DoRead(void *buffer, size_t size);
+ off_t DoSeekInput(off_t pos, wxSeekMode WXUNUSED(mode)) { return wxInvalidOffset; }
+ off_t DoTellInput() const { return wxInvalidOffset; }
+
+ protected:
size_t m_z_size;
unsigned char *m_z_buffer;
- bool m_eof;
struct z_stream_s m_inflate;
};
wxZlibOutputStream(wxOutputStream& stream);
virtual ~wxZlibOutputStream();
- wxOutputStream& Write(const void *buffer, size_t size);
- off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
- off_t TellO() const;
+ void Sync();
- size_t LastWrite() const { return m_lastwrite; }
bool Bad() const;
protected:
- size_t m_lastwrite;
+ size_t DoWrite(const void *buffer, size_t size);
+ off_t DoSeekOutput(off_t pos, wxSeekMode WXUNUSED(mode)) { return wxInvalidOffset; }
+ off_t DoTellOutput() const { return wxInvalidOffset; }
+
+ protected:
size_t m_z_size;
unsigned char *m_z_buffer;
- bool m_bad;
struct z_stream_s m_deflate;
};
common/mstream.cpp \
common/zstream.cpp \
common/datstrm.cpp \
+ common/objstrm.cpp \
\
gtk/app.cpp \
gtk/bitmap.cpp \
int fd = open(szFileName, O_CREAT | (bOverwrite ? O_TRUNC : O_EXCL), access);
if ( fd == -1 ) {
- wxLogSysError(_("can't create file '%s'"), szFileName);
+ wxLogSysError("can't create file '%s'", szFileName);
return FALSE;
}
else {
int fd = open(szFileName, flags, access);
if ( fd == -1 ) {
- wxLogSysError(_("can't open file '%s'"), szFileName);
+ wxLogSysError("can't open file '%s'", szFileName);
return FALSE;
}
else {
{
if ( IsOpened() ) {
if ( close(m_fd) == -1 ) {
- wxLogSysError(_("can't close file descriptor %d"), m_fd);
+ wxLogSysError("can't close file descriptor %d", m_fd);
m_fd = fd_invalid;
return FALSE;
}
int iRc = ::read(m_fd, pBuf, nCount);
if ( iRc == -1 ) {
- wxLogSysError(_("can't read from file descriptor %d"), m_fd);
- return ofsInvalid;
+ wxLogSysError("can't read from file descriptor %d", m_fd);
+ return wxInvalidOffset;
}
else
return (uint)iRc;
int iRc = ::write(m_fd, pBuf, nCount);
if ( iRc == -1 ) {
- wxLogSysError(_("can't write to file descriptor %d"), m_fd);
+ wxLogSysError("can't write to file descriptor %d", m_fd);
m_error = TRUE;
return 0;
}
else
- return (uint)iRc;
+ return iRc;
}
// flush
bool wxFile::Flush()
{
if ( IsOpened() ) {
-// @@@ fsync() is not ANSI (BSDish)
+ // @@@ fsync() is not ANSI (BSDish)
// if ( fsync(m_fd) == -1 ) { // TODO
if (TRUE) {
- wxLogSysError(_("can't flush file descriptor %d"), m_fd);
+ wxLogSysError("can't flush file descriptor %d", m_fd);
return FALSE;
}
}
int iRc = lseek(m_fd, ofs, flag);
if ( iRc == -1 ) {
- wxLogSysError(_("can't seek on file descriptor %d"), m_fd);
- return ofsInvalid;
+ wxLogSysError("can't seek on file descriptor %d", m_fd);
+ return wxInvalidOffset;
}
else
return (off_t)iRc;
int iRc = tell(m_fd);
if ( iRc == -1 ) {
- wxLogSysError(_("can't get seek position on file descriptor %d"), m_fd);
- return ofsInvalid;
+ wxLogSysError("can't get seek position on file descriptor %d", m_fd);
+ return wxInvalidOffset;
}
else
return (off_t)iRc;
#endif //_MSC_VER
if ( iRc == -1 ) {
- wxLogSysError(_("can't find length of file on file descriptor %d"), m_fd);
- return ofsInvalid;
+ wxLogSysError("can't find length of file on file descriptor %d", m_fd);
+ return wxInvalidOffset;
}
else
return (off_t)iRc;
// @@ this doesn't work, of course, on unseekable file descriptors
off_t ofsCur = Tell(),
ofsMax = Length();
- if ( ofsCur == ofsInvalid || ofsMax == ofsInvalid )
+ if ( ofsCur == wxInvalidOffset || ofsMax == wxInvalidOffset )
iRc = -1;
else
iRc = ofsCur == ofsMax;
return FALSE;
case -1:
- wxLogSysError(_("can't determine if the end of file is reached on "
- "descriptor %d"), m_fd);
+ wxLogSysError("can't determine if the end of file is reached on "
+ "descriptor %d", m_fd);
break;
default:
m_file.Close();
if ( wxFile::Exists(m_strName) && remove(m_strName) != 0 ) {
- wxLogSysError(_("can't remove file '%s'"), m_strName.c_str());
+ wxLogSysError("can't remove file '%s'", m_strName.c_str());
return FALSE;
}
if ( rename(m_strTemp, m_strName) != 0 ) {
- wxLogSysError(_("can't commit changes to file '%s'"), m_strName.c_str());
+ wxLogSysError("can't commit changes to file '%s'", m_strName.c_str());
return FALSE;
}
{
m_file.Close();
if ( remove(m_strTemp) != 0 )
- wxLogSysError(_("can't remove temporary file '%s'"), m_strTemp.c_str());
+ wxLogSysError("can't remove temporary file '%s'", m_strTemp.c_str());
}
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
-// declarations
+// declaration
// ============================================================================
// ----------------------------------------------------------------------------
#pragma hdrstop
#endif
-// wxWindows
-#ifndef WX_PRECOMP
- #include "wx/defs.h"
- #include "wx/string.h"
-#endif //WX_PRECOMP
+// standard headers
+#include <locale.h>
+// wxWindows
+#include "wx/defs.h"
+#include "wx/string.h"
#include "wx/intl.h"
#include "wx/file.h"
#include "wx/log.h"
#include "wx/utils.h"
-// standard headers
-#include <locale.h>
#include <stdlib.h>
// ----------------------------------------------------------------------------
#define MSGCATALOG_EXTENSION ".mo"
// ----------------------------------------------------------------------------
-// global functions (private to this module)
+// global functions
// ----------------------------------------------------------------------------
// suppress further error messages about missing translations
// (if you don't have one catalog file, you wouldn't like to see the
// error message for each string in it, so normally it's given only
// once)
-static void wxSuppressTransErrors();
+void wxSuppressTransErrors();
// restore the logging
-static void wxRestoreTransErrors();
+void wxRestoreTransErrors();
// get the current state
-static bool wxIsLoggingTransErrors();
+bool wxIsLoggingTransErrors();
-// get the current locale object (@@ may be NULL!)
-static wxLocale *wxSetLocale(wxLocale *pLocale);
+// get the current locale object (## may be NULL!)
+extern wxLocale *wxSetLocale(wxLocale *pLocale);
// ----------------------------------------------------------------------------
// wxMsgCatalog corresponds to one disk-file message catalog.
DELETEA(m_pszName);
}
-// a helper class which suppresses all translation error messages
-// from the moment of it's creation until it's destruction
class NoTransErr
{
public:
// open disk file and read in it's contents
bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
{
- // search order (assume language 'lang') is
- // 1) $LC_PATH/lang/LC_MESSAGES (if LC_PATH set)
- // 2) ./lang/LC_MESSAGES
- // 3) ./lang
+ // search order (assume language 'foo') is
+ // 1) $LC_PATH/foo/LC_MESSAGES (if LC_PATH set)
+ // 2) ./foo/LC_MESSAGES
+ // 3) ./foo
// 4) . (Added by JACS)
//
// under UNIX we search also in:
- // 5) /usr/share/locale/lang/LC_MESSAGES (Linux)
- // 6) /usr/lib/locale/lang/LC_MESSAGES (Solaris)
+ // 5) /usr/share/locale/foo/LC_MESSAGES (Linux)
+ // 6) /usr/lib/locale/foo/LC_MESSAGES (Solaris)
#define MSG_PATH FILE_SEP_PATH + "LC_MESSAGES" PATH_SEP
wxString strPath("");
// NB: '<<' is unneeded between too literal strings:
// they are concatenated at compile time
- strPath << "./" << wxString(szDirPrefix) + MSG_PATH // (2)
- << "./" << szDirPrefix << FILE_SEP_PATH << PATH_SEP // (3)
- << "." << PATH_SEP // (4)
+ strPath += "./" + wxString(szDirPrefix) + MSG_PATH // (2)
+ + "./" + szDirPrefix + FILE_SEP_PATH + PATH_SEP // (3)
+ + "." + PATH_SEP
#ifdef __UNIX__
- "/usr/share/locale/" << szDirPrefix << MSG_PATH // (5)
- "/usr/lib/locale/" << szDirPrefix << MSG_PATH // (6)
+ "/usr/share/locale/" + szDirPrefix + MSG_PATH // (5)
+ "/usr/lib/locale/" + szDirPrefix + MSG_PATH // (6)
#endif //UNIX
;
// (we're using an object because we have several return paths)
NoTransErr noTransErr;
- wxLogVerbose(_("looking for catalog '%s' in path '%s'..."),
- szName, strPath.c_str());
+ wxLogVerbose("looking for catalog '%s' in path '%s'.",
+ szName, strPath.c_str());
wxString strFullName;
if ( !wxFindFileInPath(&strFullName, strPath, strFile) ) {
- wxLogWarning(_("catalog file for domain '%s' not found."), szName);
+ wxLogWarning("catalog file for domain '%s' not found.", szName);
return FALSE;
}
// open file
- wxLogVerbose(_("catalog '%s' found in '%s'."), szName, strFullName.c_str());
+ wxLogVerbose("using catalog '%s' from '%s'.",
+ szName, strFullName.c_str());
- // declare these vars here because we're using goto further down
- bool bValid;
- off_t nSize;
-
wxFile fileMsg(strFullName);
if ( !fileMsg.IsOpened() )
- goto error;
+ return FALSE;
// get the file size
- nSize = fileMsg.Length();
- if ( nSize == ofsInvalid )
- goto error;
+ off_t nSize = fileMsg.Length();
+ if ( nSize == wxInvalidOffset )
+ return FALSE;
// read the whole file in memory
m_pData = new uint8[nSize];
if ( fileMsg.Read(m_pData, nSize) != nSize ) {
DELETEA(m_pData);
m_pData = NULL;
- goto error;
+ return FALSE;
}
// examine header
- bValid = (size_t)nSize > sizeof(wxMsgCatalogHeader);
+ bool bValid = (size_t)nSize > sizeof(wxMsgCatalogHeader);
wxMsgCatalogHeader *pHeader;
if ( bValid ) {
if ( !bValid ) {
// it's either too short or has incorrect magic number
- wxLogWarning(_("'%s' is not a valid message catalog."),
- strFullName.c_str());
+ wxLogWarning("'%s' is not a valid message catalog.", strFullName.c_str());
DELETEA(m_pData);
m_pData = NULL;
// initialize
m_numStrings = Swap(pHeader->numStrings);
- m_pOrigTable = (wxMsgTableEntry *)(m_pData + Swap(pHeader->ofsOrigTable));
- m_pTransTable = (wxMsgTableEntry *)(m_pData + Swap(pHeader->ofsTransTable));
+ m_pOrigTable = (wxMsgTableEntry *)(m_pData +
+ Swap(pHeader->ofsOrigTable));
+ m_pTransTable = (wxMsgTableEntry *)(m_pData +
+ Swap(pHeader->ofsTransTable));
m_nHashSize = Swap(pHeader->nHashSize);
m_pHashTable = (uint32 *)(m_pData + Swap(pHeader->ofsHashTable));
// everything is fine
return TRUE;
-
-error:
- wxLogError(_("error opening message catalog '%s', not loaded."),
- strFullName.c_str());
- return FALSE;
}
// search for a string
szLocale = szName;
m_pszOldLocale = setlocale(LC_ALL, szLocale);
if ( m_pszOldLocale == NULL )
- wxLogError(_("locale '%s' can not be set."), szLocale);
+ wxLogError("locale '%s' can not be set.", szLocale);
// the short name will be used to look for catalog files as well,
// so we need something here
if ( m_strShort.IsEmpty() ) {
- // @@@@ I don't know how these 2 letter abbreviations are formed,
+ // #### I don't know how these 2 letter abbreviations are formed,
// this wild guess is almost surely wrong
m_strShort = wxToLower(szLocale[0]) + wxToLower(szLocale[1]);
}
wxSuppressTransErrors();
if ( szDomain != NULL )
- wxLogWarning(_("string '%s' not found in domain '%s'"
- " for locale '%s'."),
- szOrigString, szDomain, m_strLocale.c_str());
+ wxLogWarning("string '%s' not found in domain '%s' for locale '%s'.",
+ szOrigString, szDomain, m_strLocale.c_str());
else
- wxLogWarning(_("string '%s' not found in locale '%s'."),
- szOrigString, m_strLocale.c_str());
+ wxLogWarning("string '%s' not found in locale '%s'.",
+ szOrigString, m_strLocale.c_str());
}
return szOrigString;
// the current locale object
wxLocale *g_pLocale = NULL;
+wxLocale *wxGetLocale()
+{
+ return g_pLocale;
+}
+
wxLocale *wxSetLocale(wxLocale *pLocale)
{
wxLocale *pOld = g_pLocale;
#pragma hdrstop
#endif
+#ifndef WX_PRECOMP
#include "wx/hash.h"
+#include "wx/objstrm.h"
+#endif
#include <string.h>
#include <assert.h>
* Class info: provides run-time class type information.
*/
-#ifdef USE_STORABLE_CLASSES
-
-wxClassInfo::wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn fn,
- wxStorableConstructorFn stoFn )
-{
- className = cName;
- baseClassName1 = baseName1;
- baseClassName2 = baseName2;
-
- objectSize = sz;
- objectConstructor = fn;
- storableConstructor = stoFn;
-
- next = first;
- first = this;
-
- baseInfo1 = NULL;
- baseInfo2 = NULL;
-}
-
-wxObject* wxClassInfo::CreateObject( istream &stream, char *data )
-{
- if (storableConstructor)
- return (wxObject *)(*storableConstructor)( stream, data );
- else
- return NULL;
-}
-
-#else
-
wxClassInfo::wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn constr)
{
className = cName;
baseInfo2 = NULL;
}
-#endif
-
wxObject *wxClassInfo::CreateObject(void)
{
if (objectConstructor)
#ifdef USE_STORABLE_CLASSES
-wxObject* wxCreateStoredObject( char *name, istream &stream, char *data )
+wxObject* wxCreateStoredObject( wxInputStream &stream )
{
- wxClassInfo *info = wxClassInfo::first;
- while (info)
- {
- if (info->className && strcmp(info->className, name) == 0)
- return info->CreateObject( stream, data );
- info = info->next;
- }
- return NULL;
+ wxObjectInputStream obj_s(stream);
+ return obj_s.LoadObject();
};
#endif
#pragma hdrstop
#endif
+// ----------------------------------------------------------------------------
+// wxInputStream
+// ----------------------------------------------------------------------------
+
wxInputStream::wxInputStream()
{
}
return *this;
}
+int wxInputStream::Scanf(const wxString& format, ...)
+{
+ va_list params;
+
+ va_start(params, format);
+ va_end(params);
+}
+
+wxInputStream& wxInputStream::operator>>(wxString& line)
+{
+ wxDataInputStream s(*this);
+
+ line = s.ReadLine();
+ return *this;
+}
+
+wxInputStream& wxInputStream::operator>>(char& c)
+{
+ c = GetC();
+}
+
+wxInputStream& wxInputStream::operator>>(short& i)
+{
+ Scanf("%i", &i);
+ return *this;
+}
+
+wxInputStream& wxInputStream::operator>>(long& i)
+{
+ Scanf("%l", &i);
+ return *this;
+}
+
+wxInputStream& wxInputStream::operator>>(float& f)
+{
+ Scanf("%f", &f);
+ return *this;
+}
+
+// ----------------------------------------------------------------------------
+// wxOutputStream
+// ----------------------------------------------------------------------------
wxOutputStream::wxOutputStream()
{
}
return *this;
}
+// ----------------------------------------------------------------------------
+// wxFilterInputStream
+// ----------------------------------------------------------------------------
wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
: wxInputStream()
{
{
}
+// ----------------------------------------------------------------------------
+// wxFilterOutputStream
+// ----------------------------------------------------------------------------
wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
: wxOutputStream()
{
// interpret the results (@@ far from being even 50% fool proof)
if ( nDos + nUnix + nMac == 0 ) {
// no newlines at all
- wxLogWarning(_("'%s' is probably a binary file."), m_strFile.c_str());
+ wxLogWarning("'%s' is probably a binary file.", m_strFile.c_str());
}
else {
#define GREATER_OF(t1, t2) n##t1 == n##t2 ? typeDefault \
int n, nRead;
while ( !m_file.Eof() ) {
nRead = m_file.Read(buf, WXSIZEOF(buf));
- if ( nRead == ofsInvalid ) {
+ if ( nRead == wxInvalidOffset ) {
// read error (error message already given in wxFile::Read)
m_file.Close();
return FALSE;
wxTempFile fileTmp(m_strFile);
if ( !fileTmp.IsOpened() ) {
- wxLogError(_("can't write file '%s' to disk."), m_strFile.c_str());
+ wxLogError("can't write file '%s' to disk.", m_strFile.c_str());
return FALSE;
}
projects / wxWidgets.git / commitdiff
