don't test for things which bakefile already tests for (STRIP, RANLIB, INSTALL, WINDR...

[wxWidgets.git] / src / common / variant.cpp

diff --git a/src/common/variant.cpp b/src/common/variant.cpp
index df261de03f2f1b867779335845c0cb8b8b78555c..65fbed6a4f7d0b735336609d6a3c812ddace194f 100644 (file)
--- a/src/common/variant.cpp
+++ b/src/common/variant.cpp
@@ -23,6 +23,7 @@
 #ifndef WX_PRECOMP
     #include "wx/string.h"
     #include "wx/math.h"
 #ifndef WX_PRECOMP
     #include "wx/string.h"
     #include "wx/math.h"

+    #include "wx/crt.h"

     #if wxUSE_STREAMS
         #include "wx/stream.h"
     #endif
     #if wxUSE_STREAMS
         #include "wx/stream.h"
     #endif


@@ -226,7 +227,7 @@ public:
     virtual bool Write(wxOutputStream &str) const;
 #endif // wxUSE_STREAMS
 
     virtual bool Write(wxOutputStream &str) const;
 #endif // wxUSE_STREAMS
 

-    virtual wxString GetType() const { return wxT("long"); };
+    virtual wxString GetType() const { return wxT("long"); }

 
 protected:
     long m_value;
 
 protected:
     long m_value;


@@ -286,11 +287,11 @@ bool wxVariantDataLong::Read(wxInputStream& str)
 
 bool wxVariantDataLong::Read(wxString& str)
 {
 
 bool wxVariantDataLong::Read(wxString& str)
 {

-    m_value = wxAtol((const wxChar*) str);
+    m_value = wxAtol(str);

     return true;
 }
 
     return true;
 }
 

-// wxVariant 
+// wxVariant

 
 wxVariant::wxVariant(long val, const wxString& name)
 {
 
 wxVariant::wxVariant(long val, const wxString& name)
 {


@@ -377,7 +378,7 @@ public:
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream &str) const;
 #endif // wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream &str) const;
 #endif // wxUSE_STREAMS

-    virtual wxString GetType() const { return wxT("double"); };
+    virtual wxString GetType() const { return wxT("double"); }

 
 protected:
     double m_value;
 
 protected:
     double m_value;


@@ -436,7 +437,7 @@ bool wxVariantDoubleData::Read(wxInputStream& str)
 
 bool wxVariantDoubleData::Read(wxString& str)
 {
 
 bool wxVariantDoubleData::Read(wxString& str)
 {

-    m_value = wxAtof((const wxChar*) str);
+    m_value = wxAtof(str);

     return true;
 }
 
     return true;
 }
 


@@ -517,7 +518,7 @@ public:
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream& str) const;
 #endif // wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream& str) const;
 #endif // wxUSE_STREAMS

-    virtual wxString GetType() const { return wxT("bool"); };
+    virtual wxString GetType() const { return wxT("bool"); }

 
 protected:
     bool m_value;
 
 protected:
     bool m_value;


@@ -579,7 +580,7 @@ bool wxVariantDataBool::Read(wxInputStream& str)
 
 bool wxVariantDataBool::Read(wxString& str)
 {
 
 bool wxVariantDataBool::Read(wxString& str)
 {

-    m_value = (wxAtol((const wxChar*) str) != 0);
+    m_value = (wxAtol(str) != 0);

     return true;
 }
 
     return true;
 }
 


@@ -642,10 +643,10 @@ class WXDLLIMPEXP_BASE wxVariantDataChar: public wxVariantData
 DECLARE_DYNAMIC_CLASS(wxVariantDataChar)
 public:
     wxVariantDataChar() { m_value = 0; }
 DECLARE_DYNAMIC_CLASS(wxVariantDataChar)
 public:
     wxVariantDataChar() { m_value = 0; }

-    wxVariantDataChar(wxChar value) { m_value = value; }
+    wxVariantDataChar(const wxUniChar& value) { m_value = value; }

 
 

-    inline wxChar GetValue() const { return m_value; }
-    inline void SetValue(wxChar value) { m_value = value; }
+    inline wxUniChar GetValue() const { return m_value; }
+    inline void SetValue(const wxUniChar& value) { m_value = value; }

 
     virtual bool Eq(wxVariantData& data) const;
 #if wxUSE_STD_IOSTREAM
 
     virtual bool Eq(wxVariantData& data) const;
 #if wxUSE_STD_IOSTREAM


