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

111
include/wx/txtstrm.h
View File

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

2
src/common/sizer.cpp
View File

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

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

29
src/generic/treectrl.cpp
View File

@@ -297,12 +297,9 @@ wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
m_parent = parent; m_parent = parent;
m_attr = (wxTreeItemAttr *)NULL; m_attr = (wxTreeItemAttr *)NULL;
dc.GetTextExtent( m_text, &m_width, &m_height ); m_width = 0;
// TODO : Add the width of the image m_height = 0;
// 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 !
} }
wxGenericTreeItem::~wxGenericTreeItem() wxGenericTreeItem::~wxGenericTreeItem()
@@ -1327,21 +1324,23 @@ void wxTreeCtrl::ScrollTo(const wxTreeItemId &item)
int y = 0; int y = 0;
m_anchor->GetSize( x, y, this ); m_anchor->GetSize( x, y, this );
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels 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 x_pos = GetScrollPos( wxHORIZONTAL );
// Item should appear at top // 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 ); 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) else if (item_y+GetLineHeight(gitem) > start_y+client_h)
{ {
// going up // going up
int x = 0; int x = 0;
int y = 0; int y = 0;
m_anchor->GetSize( x, y, this ); m_anchor->GetSize( x, y, this );
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
item_y += PIXELS_PER_UNIT+2; x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
int x_pos = GetScrollPos( wxHORIZONTAL ); item_y += PIXELS_PER_UNIT+2;
int x_pos = GetScrollPos( wxHORIZONTAL );
// Item should appear at bottom // 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 x = 0;
int y = 0; int y = 0;
m_anchor->GetSize( x, y, this ); m_anchor->GetSize( x, y, this );
//y += GetLineHeight(m_anchor);
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels 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 x_pos = GetScrollPos( wxHORIZONTAL );
int y_pos = GetScrollPos( wxVERTICAL ); int y_pos = GetScrollPos( wxVERTICAL );
SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos ); SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );