added alpha channel support to wxDFB's wxBitmap

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

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index 59a7ad6c35de5e5dd713f2848bfe9a22ede9de02..8e7fd8dbb16e146f810ca11745d6831b0c3c09ad 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -12,14 +12,12 @@
 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 
-#include "wx/wxchar.h"
+#include "wx/chartype.h"
+#include "wx/wxcrtbase.h"
 
 #include <stdlib.h>             // malloc() and free()
 
-inline char *wxStrDup(const char *s) { return wxStrdupA(s); }
-#if wxUSE_WCHAR_T
-    inline wchar_t *wxStrDup(const wchar_t *ws) { return wxStrdupW(ws); }
-#endif
+class WXDLLIMPEXP_BASE wxCStrData;
 
 // ----------------------------------------------------------------------------
 // Special classes for (wide) character strings: they use malloc/free instead
@@ -33,18 +31,32 @@ public:
     typedef T CharType;
 
     wxCharTypeBuffer(const CharType *str = NULL)
-        : m_str(str ? wxStrDup(str) : NULL)
+        : m_str(str ? wxStrdup(str) : NULL),
+          m_owned(true)
     {
     }
 
     wxCharTypeBuffer(size_t len)
-        : m_str((CharType *)malloc((len + 1)*sizeof(CharType)))
+        : m_str((CharType *)malloc((len + 1)*sizeof(CharType))),
+          m_owned(true)
     {
         m_str[len] = (CharType)0;
     }
 
+    static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
+    {
+        wxCharTypeBuffer buf;
+        buf.m_str = wx_const_cast(CharType*, str);
+        buf.m_owned = false;
+        return buf;
+    }
+
     /* no need to check for NULL, free() does it */
-    ~wxCharTypeBuffer() { free(m_str); }
+    ~wxCharTypeBuffer()
+    {
+        if ( m_owned)
+            free(m_str);
+    }
 
     /*
         WARNING:
@@ -55,7 +67,7 @@ public:
         a) it shouldn't be really const
         b) you shouldn't use it afterwards (or know that it was reset)
 
-        This is very ugly but is unfortunately needed to make the normal use\
+        This is very ugly but is unfortunately needed to make the normal use
         of wxCharTypeBuffer buffer objects possible and is very similar to what
         std::auto_ptr<> does (as if it were an excuse...)
     */
@@ -66,39 +78,43 @@ public:
      */
     CharType *release() const
     {
-        CharType *p = m_str;
-        ((wxCharTypeBuffer *)this)->m_str = NULL;
-        return p;
+        wxASSERT_MSG( m_owned, _T("can't release non-owned buffer") );
+        return DoRelease();
     }
 
     void reset()
     {
-        free(m_str);
+        if ( m_owned )
+            free(m_str);
         m_str = NULL;
     }
 
     wxCharTypeBuffer(const wxCharTypeBuffer& src)
-        : m_str(src.release())
     {
+        CopyFrom(src);
     }
 
     wxCharTypeBuffer& operator=(const CharType *str)
     {
-        free(m_str);
-        m_str = str ? wxStrDup(str) : NULL;
+        if ( m_owned )
+            free(m_str);
+        m_str = str ? wxStrdup(str) : NULL;
+        m_owned = true;
         return *this;
     }
 
     wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
     {
-        free(m_str);
-        m_str = src.release();
-
+        if ( m_owned )
+            free(m_str);
+        CopyFrom(src);
         return *this;
     }
 
     bool extend(size_t len)
     {
+        wxASSERT_MSG( m_owned, _T("cannot extend non-owned buffer") );
+
         CharType *
             str = (CharType *)realloc(m_str, (len + 1)*sizeof(CharType));
         if ( !str )
@@ -114,15 +130,34 @@ public:
     operator const CharType *() const { return m_str; }
     CharType operator[](size_t n) const { return m_str[n]; }
 
+
+private:
+    CharType *DoRelease() const
+    {
+        CharType *p = m_str;
+        ((wxCharTypeBuffer *)this)->m_str = NULL;
+        return p;
+    }
+
+    void CopyFrom(const wxCharTypeBuffer& src)
+    {
+        m_owned = src.m_owned;
+        m_str = src.DoRelease();
+    }
+
 private:
     CharType *m_str;
+    bool m_owned;
 };
 
-class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
+class wxCharBuffer : public wxCharTypeBuffer<char>
 {
 public:
     typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
 
+    wxCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
     wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
@@ -130,11 +165,14 @@ public:
 };
 
 #if wxUSE_WCHAR_T
-class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
+class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
 {
 public:
     typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
 
+    wxWCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
     wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
@@ -168,8 +206,13 @@ typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
 
     #define wxMB2WXbuf wxWCharBuffer
     #define wxWX2MBbuf wxCharBuffer
-    #define wxWC2WXbuf wxChar*
-    #define wxWX2WCbuf wxChar*
+    #if wxUSE_UNICODE_WCHAR
+        #define wxWC2WXbuf wxChar*
+        #define wxWX2WCbuf wxChar*
+    #elif wxUSE_UNICODE_UTF8
+        #define wxWC2WXbuf wxWCharBuffer
+        #define wxWX2WCbuf wxWCharBuffer
+    #endif
 #else // ANSI
     #define wxWxCharBuffer wxCharBuffer