]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/stream.cpp
implemented menu drawing in the GTK theme
[wxWidgets.git] / src / common / stream.cpp
index 9c006b8f7ad4133686cc0fb8dddfc0d6150bc40a..88a8ccc79023ebad60f7d25503d281a97b74c90c 100644 (file)
@@ -38,8 +38,8 @@
 #include <ctype.h>
 #include "wx/stream.h"
 #include "wx/datstrm.h"
 #include <ctype.h>
 #include "wx/stream.h"
 #include "wx/datstrm.h"
-#include "wx/objstrm.h"
 #include "wx/textfile.h"
 #include "wx/textfile.h"
+#include "wx/log.h"
 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants
@@ -69,8 +69,8 @@ void wxStreamBuffer::InitBuffer()
     m_buffer_pos = NULL;
     m_buffer_size = 0;
 
     m_buffer_pos = NULL;
     m_buffer_size = 0;
 
-    // there is nothing to destroy anyhow
-    m_destroybuf = FALSE;
+    // if we are going to allocate the buffer, we should free it later as well
+    m_destroybuf = TRUE;
 }
 
 void wxStreamBuffer::Init()
 }
 
 void wxStreamBuffer::Init()
@@ -95,7 +95,14 @@ wxStreamBuffer::wxStreamBuffer(BufMode mode)
 {
     Init();
 
 {
     Init();
 
-    m_stream = new wxStreamBase;
+    wxASSERT_MSG(mode != read_write, wxT("you have to use the other ctor for read_write mode") );
+    if ( mode == read )
+        m_stream = new wxInputStream;
+    else if ( mode == write)
+        m_stream = new wxOutputStream;
+    else
+        m_stream = NULL;
+
     m_mode = mode;
 
     m_flushable = FALSE;
     m_mode = mode;
 
     m_flushable = FALSE;
@@ -696,14 +703,14 @@ char *wxInputStream::AllocSpaceWBack(size_t needed_size)
     if (!temp_b)
         return NULL;
 
     if (!temp_b)
         return NULL;
 
-    /* copy previous data (and free old buffer) if needed */
+    // 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);
     }
 
     if (m_wback)
     {
         memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
         free(m_wback);
     }
 
-    /* done */
+    // done
     m_wback = temp_b;
     m_wbackcur = 0;
     m_wbacksize = needed_size + toget;
     m_wback = temp_b;
     m_wbackcur = 0;
     m_wbacksize = needed_size + toget;
@@ -713,25 +720,32 @@ char *wxInputStream::AllocSpaceWBack(size_t needed_size)
 
 size_t wxInputStream::GetWBack(void *buf, size_t bsize)
 {
 
 size_t wxInputStream::GetWBack(void *buf, size_t bsize)
 {
-    size_t toget = m_wbacksize-m_wbackcur;
-
     if (!m_wback)
         return 0;
 
     if (!m_wback)
         return 0;
 
-    if (bsize < toget)
-       toget = bsize;
+    // how many bytes do we have in the buffer?
+    size_t toget = m_wbacksize - m_wbackcur;
 
 
-    memcpy(buf, (m_wback+m_wbackcur), toget);
+    if ( bsize < toget )
+    {
+        // we won't read everything
+        toget = bsize;
+    }
+
+    // copy the data from the cache 
+    memcpy(buf, m_wback + m_wbackcur, toget);
 
     m_wbackcur += toget;
 
     m_wbackcur += toget;
-    if (m_wbackcur == m_wbacksize)
+    if ( m_wbackcur == m_wbacksize )
     {
     {
+        // TODO: should we really free it here all the time? maybe keep it?
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
 
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
 
+    // return the number of bytes copied
     return toget;
 }
 
     return toget;
 }
 
@@ -806,23 +820,29 @@ wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 
 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 !
-       I don't know whether it should be put as well in wxFileInputStream::OnSysSeek ? */
+    // RR: This code is duplicated in wxBufferedInputStream. This is
+    // not really a good design, but buffered stream are different
+    // from all other in that they handle two stream-related objects,
+    // the stream buffer and parent stream.
+
+    // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
     if (m_lasterror==wxSTREAM_EOF)
         m_lasterror=wxSTREAM_NOERROR;
 
     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 SeekI() to one
+    /* RR: A call to SeekI() will automatically invalidate any previous
+       call to Ungetch(), otherwise it would be possible to SeekI() to
        one position, unread some bytes there, SeekI() to another position
        and the data would be corrupted.
 
        GRG: Could add code here to try to navigate within the wback
        buffer if possible, but is it really needed? It would only work
        when seeking in wxFromCurrent mode, else it would invalidate
        one position, unread some bytes there, SeekI() to another position
        and the data would be corrupted.
 
        GRG: Could add code here to try to navigate within the wback
        buffer if possible, but is it really needed? It would only work
        when seeking in wxFromCurrent mode, else it would invalidate
-       anyway...
-     */
+       anyway... */
+       
     if (m_wback)
     {
     if (m_wback)
     {
+        wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
+        
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
@@ -834,7 +854,6 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
 
 off_t wxInputStream::TellI() const
 {
 
 off_t wxInputStream::TellI() const
 {
-    /* GRG: Changed to make it compatible with the wback buffer */
     off_t pos = OnSysTell();
 
     if (pos != wxInvalidOffset)
     off_t pos = OnSysTell();
 
     if (pos != wxInvalidOffset)
@@ -843,19 +862,6 @@ off_t wxInputStream::TellI() const
     return pos;
 }
 
     return pos;
 }
 
-// --------------------
-// Overloaded operators
-// --------------------
-
-#if wxUSE_SERIAL
-wxInputStream& wxInputStream::operator>>(wxObject *& obj)
-{
-    wxObjectInputStream obj_s(*this);
-    obj = obj_s.LoadObject();
-    return *this;
-}
-#endif // wxUSE_SERIAL
-
 
 // ----------------------------------------------------------------------------
 // wxOutputStream
 
 // ----------------------------------------------------------------------------
 // wxOutputStream
@@ -906,14 +912,6 @@ void wxOutputStream::Sync()
 {
 }
 
 {
 }
 
-#if wxUSE_SERIAL
-wxOutputStream& wxOutputStream::operator<<(wxObject& obj)
-{
-    wxObjectOutputStream obj_s(*this);
-    obj_s.SaveObject(obj);
-    return *this;
-}
-#endif // wxUSE_SERIAL
 
 // ----------------------------------------------------------------------------
 // wxCountingOutputStream
 
 // ----------------------------------------------------------------------------
 // wxCountingOutputStream
@@ -1043,31 +1041,58 @@ char wxBufferedInputStream::Peek()
 
 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
 {
 
 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
 {
-    size_t retsize;
+    // reset the error flag
+    m_lasterror = wxStream_NOERROR;
+
+    // first read from the already cached data
+    m_lastcount = GetWBack(buf, size);
 
 
-    retsize = GetWBack(buf, size);
-    m_lastcount = retsize;
-    if ( retsize == size )
+    // do we have to read anything more?
+    if ( m_lastcount < size )
     {
     {
-        m_lasterror = wxStream_NOERROR;
-        return *this;
-    }
-    size -= retsize;
-    buf = (char *)buf + retsize;
+        size -= m_lastcount;
+        buf = (char *)buf + m_lastcount;
 
 
-    m_i_streambuf->Read(buf, size);
+        // the call to wxStreamBuffer::Read() below will reset our m_lastcount,
+        // so save it
+        size_t countOld = m_lastcount;
+
+        m_i_streambuf->Read(buf, size);
+
+        m_lastcount += countOld;
+    }
 
     return *this;
 }
 
 off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
 {
 
     return *this;
 }
 
 off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
 {
+    // RR: Look at wxInputStream for comments.
+
+    if (m_lasterror==wxSTREAM_EOF)
+        m_lasterror=wxSTREAM_NOERROR;
+
+    if (m_wback)
+    {
+        wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
+        
+        free(m_wback);
+        m_wback = NULL;
+        m_wbacksize = 0;
+        m_wbackcur = 0;
+    }
+    
     return m_i_streambuf->Seek(pos, mode);
 }
 
 off_t wxBufferedInputStream::TellI() const
 {
     return m_i_streambuf->Seek(pos, mode);
 }
 
 off_t wxBufferedInputStream::TellI() const
 {
-    return m_i_streambuf->Tell();
+    off_t pos = m_i_streambuf->Tell();
+
+    if (pos != wxInvalidOffset)
+        pos -= (m_wbacksize - m_wbackcur);
+        
+    return pos;
 }
 
 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
 }
 
 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)