@@ -658,10 +659,10 @@ public:
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream& str) const;
 #endif // wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream& str) const;
 #endif // wxUSE_STREAMS

-    virtual wxString GetType() const { return wxT("char"); };
+    virtual wxString GetType() const { return wxT("char"); }

 
 protected:
 
 protected:

-    wxChar m_value;
+    wxUniChar m_value;

 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataChar, wxVariantData)
 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataChar, wxVariantData)


@@ -678,16 +679,14 @@ bool wxVariantDataChar::Eq(wxVariantData& data) const
 #if wxUSE_STD_IOSTREAM
 bool wxVariantDataChar::Write(wxSTD ostream& str) const
 {
 #if wxUSE_STD_IOSTREAM
 bool wxVariantDataChar::Write(wxSTD ostream& str) const
 {

-    wxString s;
-    Write(s);
-    str << (const char*) s.mb_str();
+    str << wxString(m_value);

     return true;
 }
 #endif
 
 bool wxVariantDataChar::Write(wxString& str) const
 {
     return true;
 }
 #endif
 
 bool wxVariantDataChar::Write(wxString& str) const
 {

-    str.Printf(wxT("%c"), m_value);
+    str = m_value;

     return true;
 }
 
     return true;
 }
 


@@ -695,7 +694,7 @@ bool wxVariantDataChar::Write(wxString& str) const
 bool wxVariantDataChar::Read(wxSTD istream& WXUNUSED(str))
 {
     wxFAIL_MSG(wxT("Unimplemented"));
 bool wxVariantDataChar::Read(wxSTD istream& WXUNUSED(str))
 {
     wxFAIL_MSG(wxT("Unimplemented"));

-    
+

     return false;
 }
 #endif
     return false;
 }
 #endif


@@ -705,7 +704,10 @@ bool wxVariantDataChar::Write(wxOutputStream& str) const
 {
     wxTextOutputStream s(str);
 
 {
     wxTextOutputStream s(str);
 

-    s.Write8(m_value);
+    // FIXME-UTF8: this should be just "s << m_value;" after removal of
+    //             ANSI build and addition of wxUniChar to wxTextOutputStream:
+    s << (wxChar)m_value;
+

     return true;
 }
 
     return true;
 }
 


@@ -713,7 +715,11 @@ bool wxVariantDataChar::Read(wxInputStream& str)
 {
     wxTextInputStream s(str);
 
 {
     wxTextInputStream s(str);
 

-    s >> m_value;
+    // FIXME-UTF8: this should be just "s >> m_value;" after removal of
+    //             ANSI build and addition of wxUniChar to wxTextInputStream:
+    wxChar ch;
+    s >> ch;
+    m_value = ch;

 
     return true;
 }
 
     return true;
 }


@@ -721,31 +727,38 @@ bool wxVariantDataChar::Read(wxInputStream& str)
 
 bool wxVariantDataChar::Read(wxString& str)
 {
 
 bool wxVariantDataChar::Read(wxString& str)
 {

-    m_value = str[size_t(0)];
+    m_value = str[0u];

     return true;
 }
 
     return true;
 }
 

-wxVariant::wxVariant(wxChar val, const wxString& name)
+wxVariant::wxVariant(const wxUniChar& val, const wxString& name)

 {
     m_data = new wxVariantDataChar(val);
     m_name = name;
 }
 
 {
     m_data = new wxVariantDataChar(val);
     m_name = name;
 }
 

-bool wxVariant::operator== (wxChar value) const
+wxVariant::wxVariant(char val, const wxString& name)

 {
 {

-    char thisValue;
+    m_data = new wxVariantDataChar(val);
+    m_name = name;
+}
+
+wxVariant::wxVariant(wchar_t val, const wxString& name)
+{
+    m_data = new wxVariantDataChar(val);
+    m_name = name;
+}
+
+bool wxVariant::operator==(const wxUniChar& value) const
+{
+    wxUniChar thisValue;

     if (!Convert(&thisValue))
         return false;
     else
         return (value == thisValue);
 }
 
     if (!Convert(&thisValue))
         return false;
     else
         return (value == thisValue);
 }
 

-bool wxVariant::operator!= (wxChar value) const
-{
-    return (!((*this) == value));
-}
-
-void wxVariant::operator= (wxChar value)
+wxVariant& wxVariant::operator=(const wxUniChar& value)

 {
     if (GetType() == wxT("char") &&
         m_data->GetRefCount() == 1)
 {
     if (GetType() == wxT("char") &&
         m_data->GetRefCount() == 1)


@@ -757,17 +770,19 @@ void wxVariant::operator= (wxChar value)
         UnRef();
         m_data = new wxVariantDataChar(value);
     }
         UnRef();
         m_data = new wxVariantDataChar(value);
     }

+
+    return *this;

 }
 
 }
 

-wxChar wxVariant::GetChar() const
+wxUniChar wxVariant::GetChar() const

 {
 {

-    char value;
+    wxUniChar value;

     if (Convert(& value))
         return value;
     else
     {
         wxFAIL_MSG(wxT("Could not convert to a char"));
     if (Convert(& value))
         return value;
     else
     {
         wxFAIL_MSG(wxT("Could not convert to a char"));

-        return 0;
+        return wxUniChar(0);

     }
 }
 
     }
 }
 


@@ -792,13 +807,13 @@ public:
     virtual bool Read(wxString& str);
     virtual bool Write(wxString& str) const;
 #if wxUSE_STD_IOSTREAM
     virtual bool Read(wxString& str);
     virtual bool Write(wxString& str) const;
 #if wxUSE_STD_IOSTREAM

-    virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; };
+    virtual bool Read(wxSTD istream& WXUNUSED(str)) { return false; }

 #endif
 #if wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream& str) const;
 #endif // wxUSE_STREAMS
 #endif
 #if wxUSE_STREAMS
     virtual bool Read(wxInputStream& str);
     virtual bool Write(wxOutputStream& str) const;
 #endif // wxUSE_STREAMS

-    virtual wxString GetType() const { return wxT("string"); };
+    virtual wxString GetType() const { return wxT("string"); }

 
 protected:
     wxString m_value;
 
 protected:
     wxString m_value;


@@ -854,14 +869,38 @@ bool wxVariantDataString::Read(wxString& str)
 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString, wxVariantData)
 
 // wxVariant ****
 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString, wxVariantData)
 
 // wxVariant ****

- 
+

 wxVariant::wxVariant(const wxString& val, const wxString& name)
 {
     m_data = new wxVariantDataString(val);
     m_name = name;
 }
 
 wxVariant::wxVariant(const wxString& val, const wxString& name)
 {
     m_data = new wxVariantDataString(val);
     m_name = name;
 }
 

-wxVariant::wxVariant(const wxChar* val, const wxString& name)
+wxVariant::wxVariant(const char* val, const wxString& name)
+{
+    m_data = new wxVariantDataString(wxString(val));
+    m_name = name;
+}
+
+wxVariant::wxVariant(const wchar_t* val, const wxString& name)
+{
+    m_data = new wxVariantDataString(wxString(val));
+    m_name = name;
+}
+
+wxVariant::wxVariant(const wxCStrData& val, const wxString& name)
+{
+    m_data = new wxVariantDataString(val.AsString());
+    m_name = name;
+}
+
+wxVariant::wxVariant(const wxCharBuffer& val, const wxString& name)
+{
+    m_data = new wxVariantDataString(wxString(val));
+    m_name = name;
+}
+
+wxVariant::wxVariant(const wxWCharBuffer& val, const wxString& name)

 {
     m_data = new wxVariantDataString(wxString(val));
     m_name = name;
 {
     m_data = new wxVariantDataString(wxString(val));
     m_name = name;


@@ -881,7 +920,7 @@ bool wxVariant::operator!= (const wxString& value) const
     return (!((*this) == value));
 }
 
     return (!((*this) == value));
 }
 

-void wxVariant::operator= (const wxString& value)
+wxVariant& wxVariant::operator= (const wxString& value)

 {
     if (GetType() == wxT("string") &&
         m_data->GetRefCount() == 1)
 {
     if (GetType() == wxT("string") &&
         m_data->GetRefCount() == 1)


@@ -893,20 +932,7 @@ void wxVariant::operator= (const wxString& value)
         UnRef();
         m_data = new wxVariantDataString(value);
     }
         UnRef();
         m_data = new wxVariantDataString(value);
     }

-}
-
-void wxVariant::operator= (const wxChar* value)
-{
-    if (GetType() == wxT("string") &&
-        m_data->GetRefCount() == 1)
-    {
-        ((wxVariantDataString*)GetData())->SetValue(wxString(value));
-    }
-    else
-    {
-        UnRef();
-        m_data = new wxVariantDataString(wxString(value));
-    }
+    return *this;

 }
 
 wxString wxVariant::GetString() const
 }
 
 wxString wxVariant::GetString() const


@@ -1065,7 +1091,7 @@ public:
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);

-    virtual wxString GetType() const { return wxT("void*"); };
+    virtual wxString GetType() const { return wxT("void*"); }

     virtual wxVariantData* Clone() { return new wxVariantDataVoidPtr; }
 
 protected:
     virtual wxVariantData* Clone() { return new wxVariantDataVoidPtr; }
 
 protected:


@@ -1189,7 +1215,7 @@ public:
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);

-    virtual wxString GetType() const { return wxT("datetime"); };
+    virtual wxString GetType() const { return wxT("datetime"); }

     virtual wxVariantData* Clone() { return new wxVariantDataDateTime; }
 
 protected:
     virtual wxVariantData* Clone() { return new wxVariantDataDateTime; }
 
 protected:


@@ -1238,7 +1264,7 @@ bool wxVariantDataDateTime::Read(wxSTD istream& WXUNUSED(str))
 
 bool wxVariantDataDateTime::Read(wxString& str)
 {
 
 bool wxVariantDataDateTime::Read(wxString& str)
 {

-    if(! m_value.ParseDateTime(str))
+    if(! m_value.ParseDateTime(str.c_str()/*FIXME-UTF8*/))

         return false;
     return true;
 }
         return false;
     return true;
 }


@@ -1355,7 +1381,7 @@ public:
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);

-    virtual wxString GetType() const { return wxT("arrstring"); };
+    virtual wxString GetType() const { return wxT("arrstring"); }

     virtual wxVariantData* Clone() { return new wxVariantDataArrayString; }
 
 protected:
     virtual wxVariantData* Clone() { return new wxVariantDataArrayString; }
 
 protected:


@@ -1484,7 +1510,7 @@ public:
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);
     virtual bool Read(wxSTD istream& str);
 #endif
     virtual bool Read(wxString& str);

-    virtual wxString GetType() const { return wxT("list"); };
+    virtual wxString GetType() const { return wxT("list"); }

 
     void Clear();
 
 
     void Clear();
 


@@ -1700,165 +1726,10 @@ void wxVariant::ClearList()
     }
 }
 
     }
 }
 

