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

Minor changes to wxTreeCtrl's horiz size,

Browse Source 
Text stream now can write Mac/Unix/Dos EOL on resp. other platforms,
  Fixed return value of wxBufferedOutputStream::GetSize() and ::TellO()


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5036 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
1999-12-20 16:15:32 +00:00
parent f9dbf34fc6
commit c7a9fa36e4
6 changed files with 491 additions and 452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

364
include/wx/stream.h
View File

@@ -44,118 +44,125 @@ WXDLLEXPORT wxOutputStream& wxEndL(wxOutputStream& o_stream);
#define wxStream_READ_ERR wxSTREAM_READ_ERROR
typedef enum {
wxStream_NOERROR = 0,
wxStream_EOF,
wxStream_WRITE_ERR,
wxStream_READ_ERR
wxSTREAM_NO_ERROR = 0,
wxSTREAM_NO_ERR = wxSTREAM_NO_ERROR,
wxSTREAM_NOERROR = wxSTREAM_NO_ERROR,
wxSTREAM_EOF,
wxSTREAM_WRITE_ERROR,
wxSTREAM_WRITE_ERR = wxSTREAM_WRITE_ERROR,
wxSTREAM_READ_ERROR,
wxSTREAM_READ_ERR = wxSTREAM_READ_ERROR,
} wxStreamError;
class WXDLLEXPORT wxStreamBase {
public:
wxStreamBase();
virtual ~wxStreamBase();
class WXDLLEXPORT wxStreamBase
{
public:
wxStreamBase();
virtual ~wxStreamBase();
bool operator!() const { return (LastError() != wxSTREAM_NOERROR); }
wxStreamError LastError() const { return m_lasterror; }
virtual size_t GetSize() const { return ~((size_t)0); }
size_t StreamSize() const { return GetSize(); }
bool operator!() const { return (LastError() != wxSTREAM_NOERROR); }
wxStreamError LastError() const { return m_lasterror; }
virtual size_t GetSize() const { return ~((size_t)0); }
size_t StreamSize() const { return GetSize(); }
protected:
protected:
virtual size_t OnSysRead(void *buffer, size_t bufsize);
virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
virtual off_t OnSysTell() const;
virtual size_t OnSysRead(void *buffer, size_t bufsize);
virtual size_t OnSysWrite(const void *buffer, size_t bufsize);
virtual off_t OnSysSeek(off_t seek, wxSeekMode mode);
virtual off_t OnSysTell() const;
friend class wxStreamBuffer;
protected:
friend class wxStreamBuffer;
size_t m_lastcount;
wxStreamError m_lasterror;
size_t m_lastcount;
wxStreamError m_lasterror;
};
class WXDLLEXPORT wxInputStream: public wxStreamBase {
public:
wxInputStream();
virtual ~wxInputStream();
class WXDLLEXPORT wxInputStream: public wxStreamBase
{
public:
wxInputStream();
virtual ~wxInputStream();
// IO functions
virtual char Peek();
char GetC();
virtual wxInputStream& Read(void *buffer, size_t size);
wxInputStream& Read(wxOutputStream& stream_out);
// IO functions
virtual char Peek();
char GetC();
virtual wxInputStream& Read(void *buffer, size_t size);
wxInputStream& Read(wxOutputStream& stream_out);
// Position functions
virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
virtual off_t TellI() const;
// Position functions
virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
virtual off_t TellI() const;
// State functions
virtual size_t LastRead() { return wxStreamBase::m_lastcount; }
// State functions
virtual size_t LastRead() { return wxStreamBase::m_lastcount; }
// Ungetch
size_t Ungetch(const void *buffer, size_t size);
bool Ungetch(char c);
// Ungetch
size_t Ungetch(const void *buffer, size_t size);
bool Ungetch(char c);
// Operators
wxInputStream& operator>>(wxOutputStream& out) { return Read(out); }
// Operators
wxInputStream& operator>>(wxOutputStream& out) { return Read(out); }
#if wxUSE_SERIAL
wxInputStream& operator>>(wxObject *& obj);
wxInputStream& operator>>(wxObject *& obj);
#endif
wxInputStream& operator>>( __wxInputManip func) { return func(*this); }
wxInputStream& operator>>( __wxInputManip func) { return func(*this); }
protected:
// Ungetch managers
char *m_wback;
size_t m_wbacksize;
size_t m_wbackcur;
char *AllocSpaceWBack(size_t needed_size);
size_t GetWBack(char *buf, size_t bsize);
protected:
// Ungetch managers
char *m_wback;
size_t m_wbacksize;
size_t m_wbackcur;
char *AllocSpaceWBack(size_t needed_size);
size_t GetWBack(char *buf, size_t bsize);
};
class WXDLLEXPORT wxOutputStream: public wxStreamBase {
public:
wxOutputStream();
virtual ~wxOutputStream();
class WXDLLEXPORT wxOutputStream: public wxStreamBase
{
public:
wxOutputStream();
virtual ~wxOutputStream();
void PutC(char c);
virtual wxOutputStream& Write(const void *buffer, size_t size);
wxOutputStream& Write(wxInputStream& stream_in);
void PutC(char c);
virtual wxOutputStream& Write(const void *buffer, size_t size);
wxOutputStream& Write(wxInputStream& stream_in);
virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
virtual off_t TellO() const;
virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
virtual off_t TellO() const;
virtual size_t LastWrite() const { return wxStreamBase::m_lastcount; }
virtual size_t LastWrite() const { return wxStreamBase::m_lastcount; }
virtual void Sync();
virtual void Sync();
wxOutputStream& operator<<(wxInputStream& out) { return Write(out); }
wxOutputStream& operator<<(wxInputStream& out) { return Write(out); }
#if wxUSE_SERIAL
wxOutputStream& operator<<(wxObject& obj);
wxOutputStream& operator<<(wxObject& obj);
#endif
wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); }
wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); }
};
// ---------------------------------------------------------------------------
// A stream for measuring streamed output
// ---------------------------------------------------------------------------
class wxCountingOutputStream: public wxOutputStream {
public:
wxCountingOutputStream();
class wxCountingOutputStream: public wxOutputStream
{
public:
wxCountingOutputStream();
size_t GetSize() const;
bool Ok() const { return TRUE; }
size_t GetSize() const;
bool Ok() const { return TRUE; }
protected:
protected:
size_t OnSysWrite(const void *buffer, size_t size);
off_t OnSysSeek(off_t pos, wxSeekMode mode);
off_t OnSysTell() const;
size_t OnSysWrite(const void *buffer, size_t size);
off_t OnSysSeek(off_t pos, wxSeekMode mode);
off_t OnSysTell() const;
protected:
size_t m_currentPos;
size_t m_currentPos;
};
@@ -163,153 +170,148 @@ class wxCountingOutputStream: public wxOutputStream {
// "Filter" streams
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxFilterInputStream: public wxInputStream {
public:
wxFilterInputStream();
wxFilterInputStream(wxInputStream& stream);
~wxFilterInputStream();
class WXDLLEXPORT wxFilterInputStream: public wxInputStream
{
public:
wxFilterInputStream();
wxFilterInputStream(wxInputStream& stream);
~wxFilterInputStream();
char Peek() { return m_parent_i_stream->Peek(); }
char Peek() { return m_parent_i_stream->Peek(); }
size_t GetSize() const { return m_parent_i_stream->GetSize(); }
size_t GetSize() const { return m_parent_i_stream->GetSize(); }
protected:
wxInputStream *m_parent_i_stream;
protected:
wxInputStream *m_parent_i_stream;
};
class WXDLLEXPORT wxFilterOutputStream: public wxOutputStream {
public:
wxFilterOutputStream();
wxFilterOutputStream(wxOutputStream& stream);
~wxFilterOutputStream();
class WXDLLEXPORT wxFilterOutputStream: public wxOutputStream
{
public:
wxFilterOutputStream();
wxFilterOutputStream(wxOutputStream& stream);
~wxFilterOutputStream();
size_t GetSize() const { return m_parent_o_stream->GetSize(); }
size_t GetSize() const { return m_parent_o_stream->GetSize(); }
protected:
wxOutputStream *m_parent_o_stream;
protected:
wxOutputStream *m_parent_o_stream;
};
// ---------------------------------------------------------------------------
// Stream buffer
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxStreamBuffer {
public:
typedef enum {
read = 0, write, read_write
} BufMode;
class WXDLLEXPORT wxStreamBuffer
{
public:
typedef enum {
read = 0, write, read_write
} BufMode;
// -----------
// ctor & dtor
// -----------
wxStreamBuffer(wxStreamBase& stream, BufMode mode);
wxStreamBuffer(BufMode mode);
wxStreamBuffer(const wxStreamBuffer& buf);
~wxStreamBuffer();
wxStreamBuffer(wxStreamBase& stream, BufMode mode);
wxStreamBuffer(BufMode mode);
wxStreamBuffer(const wxStreamBuffer& buf);
~wxStreamBuffer();
// -----------
// Filtered IO
// -----------
size_t Read(void *buffer, size_t size);
size_t Read(wxStreamBuffer *buf);
size_t Write(const void *buffer, size_t size);
size_t Write(wxStreamBuffer *buf);
// Filtered IO
size_t Read(void *buffer, size_t size);
size_t Read(wxStreamBuffer *buf);
size_t Write(const void *buffer, size_t size);
size_t Write(wxStreamBuffer *buf);
char Peek();
char GetChar();
void PutChar(char c);
off_t Tell() const;
off_t Seek(off_t pos, wxSeekMode mode);
char Peek();
char GetChar();
void PutChar(char c);
off_t Tell() const;
off_t Seek(off_t pos, wxSeekMode mode);
// --------------
// Buffer control
// --------------
void ResetBuffer();
void SetBufferIO(char *buffer_start, char *buffer_end);
void SetBufferIO(size_t bufsize);
char *GetBufferStart() const { return m_buffer_start; }
char *GetBufferEnd() const { return m_buffer_end; }
char *GetBufferPos() const { return m_buffer_pos; }
off_t GetIntPosition() const { return m_buffer_pos-m_buffer_start; }
void SetIntPosition(off_t pos) { m_buffer_pos = m_buffer_start+pos; }
size_t GetLastAccess() const { return m_buffer_end-m_buffer_start; }
// Buffer control
void ResetBuffer();
void SetBufferIO(char *buffer_start, char *buffer_end);
void SetBufferIO(size_t bufsize);
char *GetBufferStart() const { return m_buffer_start; }
char *GetBufferEnd() const { return m_buffer_end; }
char *GetBufferPos() const { return m_buffer_pos; }
off_t GetIntPosition() const { return m_buffer_pos-m_buffer_start; }
void SetIntPosition(off_t pos) { m_buffer_pos = m_buffer_start+pos; }
size_t GetLastAccess() const { return m_buffer_end-m_buffer_start; }
void Fixed(bool fixed) { m_fixed = fixed; }
void Flushable(bool f) { m_flushable = f; }
void Fixed(bool fixed) { m_fixed = fixed; }
void Flushable(bool f) { m_flushable = f; }
bool FlushBuffer();
bool FillBuffer();
size_t GetDataLeft();
bool FlushBuffer();
bool FillBuffer();
size_t GetDataLeft();
// --------------
// Administration
// --------------
wxStreamBase *Stream() { return m_stream; }
// Misc.
wxStreamBase *Stream() { return m_stream; }
protected:
void GetFromBuffer(void *buffer, size_t size);
void PutToBuffer(const void *buffer, size_t size);
protected:
void GetFromBuffer(void *buffer, size_t size);
void PutToBuffer(const void *buffer, size_t size);
protected:
char *m_buffer_start, *m_buffer_end, *m_buffer_pos;
size_t m_buffer_size;
char *m_buffer_start, *m_buffer_end, *m_buffer_pos;
size_t m_buffer_size;
bool m_fixed, m_flushable;
bool m_fixed, m_flushable;
wxStreamBase *m_stream;
BufMode m_mode;
bool m_destroybuf, m_destroystream;
wxStreamBase *m_stream;
BufMode m_mode;
bool m_destroybuf, m_destroystream;
};
// ---------------------------------------------------------------------------
// wxBufferedStreams
// ---------------------------------------------------------------------------
class wxBufferedInputStream: public wxFilterInputStream {
public:
wxBufferedInputStream(wxInputStream& stream);
~wxBufferedInputStream();
class wxBufferedInputStream: public wxFilterInputStream
{
public:
wxBufferedInputStream(wxInputStream& stream);
~wxBufferedInputStream();
char Peek();
wxInputStream& Read(void *buffer, size_t size);
char Peek();
wxInputStream& Read(void *buffer, size_t size);
// Position functions
off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
off_t TellI() const;
// Position functions
off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
off_t TellI() const;
wxStreamBuffer *InputStreamBuffer() const { return m_i_streambuf; }
wxStreamBuffer *InputStreamBuffer() const { return m_i_streambuf; }
protected:
size_t OnSysRead(void *buffer, size_t bufsize);
off_t OnSysSeek(off_t seek, wxSeekMode mode);
off_t OnSysTell() const;
protected:
size_t OnSysRead(void *buffer, size_t bufsize);
off_t OnSysSeek(off_t seek, wxSeekMode mode);
off_t OnSysTell() const;
protected:
wxStreamBuffer *m_i_streambuf;
wxStreamBuffer *m_i_streambuf;
};
class wxBufferedOutputStream: public wxFilterOutputStream {
public:
wxBufferedOutputStream(wxOutputStream& stream);
~wxBufferedOutputStream();
class wxBufferedOutputStream: public wxFilterOutputStream
{
public:
wxBufferedOutputStream(wxOutputStream& stream);
~wxBufferedOutputStream();
wxOutputStream& Write(const void *buffer, size_t size);
wxOutputStream& Write(const void *buffer, size_t size);
// Position functions
off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
off_t TellO() const;
// Position functions
off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
off_t TellO() const;
void Sync();
void Sync();
wxStreamBuffer *OutputStreamBuffer() const { return m_o_streambuf; }
size_t GetSize() const;
protected:
size_t OnSysWrite(const void *buffer, size_t bufsize);
off_t OnSysSeek(off_t seek, wxSeekMode mode);
off_t OnSysTell() const;
wxStreamBuffer *OutputStreamBuffer() const { return m_o_streambuf; }
protected:
wxStreamBuffer *m_o_streambuf;
protected:
size_t OnSysWrite(const void *buffer, size_t bufsize);
off_t OnSysSeek(off_t seek, wxSeekMode mode);
off_t OnSysTell() const;
wxStreamBuffer *m_o_streambuf;
};
#endif

111
include/wx/txtstrm.h
View File

@@ -28,68 +28,81 @@ typedef wxTextOutputStream& (*__wxTextOutputManip)(wxTextOutputStream&);
WXDLLEXPORT wxTextOutputStream &endl( wxTextOutputStream &stream );
class WXDLLEXPORT wxTextInputStream {
class WXDLLEXPORT wxTextInputStream
{
public:
wxTextInputStream(wxInputStream& s, const wxString &sep=wxT(" \t"));
~wxTextInputStream();
wxTextInputStream(wxInputStream& s, const wxString &sep=wxT(" \t") );
~wxTextInputStream();
wxUint32 Read32();
wxUint16 Read16();
wxUint8 Read8();
double ReadDouble();
wxString ReadString(); // deprecated use ReadLine or ReadWord instead
wxString ReadLine();
wxString ReadWord();
wxUint32 Read32();
wxUint16 Read16();
wxUint8 Read8();
double ReadDouble();
wxString ReadString(); // deprecated use ReadLine or ReadWord instead
wxString ReadLine();
wxString ReadWord();
wxString GetStringSeparators() const { return m_separators;}
void SetStringSeparators(const wxString &c) { m_separators=c;}
wxString GetStringSeparators() const { return m_separators; }
void SetStringSeparators(const wxString &c) { m_separators = c; }
// Operators
wxTextInputStream& operator>>(wxString& word);
wxTextInputStream& operator>>(wxChar& c);
wxTextInputStream& operator>>(wxInt16& i);
wxTextInputStream& operator>>(wxInt32& i);
wxTextInputStream& operator>>(wxUint16& i);
wxTextInputStream& operator>>(wxUint32& i);
wxTextInputStream& operator>>(double& i);
wxTextInputStream& operator>>(float& f);
// Operators
wxTextInputStream& operator>>(wxString& word);
wxTextInputStream& operator>>(wxChar& c);
wxTextInputStream& operator>>(wxInt16& i);
wxTextInputStream& operator>>(wxInt32& i);
wxTextInputStream& operator>>(wxUint16& i);
wxTextInputStream& operator>>(wxUint32& i);
wxTextInputStream& operator>>(double& i);
wxTextInputStream& operator>>(float& f);
wxTextInputStream& operator>>( __wxTextInputManip func) { return func(*this); }
wxTextInputStream& operator>>( __wxTextInputManip func) { return func(*this); }
protected:
wxInputStream &m_input;
wxString m_separators;
protected:
wxInputStream &m_input;
wxString m_separators;
bool EatEOL(const wxChar &c);
wxChar NextNonSeparators();
void SkipIfEndOfLine( wxChar c );
bool EatEOL(const wxChar &c);
wxChar NextNonSeparators();
void SkipIfEndOfLine( wxChar c );
};
class WXDLLEXPORT wxTextOutputStream {
public:
wxTextOutputStream(wxOutputStream& s);
~wxTextOutputStream();
typedef enum {
wxEOL_NATIVE,
wxEOL_UNIX,
wxEOL_MAC,
wxEOL_DOS,
} wxEOL;
void Write32(wxUint32 i);
void Write16(wxUint16 i);
void Write8(wxUint8 i);
void WriteDouble(double d);
void WriteString(const wxString& string);
class WXDLLEXPORT wxTextOutputStream
{
public:
wxTextOutputStream( wxOutputStream& s, wxEOL mode = wxEOL_NATIVE );
virtual ~wxTextOutputStream();
wxTextOutputStream& operator<<(const wxChar *string);
wxTextOutputStream& operator<<(const wxString& string);
wxTextOutputStream& operator<<(wxChar c);
wxTextOutputStream& operator<<(wxInt16 c);
wxTextOutputStream& operator<<(wxInt32 c);
wxTextOutputStream& operator<<(wxUint16 c);
wxTextOutputStream& operator<<(wxUint32 c);
wxTextOutputStream& operator<<(double f);
wxTextOutputStream& operator<<(float f);
void SetMode( wxEOL mode = wxEOL_NATIVE );
wxEOL GetMode() { return m_mode; }
wxTextOutputStream& operator<<( __wxTextOutputManip func) { return func(*this); }
void Write32(wxUint32 i);
void Write16(wxUint16 i);
void Write8(wxUint8 i);
virtual void WriteDouble(double d);
virtual void WriteString(const wxString& string);
protected:
wxOutputStream &m_output;
wxTextOutputStream& operator<<(const wxChar *string);
wxTextOutputStream& operator<<(const wxString& string);
wxTextOutputStream& operator<<(wxChar c);
wxTextOutputStream& operator<<(wxInt16 c);
wxTextOutputStream& operator<<(wxInt32 c);
wxTextOutputStream& operator<<(wxUint16 c);
wxTextOutputStream& operator<<(wxUint32 c);
wxTextOutputStream& operator<<(double f);
wxTextOutputStream& operator<<(float f);
wxTextOutputStream& operator<<( __wxTextOutputManip func) { return func(*this); }
protected:
wxOutputStream &m_output;
wxEOL m_mode;
};
#endif

2
src/common/sizer.cpp
View File

@@ -469,7 +469,7 @@ void wxBoxSizer::RecalcSizes()
wxSize wxBoxSizer::CalcMin()
{
if (m_children.GetCount() == 0)
return wxSize(2,2);
return wxSize(10,10);
m_stretchable = 0;
m_minWidth = 0;

370
src/common/stream.cpp
View File

@@ -423,22 +423,25 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
off_t wxStreamBuffer::Tell() const
{
off_t pos;
if (m_flushable) {
pos = m_stream->OnSysTell();
off_t pos = m_stream->OnSysTell();
if (pos == wxInvalidOffset)
return wxInvalidOffset;
return pos - GetLastAccess() + GetIntPosition();
} else
return GetIntPosition();
return wxInvalidOffset;
pos += GetIntPosition();
if (m_mode == read && m_flushable)
pos -= GetLastAccess();
return pos;
}
size_t wxStreamBuffer::GetDataLeft()
{
if (m_buffer_end == m_buffer_pos && m_flushable)
FillBuffer();
return m_buffer_end-m_buffer_pos;
/* Why is this done? RR. */
if (m_buffer_end == m_buffer_pos && m_flushable)
FillBuffer();
return m_buffer_end-m_buffer_pos;
}
// ----------------------------------------------------------------------------
@@ -447,8 +450,8 @@ size_t wxStreamBuffer::GetDataLeft()
wxStreamBase::wxStreamBase()
{
m_lasterror = wxStream_NOERROR;
m_lastcount = 0;
m_lasterror = wxStream_NOERROR;
m_lastcount = 0;
}
wxStreamBase::~wxStreamBase()
@@ -457,22 +460,22 @@ wxStreamBase::~wxStreamBase()
size_t wxStreamBase::OnSysRead(void *WXUNUSED(buffer), size_t WXUNUSED(size))
{
return 0;
return 0;
}
size_t wxStreamBase::OnSysWrite(const void *WXUNUSED(buffer), size_t WXUNUSED(bufsize))
{
return 0;
return 0;
}
off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
{
return wxInvalidOffset;
return wxInvalidOffset;
}
off_t wxStreamBase::OnSysTell() const
{
return wxInvalidOffset;
return wxInvalidOffset;
}
// ----------------------------------------------------------------------------
@@ -493,153 +496,150 @@ wxInputStream::~wxInputStream()
char *wxInputStream::AllocSpaceWBack(size_t needed_size)
{
char *temp_b;
size_t toget;
/* get number of bytes left from previous wback buffer */
size_t toget = m_wbacksize - m_wbackcur;
/* get number of bytes left from previous wback buffer */
toget = m_wbacksize - m_wbackcur;
/* allocate a buffer large enough to hold prev + new data */
char *temp_b = (char *) malloc(needed_size + toget);
/* allocate a buffer large enough to hold prev + new data */
temp_b = (char *) malloc(needed_size + toget);
if (!temp_b)
return NULL;
if (!temp_b)
return NULL;
/* copy previous data (and free old buffer) if needed */
if (m_wback)
{
memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
free(m_wback);
}
/* copy previous data (and free old buffer) if needed */
if (m_wback)
{
memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
free(m_wback);
}
/* done */
m_wback = temp_b;
m_wbackcur = 0;
m_wbacksize = needed_size + toget;
/* done */
m_wback = temp_b;
m_wbackcur = 0;
m_wbacksize = needed_size + toget;
return (char *) m_wback;
return (char *) m_wback;
}
size_t wxInputStream::GetWBack(char *buf, size_t bsize)
{
size_t s_toget = m_wbacksize-m_wbackcur;
size_t s_toget = m_wbacksize-m_wbackcur;
if (!m_wback)
return 0;
if (!m_wback)
return 0;
if (bsize < s_toget)
s_toget = bsize;
if (bsize < s_toget)
s_toget = bsize;
memcpy(buf, (m_wback+m_wbackcur), s_toget);
memcpy(buf, (m_wback+m_wbackcur), s_toget);
m_wbackcur += s_toget;
if (m_wbackcur == m_wbacksize) {
free(m_wback);
m_wback = (char *)NULL;
m_wbacksize = 0;
m_wbackcur = 0;
}
m_wbackcur += s_toget;
if (m_wbackcur == m_wbacksize)
{
free(m_wback);
m_wback = (char *)NULL;
m_wbacksize = 0;
m_wbackcur = 0;
}
return s_toget;
return s_toget;
}
size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
{
char *ptrback;
char *ptrback = AllocSpaceWBack(bufsize);
if (!ptrback)
return 0;
ptrback = AllocSpaceWBack(bufsize);
if (!ptrback)
return 0;
memcpy(ptrback, buf, bufsize);
return bufsize;
memcpy(ptrback, buf, bufsize);
return bufsize;
}
bool wxInputStream::Ungetch(char c)
{
char *ptrback;
char * ptrback = AllocSpaceWBack(1);
if (!ptrback)
return FALSE;
ptrback = AllocSpaceWBack(1);
if (!ptrback)
return FALSE;
*ptrback = c;
return TRUE;
*ptrback = c;
return TRUE;
}
char wxInputStream::GetC()
{
char c;
Read(&c, 1);
return c;
char c;
Read(&c, 1);
return c;
}
wxInputStream& wxInputStream::Read(void *buffer, size_t size)
{
size_t retsize;
char *buf = (char *)buffer;
char *buf = (char *)buffer;
retsize = GetWBack(buf, size);
if (retsize == size) {
m_lastcount = size;
m_lasterror = wxStream_NOERROR;
size_t retsize = GetWBack(buf, size);
if (retsize == size)
{
m_lastcount = size;
m_lasterror = wxStream_NOERROR;
return *this;
}
size -= retsize;
buf += retsize;
m_lastcount = OnSysRead(buf, size) + retsize;
return *this;
}
size -= retsize;
buf += retsize;
m_lastcount = OnSysRead(buf, size) + retsize;
return *this;
}
char wxInputStream::Peek()
{
char c;
char c;
Read(&c, 1);
if (m_lasterror == wxStream_NOERROR)
{
Ungetch(c);
return c;
}
Read(&c, 1);
if (m_lasterror == wxStream_NOERROR) {
Ungetch(c);
return c;
}
return 0;
return 0;
}
wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
{
char buf[BUF_TEMP_SIZE];
size_t bytes_read = BUF_TEMP_SIZE;
char buf[BUF_TEMP_SIZE];
size_t bytes_read = BUF_TEMP_SIZE;
while (bytes_read == BUF_TEMP_SIZE) {
bytes_read = Read(buf, bytes_read).LastRead();
bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
}
return *this;
while (bytes_read == BUF_TEMP_SIZE)
{
bytes_read = Read(buf, bytes_read).LastRead();
bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
}
return *this;
}
off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
{
// Should be check and improve, just to remove a slight bug !
// I don't know whether it should be put as well in wxFileInputStream::OnSysSeek ?
if (m_lasterror==wxSTREAM_EOF)
m_lasterror=wxSTREAM_NOERROR;
/* Should be check and improve, just to remove a slight bug !
I don't know whether it should be put as well in wxFileInputStream::OnSysSeek ? */
if (m_lasterror==wxSTREAM_EOF)
m_lasterror=wxSTREAM_NOERROR;
// A call to SeekI() will automatically invalidate any previous call
// to Ungetch(), otherwise it would be possible to SeeI() to one
// one position, unread some bytes there, SeekI() to another position
// and the data would be corrupted.
if (m_wback) {
free(m_wback);
m_wback = (char*) NULL;
m_wbacksize = 0;
m_wbackcur = 0;
}
/* A call to SeekI() will automatically invalidate any previous call
to Ungetch(), otherwise it would be possible to SeekI() to one
one position, unread some bytes there, SeekI() to another position
and the data would be corrupted. */
if (m_wback)
{
free(m_wback);
m_wback = (char*) NULL;
m_wbacksize = 0;
m_wbackcur = 0;
}
return OnSysSeek(pos, mode);
return OnSysSeek(pos, mode);
}
off_t wxInputStream::TellI() const
{
return OnSysTell();
return OnSysTell();
}
// --------------------
@@ -649,9 +649,9 @@ off_t wxInputStream::TellI() const
#if wxUSE_SERIAL
wxInputStream& wxInputStream::operator>>(wxObject *& obj)
{
wxObjectInputStream obj_s(*this);
obj = obj_s.LoadObject();
return *this;
wxObjectInputStream obj_s(*this);
obj = obj_s.LoadObject();
return *this;
}
#endif
@@ -670,29 +670,29 @@ wxOutputStream::~wxOutputStream()
void wxOutputStream::PutC(char c)
{
Write((void *) &c, 1);
Write((void *) &c, 1);
}
wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
{
m_lastcount = OnSysWrite(buffer, size);
return *this;
m_lastcount = OnSysWrite(buffer, size);
return *this;
}
wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
{
stream_in.Read(*this);
return *this;
stream_in.Read(*this);
return *this;
}
off_t wxOutputStream::TellO() const
{
return OnSysTell();
return OnSysTell();
}
off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
{
return OnSysSeek(pos, mode);
return OnSysSeek(pos, mode);
}
void wxOutputStream::Sync()
@@ -702,9 +702,9 @@ void wxOutputStream::Sync()
#if wxUSE_SERIAL
wxOutputStream& wxOutputStream::operator<<(wxObject& obj)
{
wxObjectOutputStream obj_s(*this);
obj_s.SaveObject(obj);
return *this;
wxObjectOutputStream obj_s(*this);
obj_s.SaveObject(obj);
return *this;
}
#endif
@@ -715,43 +715,38 @@ wxOutputStream& wxOutputStream::operator<<(wxObject& obj)
wxCountingOutputStream::wxCountingOutputStream ()
: wxOutputStream()
{
m_currentPos = 0;
m_currentPos = 0;
}
size_t wxCountingOutputStream::GetSize() const
{
return m_lastcount;
return m_lastcount;
}
size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer), size_t size)
{
m_currentPos += size;
if (m_currentPos > m_lastcount) m_lastcount = m_currentPos;
return m_currentPos;
m_currentPos += size;
if (m_currentPos > m_lastcount) m_lastcount = m_currentPos;
return m_currentPos;
}
off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
{
if (mode == wxFromStart)
{
m_currentPos = pos;
}
if (mode == wxFromEnd)
{
m_currentPos = m_lastcount + pos;
}
else
{
m_currentPos += pos;
}
if (m_currentPos > m_lastcount) m_lastcount = m_currentPos;
if (mode == wxFromStart)
m_currentPos = pos;
if (mode == wxFromEnd)
m_currentPos = m_lastcount + pos;
else
m_currentPos += pos;
return m_currentPos; // ?
if (m_currentPos > m_lastcount) m_lastcount = m_currentPos;
return m_currentPos;
}
off_t wxCountingOutputStream::OnSysTell() const
{
return m_currentPos; // ?
return m_currentPos;
}
// ----------------------------------------------------------------------------
@@ -766,7 +761,7 @@ wxFilterInputStream::wxFilterInputStream()
wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
: wxInputStream()
{
m_parent_i_stream = &stream;
m_parent_i_stream = &stream;
}
wxFilterInputStream::~wxFilterInputStream()
@@ -784,7 +779,7 @@ wxFilterOutputStream::wxFilterOutputStream()
wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
: wxOutputStream()
{
m_parent_o_stream = &stream;
m_parent_o_stream = &stream;
}
wxFilterOutputStream::~wxFilterOutputStream()
@@ -797,67 +792,69 @@ wxFilterOutputStream::~wxFilterOutputStream()
wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s)
: wxFilterInputStream(s)
{
m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
m_i_streambuf->SetBufferIO(1024);
m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
m_i_streambuf->SetBufferIO(1024);
}
wxBufferedInputStream::~wxBufferedInputStream()
{
off_t unused_bytes=m_i_streambuf->GetBufferPos()-m_i_streambuf->GetBufferEnd();
m_parent_i_stream->SeekI(unused_bytes,wxFromCurrent);
off_t unused_bytes=m_i_streambuf->GetBufferPos()-m_i_streambuf->GetBufferEnd();
m_parent_i_stream->SeekI(unused_bytes,wxFromCurrent);
delete m_i_streambuf;
delete m_i_streambuf;
}
char wxBufferedInputStream::Peek()
{
return m_i_streambuf->Peek();
return m_i_streambuf->Peek();
}
wxInputStream& wxBufferedInputStream::Read(void *buffer, size_t size)
{
size_t retsize;
char *buf = (char *)buffer;
size_t retsize;
char *buf = (char *)buffer;
retsize = GetWBack(buf, size);
m_lastcount = retsize;
if (retsize == size)
{
m_lasterror = wxStream_NOERROR;
return *this;
}
size -= retsize;
buf += retsize;
m_i_streambuf->Read(buf, size);
retsize = GetWBack(buf, size);
m_lastcount = retsize;
if (retsize == size) {
m_lasterror = wxStream_NOERROR;
return *this;
}
size -= retsize;
buf += retsize;
m_i_streambuf->Read(buf, size);
return *this;
}
off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
{
return m_i_streambuf->Seek(pos, mode);
return m_i_streambuf->Seek(pos, mode);
}
off_t wxBufferedInputStream::TellI() const
{
return m_i_streambuf->Tell();
return m_i_streambuf->Tell();
}
size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
{
return m_parent_i_stream->Read(buffer, bufsize).LastRead();
return m_parent_i_stream->Read(buffer, bufsize).LastRead();
}
off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
{
return m_parent_i_stream->SeekI(seek, mode);
return m_parent_i_stream->SeekI(seek, mode);
}
off_t wxBufferedInputStream::OnSysTell() const
{
return m_parent_i_stream->TellI();
return m_parent_i_stream->TellI();
}
// ----------------------------------------------------------------------------
// wxBufferedOutputStream
// ----------------------------------------------------------------------------
@@ -865,53 +862,58 @@ off_t wxBufferedInputStream::OnSysTell() const
wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s)
: wxFilterOutputStream(s)
{
m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
m_o_streambuf->SetBufferIO(1024);
m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
m_o_streambuf->SetBufferIO(1024);
}
wxBufferedOutputStream::~wxBufferedOutputStream()
{
Sync();
delete m_o_streambuf;
Sync();
delete m_o_streambuf;
}
wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
{
m_lastcount = 0;
m_o_streambuf->Write(buffer, size);
return *this;
m_lastcount = 0;
m_o_streambuf->Write(buffer, size);
return *this;
}
off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
{
Sync();
return m_o_streambuf->Seek(pos, mode);
Sync();
return m_o_streambuf->Seek(pos, mode);
}
off_t wxBufferedOutputStream::TellO() const
{
return m_o_streambuf->Tell();
return m_o_streambuf->Tell();
}
void wxBufferedOutputStream::Sync()
{
m_o_streambuf->FlushBuffer();
m_parent_o_stream->Sync();
m_o_streambuf->FlushBuffer();
m_parent_o_stream->Sync();
}
size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
{
return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
}
off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
{
return m_parent_o_stream->SeekO(seek, mode);
return m_parent_o_stream->SeekO(seek, mode);
}
off_t wxBufferedOutputStream::OnSysTell() const
{
return m_parent_o_stream->TellO();
return m_parent_o_stream->TellO();
}
size_t wxBufferedOutputStream::GetSize() const
{
return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
}
// ----------------------------------------------------------------------------

63
src/common/txtstrm.cpp
View File

@@ -323,15 +323,41 @@ wxTextInputStream& wxTextInputStream::operator>>(float& f)
return *this;
}
wxTextOutputStream::wxTextOutputStream(wxOutputStream& s)
wxTextOutputStream::wxTextOutputStream(wxOutputStream& s, wxEOL mode)
: m_output(s)
{
m_mode = mode;
if (m_mode == wxEOL_NATIVE)
{
#if defined(__WXMSW__) || defined(__WXPM__)
m_mode = wxEOL_DOS;
#elif defined(__WXMAC__)
m_mode = wxEOL_MAC;
#else
m_mode = wxEOL_UNIX;
#endif
}
}
wxTextOutputStream::~wxTextOutputStream()
{
}
void wxTextOutputStream::SetMode( wxEOL mode = wxEOL_NATIVE )
{
m_mode = mode;
if (m_mode == wxEOL_NATIVE)
{
#if defined(__WXMSW__) || defined(__WXPM__)
m_mode = wxEOL_DOS;
#elif defined(__WXMAC__)
m_mode = wxEOL_MAC;
#else
m_mode = wxEOL_UNIX;
#endif
}
}
void wxTextOutputStream::Write32(wxUint32 i)
{
wxString str;
@@ -371,25 +397,22 @@ void wxTextOutputStream::WriteString(const wxString& string)
wxChar c = string[i];
if (c == wxT('\n'))
{
#if defined(__WINDOWS__)
c = wxT('\r');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
c = wxT('\n');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
#elif defined(__UNIX__)
c = wxT('\n');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
#elif defined(__WXMAC__)
c = wxT('\r');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
#elif defined(__OS2__)
c = wxT('\r');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
c = wxT('\n');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
#else
#error "wxTextOutputStream: unsupported platform."
#endif
if (m_mode == wxEOL_DOS)
{
c = wxT('\r');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
c = wxT('\n');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
} else
if (m_mode == wxEOL_MAC)
{
c = wxT('\r');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
} else
{
c = wxT('\n');
m_output.Write( (const void*)(&c), sizeof(wxChar) );
}
}
else
{

27
src/generic/treectrl.cpp
View File

@@ -298,11 +298,8 @@ wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
m_attr = (wxTreeItemAttr *)NULL;
dc.GetTextExtent( m_text, &m_width, &m_height );
// TODO : Add the width of the image
// PB : We don't know which image is shown (image, selImage)
// We don't even know imageList from the treectrl this item belongs to !!!
// At this point m_width doesn't mean much, this can be remove !
m_width = 0;
m_height = 0;
}
wxGenericTreeItem::~wxGenericTreeItem()
@@ -1327,21 +1324,23 @@ void wxTreeCtrl::ScrollTo(const wxTreeItemId &item)
int y = 0;
m_anchor->GetSize( x, y, this );
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
int x_pos = GetScrollPos( wxHORIZONTAL );
// Item should appear at top
SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
}
else if (item_y+GetLineHeight(gitem) > start_y+client_h)
{
// going up
int x = 0;
int y = 0;
m_anchor->GetSize( x, y, this );
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
item_y += PIXELS_PER_UNIT+2;
int x_pos = GetScrollPos( wxHORIZONTAL );
// going up
int x = 0;
int y = 0;
m_anchor->GetSize( x, y, this );
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
item_y += PIXELS_PER_UNIT+2;
int x_pos = GetScrollPos( wxHORIZONTAL );
// Item should appear at bottom
SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, (item_y+GetLineHeight(gitem)-client_h)/PIXELS_PER_UNIT );
SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, (item_y+GetLineHeight(gitem)-client_h)/PIXELS_PER_UNIT );
}
}
@@ -1435,8 +1434,8 @@ void wxTreeCtrl::AdjustMyScrollbars()
int x = 0;
int y = 0;
m_anchor->GetSize( x, y, this );
//y += GetLineHeight(m_anchor);
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
int x_pos = GetScrollPos( wxHORIZONTAL );
int y_pos = GetScrollPos( wxVERTICAL );
SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );