The use of wxPopupWindow fo rhte autocomplete and calltip windows is

[wxWidgets.git] / include / wx / buffer.h

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index c2aaa0c09b727ef7289ece05c2a3d4526bda9aad..9415229b9c236412ab37e226ec19d73128c53011 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -27,12 +27,14 @@ class wxCharBuffer
 {
 public:
     wxCharBuffer(const char *str)
 {
 public:
     wxCharBuffer(const char *str)

+        : m_str(NULL)

     {
         wxASSERT_MSG( str, wxT("NULL string in wxCharBuffer") );
 
         m_str = str ? strdup(str) : (char *)NULL;
     }
     wxCharBuffer(size_t len)
     {
         wxASSERT_MSG( str, wxT("NULL string in wxCharBuffer") );
 
         m_str = str ? strdup(str) : (char *)NULL;
     }
     wxCharBuffer(size_t len)

+        : m_str(NULL)

     {
         m_str = (char *)malloc(len+1);
         m_str[len] = '\0';
     {
         m_str = (char *)malloc(len+1);
         m_str[len] = '\0';


@@ -41,17 +43,17 @@ public:
    ~wxCharBuffer() { free(m_str); }
 
    wxCharBuffer(const wxCharBuffer& src)
    ~wxCharBuffer() { free(m_str); }
 
    wxCharBuffer(const wxCharBuffer& src)

+       : m_str(src.m_str)

    {
    {

-     m_str = src.m_str;
-     // no reference count yet...
-     ((wxCharBuffer*)&src)->m_str = (char *)NULL;
+       // no reference count yet...
+       ((wxCharBuffer*)&src)->m_str = (char *)NULL;

    }
    wxCharBuffer& operator=(const wxCharBuffer& src)
    {
    }
    wxCharBuffer& operator=(const wxCharBuffer& src)
    {

-     m_str = src.m_str;
-     // no reference count yet...
-     ((wxCharBuffer*)&src)->m_str = (char *)NULL;
-     return *this;
+       m_str = src.m_str;
+       // no reference count yet...
+       ((wxCharBuffer*)&src)->m_str = (char *)NULL;
+       return *this;

    }
 
    const char *data() const { return m_str; }
    }
 
    const char *data() const { return m_str; }


@@ -67,6 +69,7 @@ class wxWCharBuffer
 {
 public:
     wxWCharBuffer(const wchar_t *wcs)
 {
 public:
     wxWCharBuffer(const wchar_t *wcs)

+        : m_wcs((wchar_t *)NULL)

     {
         wxASSERT_MSG( wcs, wxT("NULL string in wxWCharBuffer") );
 
     {
         wxASSERT_MSG( wcs, wxT("NULL string in wxWCharBuffer") );
 


@@ -80,9 +83,9 @@ public:
           m_wcs = (wchar_t *)malloc(siz);
           memcpy(m_wcs, wcs, siz);
         }
           m_wcs = (wchar_t *)malloc(siz);
           memcpy(m_wcs, wcs, siz);
         }

-        else m_wcs = (wchar_t *)NULL;

     }
     wxWCharBuffer(size_t len)
     }
     wxWCharBuffer(size_t len)

+        : m_wcs((wchar_t *)NULL)

     {
         m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t));
         m_wcs[len] = L'\0';
     {
         m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t));
         m_wcs[len] = L'\0';


@@ -92,17 +95,17 @@ public:
    ~wxWCharBuffer() { free(m_wcs); }
 
    wxWCharBuffer(const wxWCharBuffer& src)
    ~wxWCharBuffer() { free(m_wcs); }
 
    wxWCharBuffer(const wxWCharBuffer& src)

+       : m_wcs(src.m_wcs)

    {
    {

-     m_wcs = src.m_wcs;
-     // no reference count yet...
-     ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
+       // no reference count yet...
+       ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;

    }
    wxWCharBuffer& operator=(const wxWCharBuffer& src)
    {
    }
    wxWCharBuffer& operator=(const wxWCharBuffer& src)
    {

-     m_wcs = src.m_wcs;
-     // no reference count yet...
-     ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
-     return *this;
+       m_wcs = src.m_wcs;
+       // no reference count yet...
+       ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
+       return *this;

    }
 
    const wchar_t *data() const { return m_wcs; }
    }
 
    const wchar_t *data() const { return m_wcs; }


@@ -126,6 +129,116 @@ private:
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 

+
+
+// ----------------------------------------------------------------------------
+// A class for holding growable data buffers (not necessarily strings)
+// ----------------------------------------------------------------------------
+
+class wxMemoryBuffer
+{
+public:
+    enum { BLOCK_SIZE = 1024 };
+    wxMemoryBuffer(size_t size=wxMemoryBuffer::BLOCK_SIZE)
+        : m_data(NULL), m_size(0), m_len(0)
+    {
+        wxASSERT(size > 0);
+        m_data = malloc(size);
+        wxASSERT(m_data != NULL);
+        m_size = size;
+    }
+
+    ~wxMemoryBuffer() { free(m_data); }
+
+    // Accessors
+    void*  GetData() const    { return m_data; }
+    size_t GetBufSize() const { return m_size; }
+    size_t GetDataLen() const { return m_len; }
+
+    void   SetBufSize(size_t size) { ResizeIfNeeded(size); }
+    void   SetDataLen(size_t len)
+    {
+        wxASSERT(len <= m_size);
+        m_len = len;
+    }
+
+    // Ensure the buffer is big enough and return a pointer to it
+    void* GetWriteBuf(size_t sizeNeeded)
+    {
+        ResizeIfNeeded(sizeNeeded);
+        return m_data;
+    }
+    // Update the length after the write
+    void  UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }
+
+    // Like the above, but appends to the buffer
+    void* GetAppendBuf(size_t sizeNeeded)
+    {
+        ResizeIfNeeded(m_len + sizeNeeded);
+        return (char*)m_data + m_len;
+    }
+    void  UngetAppendBuf(size_t sizeUsed) { SetDataLen(m_len + sizeUsed); }
+
+    // Other ways to append to the buffer
+    void  AppendByte(char data) {
+        ResizeIfNeeded(m_len + 1);
+        *(((char*)m_data)+m_len) = data;
+        m_len += 1;
+    }
+    void  AppendData(void* data, size_t len)
+    {
+        memcpy(GetAppendBuf(len), data, len);
+        UngetAppendBuf(len);
+    }
+
+    operator const char *() const { return (const char*)m_data; }
+
+
+    // Copy and assignment
+    wxMemoryBuffer(const wxMemoryBuffer& src)
+        : m_data(src.m_data), m_size(src.m_size), m_len(src.m_len)
+    {
+        // no reference count yet...
+        ((wxMemoryBuffer*)&src)->m_data = NULL;
+        ((wxMemoryBuffer*)&src)->m_size = 0;
+        ((wxMemoryBuffer*)&src)->m_len  = 0;
+    }
+
+    wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
+    {
+        m_data = src.m_data;
+        m_size = src.m_size;
+        m_len  = src.m_len;
+        
+        // no reference count yet...
+        ((wxMemoryBuffer*)&src)->m_data = NULL;
+        ((wxMemoryBuffer*)&src)->m_size = 0;
+        ((wxMemoryBuffer*)&src)->m_len  = 0;
+
+        return *this;
+   }
+
+
+protected:
+
+    void ResizeIfNeeded(size_t newSize)
+    {
+        if (newSize > m_size)
+        {
+            m_data = realloc(m_data, newSize + wxMemoryBuffer::BLOCK_SIZE);
+            wxASSERT(m_data != NULL);
+            m_size = newSize + wxMemoryBuffer::BLOCK_SIZE;
+        }
+    }
+
+private:
+    void*       m_data;
+    size_t      m_size;
+    size_t      m_len;
+};
+
+
+

 // ----------------------------------------------------------------------------
 // template class for any kind of data
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // template class for any kind of data
 // ----------------------------------------------------------------------------