-#if WXWIN_COMPATIBILITY_2_4
-
-// ----------------------------------------------------------------------------
-// wxVariantDataStringList
-// ----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_BASE wxVariantDataStringList: public wxVariantData
-{
-DECLARE_DYNAMIC_CLASS(wxVariantDataStringList)
-public:
-    wxVariantDataStringList() {}
-    wxVariantDataStringList(const wxStringList& list) { m_value = list; }
-
-    wxStringList& GetValue() const { return (wxStringList&) m_value; }
-    void SetValue(const wxStringList& value);
-
-    virtual bool Eq(wxVariantData& data) const;
-#if wxUSE_STD_IOSTREAM
-    virtual bool Write(wxSTD ostream& str) const;
-#endif
-    virtual bool Write(wxString& str) const;
-#if wxUSE_STD_IOSTREAM
-    virtual bool Read(wxSTD istream& str);
-#endif
-    virtual bool Read(wxString& str);
-    virtual wxString GetType() const { return wxT("stringlist"); };
-
-protected:
-    wxStringList  m_value;
-};
-
-IMPLEMENT_DYNAMIC_CLASS(wxVariantDataStringList, wxVariantData)
-
-void wxVariantDataStringList::SetValue(const wxStringList& value)
-{
-    m_value = value;
-}
-
-bool wxVariantDataStringList::Eq(wxVariantData& data) const
-{
-    wxASSERT_MSG( (data.GetType() == wxT("stringlist")), wxT("wxVariantDataStringList::Eq: argument mismatch") );
-
-    wxVariantDataStringList& listData = (wxVariantDataStringList&) data;
-    wxStringList::compatibility_iterator node1 = m_value.GetFirst();
-    wxStringList::compatibility_iterator node2 = listData.GetValue().GetFirst();
-    while (node1 && node2)
-    {
-        wxString str1 ( node1->GetData() );
-        wxString str2 ( node2->GetData() );
-        if (str1 != str2)
-            return false;
-        node1 = node1->GetNext();
-        node2 = node2->GetNext();
-    }
-    if (node1 || node2) return false;
-    return true;
-}
-
-#if wxUSE_STD_IOSTREAM
-bool wxVariantDataStringList::Write(wxSTD ostream& str) const
-{
-    wxString s;
-    Write(s);
-    str << (const char*) s.mb_str();
-    return true;
-}
-#endif
-
-bool wxVariantDataStringList::Write(wxString& str) const
-{
-    str.Empty();
-    wxStringList::compatibility_iterator node = m_value.GetFirst();
-    while (node)
-    {
-        const wxChar* s = node->GetData();
-        if (node != m_value.GetFirst())
-          str += wxT(" ");
-        str += s;
-        node = node->GetNext();
-    }
-
-    return true;
-}
-
-#if wxUSE_STD_IOSTREAM
-bool wxVariantDataStringList::Read(wxSTD istream& WXUNUSED(str))
-{
-    wxFAIL_MSG(wxT("Unimplemented"));
-    // TODO
-    return false;
-}
-#endif
-
-bool wxVariantDataStringList::Read(wxString& WXUNUSED(str))
-{
-    wxFAIL_MSG(wxT("Unimplemented"));
-    // TODO
-    return false;
-}
-
-#endif //2.4 compat
-
-#if WXWIN_COMPATIBILITY_2_4
-
-wxVariant::wxVariant(const wxStringList& val, const wxString& name)
-{
-    m_data = new wxVariantDataStringList(val);
-    m_name = name;
-}
-
-bool wxVariant::operator== (const wxStringList& value) const
-{
-    wxASSERT_MSG( (GetType() == wxT("stringlist")), wxT("Invalid type for == operator") );
-
-    wxVariantDataStringList other(value);
-    return (GetData()->Eq(other));
-}
-
-bool wxVariant::operator!= (const wxStringList& value) const
-{
-    wxASSERT_MSG( (GetType() == wxT("stringlist")), wxT("Invalid type for == operator") );
-
-    wxVariantDataStringList other(value);
-    return !(GetData()->Eq(other));
-}
-
-void wxVariant::operator= (const wxStringList& value)
-{
-    if (GetType() == wxT("stringlist") &&
-        m_data->GetRefCount() == 1)
-    {
-        ((wxVariantDataStringList*)GetData())->SetValue(value);
-    }
-    else
-    {
-        UnRef();
-        m_data = new wxVariantDataStringList(value);
-    }
-}
-
-// wxVariant 
-
-wxStringList& wxVariant::GetStringList() const
-{
-    wxASSERT( (GetType() == wxT("stringlist")) );
-
-    return (wxStringList&) ((wxVariantDataStringList*) m_data)->GetValue();
-}
-
-#endif
-

 // Treat a list variant as an array
 wxVariant wxVariant::operator[] (size_t idx) const
 {
 // Treat a list variant as an array
 wxVariant wxVariant::operator[] (size_t idx) const
 {

-#if WXWIN_COMPATIBILITY_2_4
-    wxASSERT_MSG( (GetType() == wxT("list") || GetType() == wxT("stringlist")), wxT("Invalid type for array operator") );
-#else

     wxASSERT_MSG( GetType() == wxT("list"), wxT("Invalid type for array operator") );
     wxASSERT_MSG( GetType() == wxT("list"), wxT("Invalid type for array operator") );

-#endif

 
     if (GetType() == wxT("list"))
     {
 
     if (GetType() == wxT("list"))
     {


@@ -1866,17 +1737,6 @@ wxVariant wxVariant::operator[] (size_t idx) const
         wxASSERT_MSG( (idx < data->GetValue().GetCount()), wxT("Invalid index for array") );
         return * (wxVariant*) (data->GetValue().Item(idx)->GetData());
     }
         wxASSERT_MSG( (idx < data->GetValue().GetCount()), wxT("Invalid index for array") );
         return * (wxVariant*) (data->GetValue().Item(idx)->GetData());
     }

-#if WXWIN_COMPATIBILITY_2_4
-    else if (GetType() == wxT("stringlist"))
-    {
-        wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
-        wxASSERT_MSG( (idx < data->GetValue().GetCount()), wxT("Invalid index for array") );
-
-        wxString str( (const wxChar*) (data->GetValue().Item(idx)->GetData()) );
-        wxVariant variant( str );
-        return variant;
-    }
-#endif

     return wxNullVariant;
 }
 
     return wxNullVariant;
 }
 


@@ -1896,24 +1756,13 @@ wxVariant& wxVariant::operator[] (size_t idx)
 // Return the number of elements in a list
 size_t wxVariant::GetCount() const
 {
 // Return the number of elements in a list
 size_t wxVariant::GetCount() const
 {

-#if WXWIN_COMPATIBILITY_2_4
-    wxASSERT_MSG( (GetType() == wxT("list") || GetType() == wxT("stringlist")), wxT("Invalid type for GetCount()") );
-#else

     wxASSERT_MSG( GetType() == wxT("list"), wxT("Invalid type for GetCount()") );
     wxASSERT_MSG( GetType() == wxT("list"), wxT("Invalid type for GetCount()") );

-#endif

 
     if (GetType() == wxT("list"))
     {
         wxVariantDataList* data = (wxVariantDataList*) m_data;
         return data->GetValue().GetCount();
     }
 
     if (GetType() == wxT("list"))
     {
         wxVariantDataList* data = (wxVariantDataList*) m_data;
         return data->GetValue().GetCount();
     }

-#if WXWIN_COMPATIBILITY_2_4
-    else if (GetType() == wxT("stringlist"))
-    {
-        wxVariantDataStringList* data = (wxVariantDataStringList*) m_data;
-        return data->GetValue().GetCount();
-    }
-#endif

     return 0;
 }
 
     return 0;
 }
 


@@ -1933,7 +1782,7 @@ bool wxVariant::Convert(long* value) const
         *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
 #endif
     else if (type == wxT("string"))
         *value = (long) (((wxVariantDataBool*)GetData())->GetValue());
 #endif
     else if (type == wxT("string"))

-        *value = wxAtol((const wxChar*) ((wxVariantDataString*)GetData())->GetValue());
+        *value = wxAtol(((wxVariantDataString*)GetData())->GetValue());

     else
         return false;
 
     else
         return false;
 


@@ -1980,14 +1829,14 @@ bool wxVariant::Convert(double* value) const
         *value = (double) (((wxVariantDataBool*)GetData())->GetValue());
 #endif
     else if (type == wxT("string"))
         *value = (double) (((wxVariantDataBool*)GetData())->GetValue());
 #endif
     else if (type == wxT("string"))

-        *value = (double) wxAtof((const wxChar*) ((wxVariantDataString*)GetData())->GetValue());
+        *value = (double) wxAtof(((wxVariantDataString*)GetData())->GetValue());

     else
         return false;
 
     return true;
 }
 
     else
         return false;
 
     return true;
 }
 

-bool wxVariant::Convert(char* value) const
+bool wxVariant::Convert(wxUniChar* value) const

 {
     wxString type(GetType());
     if (type == wxT("char"))
 {
     wxString type(GetType());
     if (type == wxT("char"))


@@ -2004,6 +1853,24 @@ bool wxVariant::Convert(char* value) const
     return true;
 }
 
     return true;
 }
 

+bool wxVariant::Convert(char* value) const
+{
+    wxUniChar ch;
+    if ( !Convert(&ch) )
+        return false;
+    *value = ch;
+    return true;
+}
+
+bool wxVariant::Convert(wchar_t* value) const
+{
+    wxUniChar ch;
+    if ( !Convert(&ch) )
+        return false;
+    *value = ch;
+    return true;
+}
+

 bool wxVariant::Convert(wxString* value) const
 {
     *value = MakeString();
 bool wxVariant::Convert(wxString* value) const
 {
     *value = MakeString();


@@ -2022,11 +1889,10 @@ bool wxVariant::Convert(wxDateTime* value) const
     // Fallback to string conversion
     wxString val;
     return Convert(&val) &&
     // Fallback to string conversion
     wxString val;
     return Convert(&val) &&

-                (value->ParseDateTime(val) || value->ParseDate(val) || value->ParseTime(val));
+                (value->ParseDateTime(val.c_str()/*FIXME-UTF8*/) ||
+                 value->ParseDate(val.c_str()/*FIXME-UTF8*/) ||
+                 value->ParseTime(val.c_str()/*FIXME-UTF8*/));

 }
 #endif // wxUSE_DATETIME
 
 }
 #endif // wxUSE_DATETIME
 

-
-
-

 #endif // wxUSE_VARIANT
 #endif // wxUSE_VARIANT