fixed typo : _ instead of wxT

[wxWidgets.git] / src / generic / prop.cpp

diff --git a/src/generic/prop.cpp b/src/generic/prop.cpp
index b63cafa0cf6932a89a3a83031e6ebe2120b102ea..ad6d3b521e20622e4add9c9b2efe9668ec6eb6f7 100644 (file)
--- a/src/generic/prop.cpp
+++ b/src/generic/prop.cpp
@@ -24,26 +24,14 @@
 #include "wx/wx.h"
 #endif
 
 #include "wx/wx.h"
 #endif
 

+#include "wx/debug.h"
+#include "wx/prop.h"
+

 #include <ctype.h>
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
 

-#if wxUSE_IOSTREAMH
-#if defined(__WXMSW__) && !defined(__GNUWIN32__)
-#include <strstrea.h>
-#else
-#include <strstream.h>
-#endif
-#else
-#include <strstream>
-#endif
-
-#include "wx/window.h"
-#include "wx/utils.h"
-#include "wx/list.h"
-#include "wx/debug.h"
-#include "wx/prop.h"

 
 IMPLEMENT_DYNAMIC_CLASS(wxPropertyValue, wxObject)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPropertyValue, wxObject)
 


@@ -59,11 +47,12 @@ wxPropertyValue::wxPropertyValue(void)
 
 wxPropertyValue::wxPropertyValue(const wxPropertyValue& copyFrom)
 {
 
 wxPropertyValue::wxPropertyValue(const wxPropertyValue& copyFrom)
 {

+  m_value.string = (wxChar*) NULL;

   m_modifiedFlag = FALSE;
   Copy((wxPropertyValue& )copyFrom);
 }
 
   m_modifiedFlag = FALSE;
   Copy((wxPropertyValue& )copyFrom);
 }
 

-wxPropertyValue::wxPropertyValue(const char *val)
+wxPropertyValue::wxPropertyValue(const wxChar *val)

 {
   m_modifiedFlag = FALSE;
   m_type = wxPropertyValueString;
 {
   m_modifiedFlag = FALSE;
   m_type = wxPropertyValueString;


@@ -79,7 +68,7 @@ wxPropertyValue::wxPropertyValue(const wxString& val)
   m_modifiedFlag = FALSE;
   m_type = wxPropertyValueString;
 
   m_modifiedFlag = FALSE;
   m_type = wxPropertyValueString;
 

-  m_value.string = copystring((const char *)val);
+  m_value.string = copystring((const wxChar *)val);

   m_clientData = NULL;
   m_next = NULL;
   m_last = NULL;
   m_clientData = NULL;
   m_next = NULL;
   m_last = NULL;


@@ -122,7 +111,7 @@ wxPropertyValue::wxPropertyValue(double the_real)
 }
 
 // Pointer versions: we have a pointer to the real C++ value.
 }
 
 // Pointer versions: we have a pointer to the real C++ value.

-wxPropertyValue::wxPropertyValue(char **val)
+wxPropertyValue::wxPropertyValue(wxChar **val)

 {
   m_modifiedFlag = FALSE;
   m_type = wxPropertyValueStringPtr;
 {
   m_modifiedFlag = FALSE;
   m_type = wxPropertyValueStringPtr;


@@ -254,7 +243,7 @@ void wxPropertyValue::Insert(wxPropertyValue *expr)
 void wxPropertyValue::Delete(wxPropertyValue *node)
 {
   wxPropertyValue *expr = GetFirst();
 void wxPropertyValue::Delete(wxPropertyValue *node)
 {
   wxPropertyValue *expr = GetFirst();

-  
+

   wxPropertyValue *previous = NULL;
   while (expr && (expr != node))
   {
   wxPropertyValue *previous = NULL;
   while (expr && (expr != node))
   {


@@ -266,7 +255,7 @@ void wxPropertyValue::Delete(wxPropertyValue *node)
   {
     if (previous)
       previous->m_next = expr->m_next;
   {
     if (previous)
       previous->m_next = expr->m_next;

-      
+

     // If node was the first in the list,
     // make the list point to the NEXT one.
     if (GetFirst() == expr)
     // If node was the first in the list,
     // make the list point to the NEXT one.
     if (GetFirst() == expr)


@@ -339,10 +328,8 @@ wxPropertyValue *wxPropertyValue::NewCopy(void) const
    case wxPropertyValueStringPtr:
      return new wxPropertyValue(m_value.stringPtr);
 
    case wxPropertyValueStringPtr:
      return new wxPropertyValue(m_value.stringPtr);
 

-   case wxPropertyValueNull: 
-#ifdef __X__
-    cerr << "Should never get here!\n";
-#endif
+   case wxPropertyValueNull:
+    wxFAIL_MSG( wxT("Should never get here!\n" ) );

     break;
   }
   return NULL;
     break;
   }
   return NULL;


@@ -350,6 +337,11 @@ wxPropertyValue *wxPropertyValue::NewCopy(void) const
 
 void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
 {
 
 void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
 {

+  if (m_type == wxPropertyValueString)
+  {
+    delete[] m_value.string ;
+    m_value.string = NULL;
+  }

   m_type = copyFrom.Type();
 
   switch (m_type)
   m_type = copyFrom.Type();
 
   switch (m_type)


@@ -361,11 +353,11 @@ void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
     case wxPropertyValueReal:
       (*this) = copyFrom.RealValue();
       return ;
     case wxPropertyValueReal:
       (*this) = copyFrom.RealValue();
       return ;

-      
+

     case wxPropertyValueString:
       (*this) = wxString(copyFrom.StringValue());
       return ;
     case wxPropertyValueString:
       (*this) = wxString(copyFrom.StringValue());
       return ;

-      
+

     case wxPropertyValuebool:
       (*this) = copyFrom.BoolValue();
       return ;
     case wxPropertyValuebool:
       (*this) = copyFrom.BoolValue();
       return ;


@@ -382,11 +374,22 @@ void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
       return ;
     case wxPropertyValueStringPtr:
     {
       return ;
     case wxPropertyValueStringPtr:
     {

-      char** s = copyFrom.StringValuePtr();
+      wxChar** s = copyFrom.StringValuePtr();
+      
+#if 0      
+      // what is this? are you trying to assign a bool or a string?  VA can't figure it out..
+#if defined(__VISAGECPP__) || defined( __VISUALC__ )

       (*this) = s;
       (*this) = s;

+#else
+      (*this) = s != 0;
+#endif
+#endif // if 0
+
+      (*this) = (bool)(s != 0);
+      

       return ;
     }
       return ;
     }

-      
+

     case wxPropertyValueList:
     {
       m_value.first = NULL;
     case wxPropertyValueList:
     {
       m_value.first = NULL;


@@ -401,10 +404,8 @@ void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
       }
       return;
     }
       }
       return;
     }

-   case wxPropertyValueNull: 
-#ifdef __X__
-    cerr << "Should never get here!\n";
-#endif
+   case wxPropertyValueNull:
+    wxFAIL_MSG( wxT("Should never get here!\n" ) );

     break;
   }
 }
     break;
   }
 }


@@ -457,7 +458,7 @@ int wxPropertyValue::Number(void) const
   return i;
 }
 
   return i;
 }
 

-void wxPropertyValue::WritePropertyClause(ostream& stream)  // Write this expression as a top-level clause
+void wxPropertyValue::WritePropertyClause(wxString& stream)  // Write this expression as a top-level clause

 {
   if (m_type != wxPropertyValueList)
     return;
 {
   if (m_type != wxPropertyValueList)
     return;


@@ -466,90 +467,78 @@ void wxPropertyValue::WritePropertyClause(ostream& stream)  // Write this expres
   if (node)
   {
     node->WritePropertyType(stream);
   if (node)
   {
     node->WritePropertyType(stream);

-    stream << "(";
+    stream.Append( wxT("(") );

     node = node->m_next;
     bool first = TRUE;
     while (node)
     {
       if (!first)
     node = node->m_next;
     bool first = TRUE;
     while (node)
     {
       if (!first)

-        stream << "  ";
+        stream.Append( wxT("  ") );

       node->WritePropertyType(stream);
       node = node->m_next;
       node->WritePropertyType(stream);
       node = node->m_next;

-      if (node) stream << ",\n";
+      if (node)
+        stream.Append( wxT(",\n" ) );

       first = FALSE;
     }
       first = FALSE;
     }

-    stream << ").\n\n";
+    stream.Append( wxT(").\n\n") );

   }
 }
 
   }
 }
 

-void wxPropertyValue::WritePropertyType(ostream& stream)    // Write as any other subexpression
+void wxPropertyValue::WritePropertyType(wxString& stream)    // Write as any other subexpression

 {
 {

+  wxString tmp;

   switch (m_type)
   {
     case wxPropertyValueInteger:
     {
   switch (m_type)
   {
     case wxPropertyValueInteger:
     {

-      stream << m_value.integer;
+      tmp.Printf( wxT("%ld"), m_value.integer );
+      stream.Append( tmp );

       break;
     }
     case wxPropertyValueIntegerPtr:
     {
       break;
     }
     case wxPropertyValueIntegerPtr:
     {

-      stream << *m_value.integerPtr;
+      tmp.Printf( wxT("%ld"), *m_value.integerPtr );
+      stream.Append( tmp );

       break;
     }
     case wxPropertyValuebool:
     {
       if (m_value.integer)
       break;
     }
     case wxPropertyValuebool:
     {
       if (m_value.integer)

-        stream << "True";
+        stream.Append( wxT("True") );

       else
       else

-        stream << "False";
+        stream.Append( wxT("False") );

       break;
     }
     case wxPropertyValueboolPtr:
     {
       if (*m_value.integerPtr)
       break;
     }
     case wxPropertyValueboolPtr:
     {
       if (*m_value.integerPtr)

-        stream << "True";
+        stream.Append( wxT("True") );

       else
       else

-        stream << "False";
+        stream.Append( wxT("False") );

       break;
     }
     case wxPropertyValueReal:
     {
       break;
     }
     case wxPropertyValueReal:
     {

-      float f = m_value.real;
-      sprintf(wxBuffer, "%.6g", (double)f);
-      stream << wxBuffer;
+      double d = m_value.real;
+      tmp.Printf( wxT("%.6g"), d );
+      stream.Append( tmp );

       break;
     }
     case wxPropertyValueRealPtr:
     {
       break;
     }
     case wxPropertyValueRealPtr:
     {

-      float f = *m_value.realPtr;
-/* Now the parser can cope with this.
-      // Prevent printing in 'e' notation. Any better way?
-      if (fabs(f) < 0.00001)
-        f = 0.0;
-*/
-      sprintf(wxBuffer, "%.6g", f);
-      stream << wxBuffer;
+      double d = *m_value.realPtr;
+      tmp.Printf( wxT("%.6g"), d );
+      stream.Append( tmp );

       break;
     }
     case wxPropertyValueString:
     {
       break;
     }
     case wxPropertyValueString:
     {

-//      stream << "\"";
-      int i;
-      int len = strlen(m_value.string);
-      for (i = 0; i < len; i++)
-      {
-        char ch = m_value.string[i];
-//        if (ch == '"' || ch == '\\')
-//          stream << "\\";
-        stream << ch;
-      }
-
-//      stream << "\"";
+      stream.Append( m_value.string );

       break;
     }
     case wxPropertyValueStringPtr:
     {
       break;
     }
     case wxPropertyValueStringPtr:
     {

-      wxFAIL_MSG( "wxPropertyValue::WritePropertyType( wxPropertyValueStringPtr ) not implemented" );
+      wxFAIL_MSG( wxT("wxPropertyValue::WritePropertyType( wxPropertyValueStringPtr ) not implemented") );

       /*
       int i;
       int len = strlen(*(m_value.stringPtr));
       /*
       int i;
       int len = strlen(*(m_value.stringPtr));


@@ -564,19 +553,20 @@ void wxPropertyValue::WritePropertyType(ostream& stream)    // Write as any othe
     case wxPropertyValueList:
     {
       if (!m_value.first)
     case wxPropertyValueList:
     {
       if (!m_value.first)

-        stream << "[]";
+        stream.Append( wxT("[]") );

       else
       {
         wxPropertyValue *expr = m_value.first;
 
       else
       {
         wxPropertyValue *expr = m_value.first;
 

-        stream << "[";
+        stream.Append( wxT("[") );

         while (expr)
         {
           expr->WritePropertyType(stream);
           expr = expr->m_next;
         while (expr)
         {
           expr->WritePropertyType(stream);
           expr = expr->m_next;

-          if (expr) stream << ", ";
+          if (expr)
+           stream.Append( wxT(", ") );

         }
         }

-        stream << "]";
+        stream.Append( wxT("]") );

       }
       break;
     }
       }
       break;
     }


@@ -586,16 +576,9 @@ void wxPropertyValue::WritePropertyType(ostream& stream)    // Write as any othe
 
 wxString wxPropertyValue::GetStringRepresentation(void)
 {
 
 wxString wxPropertyValue::GetStringRepresentation(void)
 {

-  char buf[500];
-  buf[0] = 0;
-  
-  ostrstream str((char *)buf, (int)500, ios::out);
+  wxString str;

   WritePropertyType(str);
   WritePropertyType(str);

-  str << '\0';
-  str.flush();
-
-  wxString theString(buf);
-  return theString;
+  return str;

 }
 
 void wxPropertyValue::operator=(const wxPropertyValue& val)
 }
 
 void wxPropertyValue::operator=(const wxPropertyValue& val)


@@ -607,9 +590,17 @@ void wxPropertyValue::operator=(const wxPropertyValue& val)
 // void wxPropertyValue::operator=(const char *val)
 void wxPropertyValue::operator=(const wxString& val1)
 {
 // void wxPropertyValue::operator=(const char *val)
 void wxPropertyValue::operator=(const wxString& val1)
 {

-  const char *val = (const char *)val1;
+  const wxChar *val = (const wxChar *)val1;

 
   m_modifiedFlag = TRUE;
 
   m_modifiedFlag = TRUE;

+
+  wxPropertyValueType oldType = m_type;
+  if (oldType == wxPropertyValueString)
+  {
+    delete[] m_value.string ;
+    m_value.string = NULL;
+  }
+

   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValueString;
 
   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValueString;
 


@@ -622,14 +613,13 @@ void wxPropertyValue::operator=(const wxString& val1)
   }
   else if (m_type == wxPropertyValueStringPtr)
   {
   }
   else if (m_type == wxPropertyValueStringPtr)
   {

-    if (*m_value.stringPtr)
-      delete[] *m_value.stringPtr;
+    wxFAIL_MSG( wxT("Shouldn't try to assign a wxString reference to a char* pointer.") );

     if (val)
       *m_value.stringPtr = copystring(val);
     else
       *m_value.stringPtr = NULL;
   }
     if (val)
       *m_value.stringPtr = copystring(val);
     else
       *m_value.stringPtr = NULL;
   }

-  
+

   m_clientData = NULL;
   m_next = NULL;
   m_last = NULL;
   m_clientData = NULL;
   m_next = NULL;
   m_last = NULL;


@@ -638,6 +628,13 @@ void wxPropertyValue::operator=(const wxString& val1)
 
 void wxPropertyValue::operator=(const long val)
 {
 
 void wxPropertyValue::operator=(const long val)
 {

+  wxPropertyValueType oldType = m_type;
+  if (oldType == wxPropertyValueString)
+  {
+    delete[] m_value.string ;
+    m_value.string = NULL;
+  }
+

   m_modifiedFlag = TRUE;
   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValueInteger;
   m_modifiedFlag = TRUE;
   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValueInteger;


@@ -657,6 +654,13 @@ void wxPropertyValue::operator=(const long val)
 
 void wxPropertyValue::operator=(const bool val)
 {
 
 void wxPropertyValue::operator=(const bool val)
 {

+  wxPropertyValueType oldType = m_type;
+  if (oldType == wxPropertyValueString)
+  {
+    delete[] m_value.string ;
+    m_value.string = NULL;
+  }
+

   m_modifiedFlag = TRUE;
   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValuebool;
   m_modifiedFlag = TRUE;
   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValuebool;


@@ -672,6 +676,13 @@ void wxPropertyValue::operator=(const bool val)
 
 void wxPropertyValue::operator=(const float val)
 {
 
 void wxPropertyValue::operator=(const float val)
 {

+  wxPropertyValueType oldType = m_type;
+  if (oldType == wxPropertyValueString)
+  {
+    delete[] m_value.string ;
+    m_value.string = NULL;
+  }
+

   m_modifiedFlag = TRUE;
   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValueReal;
   m_modifiedFlag = TRUE;
   if (m_type == wxPropertyValueNull)
     m_type = wxPropertyValueReal;


@@ -689,13 +700,20 @@ void wxPropertyValue::operator=(const float val)
   m_next = NULL;
 }
 
   m_next = NULL;
 }
 

-void wxPropertyValue::operator=(const char **val)
+void wxPropertyValue::operator=(const wxChar **val)

 {
 {

+  wxPropertyValueType oldType = m_type;
+  if (oldType == wxPropertyValueString)
+  {
+    delete[] m_value.string ;
+    m_value.string = NULL;
+  }
+

   m_modifiedFlag = TRUE;
   m_type = wxPropertyValueStringPtr;
 
   if (val)
   m_modifiedFlag = TRUE;
   m_type = wxPropertyValueStringPtr;
 
   if (val)

-    m_value.stringPtr = (char **)val;
+    m_value.stringPtr = (wxChar **)val;

   else
     m_value.stringPtr = NULL;
   m_clientData = NULL;
   else
     m_value.stringPtr = NULL;
   m_clientData = NULL;


@@ -787,7 +805,7 @@ bool *wxPropertyValue::BoolValuePtr(void) const
   return m_value.boolPtr;
 }
 
   return m_value.boolPtr;
 }
 

-char *wxPropertyValue::StringValue(void) const {
+wxChar *wxPropertyValue::StringValue(void) const {

     if (m_type == wxPropertyValueString)
       return m_value.string;
     else if (m_type == wxPropertyValueStringPtr)
     if (m_type == wxPropertyValueString)
       return m_value.string;
     else if (m_type == wxPropertyValueStringPtr)


@@ -795,7 +813,7 @@ char *wxPropertyValue::StringValue(void) const {
     else return NULL;
   }
 
     else return NULL;
   }
 

-char **wxPropertyValue::StringValuePtr(void) const
+wxChar **wxPropertyValue::StringValuePtr(void) const

 {
   return m_value.stringPtr;
 }
 {
   return m_value.stringPtr;
 }


@@ -803,7 +821,7 @@ char **wxPropertyValue::StringValuePtr(void) const
 /*
  * A property (name plus value)
  */
 /*
  * A property (name plus value)
  */

- 
+

 IMPLEMENT_DYNAMIC_CLASS(wxProperty, wxObject)
 
 wxProperty::wxProperty(void)
 IMPLEMENT_DYNAMIC_CLASS(wxProperty, wxObject)
 
 wxProperty::wxProperty(void)


@@ -893,7 +911,7 @@ void wxProperty::operator=(const wxPropertyValue& val)
 /*
  * Base property view class
  */
 /*
  * Base property view class
  */

- 
+

 IMPLEMENT_DYNAMIC_CLASS(wxPropertyView, wxEvtHandler)
 
 wxPropertyView::wxPropertyView(long flags)
 IMPLEMENT_DYNAMIC_CLASS(wxPropertyView, wxEvtHandler)
 
 wxPropertyView::wxPropertyView(long flags)


@@ -917,7 +935,7 @@ wxPropertyValidator *wxPropertyView::FindPropertyValidator(wxProperty *property)
 {
   if (property->GetValidator())
     return property->GetValidator();
 {
   if (property->GetValidator())
     return property->GetValidator();

-    
+

   wxNode *node = m_validatorRegistryList.First();
   while (node)
   {
   wxNode *node = m_validatorRegistryList.First();
   while (node)
   {


@@ -941,7 +959,7 @@ wxPropertyValidator *wxPropertyView::FindPropertyValidator(wxProperty *property)
 
 IMPLEMENT_DYNAMIC_CLASS(wxPropertySheet, wxObject)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPropertySheet, wxObject)
 

-wxPropertySheet::wxPropertySheet(wxString name)
+wxPropertySheet::wxPropertySheet(const wxString& name)

 :m_properties(wxKEY_STRING),m_name(name)
 {
 }
 :m_properties(wxKEY_STRING),m_name(name)
 {
 }


@@ -951,16 +969,6 @@ wxPropertySheet::~wxPropertySheet(void)
   Clear();
 }
 
   Clear();
 }
 

-bool wxPropertySheet::Save( ostream& WXUNUSED(str) )
-{
-  return FALSE;
-}
-
-bool wxPropertySheet::Load( ostream& WXUNUSED(str) )
-{
-  return FALSE;
-}
-

 void wxPropertySheet::UpdateAllViews( wxPropertyView *WXUNUSED(thisView) )
 {
 }
 void wxPropertySheet::UpdateAllViews( wxPropertyView *WXUNUSED(thisView) )
 {
 }


@@ -968,29 +976,31 @@ void wxPropertySheet::UpdateAllViews( wxPropertyView *WXUNUSED(thisView) )
 // Add a property
 void wxPropertySheet::AddProperty(wxProperty *property)
 {
 // Add a property
 void wxPropertySheet::AddProperty(wxProperty *property)
 {

-  m_properties.Append((const char*) property->GetName(), property);
+  m_properties.Append((const wxChar*) property->GetName(), property);

 }
 
 // Get property by name
 }
 
 // Get property by name

-wxProperty *wxPropertySheet::GetProperty(wxString name)
+wxProperty *wxPropertySheet::GetProperty(const wxString& name) const

 {
 {

-  wxNode *node = m_properties.Find((const char*) name);
+  wxNode *node = m_properties.Find((const wxChar*) name);

   if (!node)
     return NULL;
   else
     return (wxProperty *)node->Data();
 }
   if (!node)
     return NULL;
   else
     return (wxProperty *)node->Data();
 }

-bool wxPropertySheet::SetProperty(const wxString name, wxPropertyValue value)
+
+bool wxPropertySheet::SetProperty(const wxString& name, const wxPropertyValue& value)

 {
   wxProperty* prop = GetProperty(name);
   if(prop){
     prop->SetValue(value);
 {
   wxProperty* prop = GetProperty(name);
   if(prop){
     prop->SetValue(value);

-    return true;
+    return TRUE;

   }else{
   }else{

-    return false;
+    return FALSE;

   }
 }
   }
 }

-void wxPropertySheet::RemoveProperty(wxString name)
+
+void wxPropertySheet::RemoveProperty(const wxString& name)

 {
   wxNode *node = m_properties.Find(name);
   if(node)
 {
   wxNode *node = m_properties.Find(name);
   if(node)


@@ -1000,10 +1010,12 @@ void wxPropertySheet::RemoveProperty(wxString name)
     m_properties.DeleteNode(node);
   }
 }      
     m_properties.DeleteNode(node);
   }
 }      

-bool wxPropertySheet::HasProperty(wxString name)
-{ 
-       return (GetProperty(name)?true:false); 
+
+bool wxPropertySheet::HasProperty(const wxString& name) const
+{
+       return (GetProperty(name)?TRUE:FALSE);

 }
 }

+

 // Clear all properties
 void wxPropertySheet::Clear(void)
 {
 // Clear all properties
 void wxPropertySheet::Clear(void)
 {


@@ -1027,7 +1039,7 @@ void wxPropertySheet::SetAllModified(bool flag)
     wxProperty *prop = (wxProperty *)node->Data();
     prop->GetValue().SetModified(flag);
     node = node->Next();
     wxProperty *prop = (wxProperty *)node->Data();
     prop->GetValue().SetModified(flag);
     node = node->Next();

-  }  
+  }

 }
 
 /*
 }
 
 /*


@@ -1048,19 +1060,19 @@ wxPropertyValidatorRegistry::~wxPropertyValidatorRegistry(void)
 
 void wxPropertyValidatorRegistry::RegisterValidator(const wxString& typeName, wxPropertyValidator *validator)
 {
 
 void wxPropertyValidatorRegistry::RegisterValidator(const wxString& typeName, wxPropertyValidator *validator)
 {

-  Put((const char*) typeName, validator);
+  Put((const wxChar*) typeName, validator);

 }
 
 wxPropertyValidator *wxPropertyValidatorRegistry::GetValidator(const wxString& typeName)
 {
 }
 
 wxPropertyValidator *wxPropertyValidatorRegistry::GetValidator(const wxString& typeName)
 {

-  return (wxPropertyValidator *)Get((const char*) typeName);
+  return (wxPropertyValidator *)Get((const wxChar*) typeName);

 }
 
 void wxPropertyValidatorRegistry::ClearRegistry(void)
 {
   BeginFind();
   wxNode *node;
 }
 
 void wxPropertyValidatorRegistry::ClearRegistry(void)
 {
   BeginFind();
   wxNode *node;

-  while ((node = Next()))
+  while ((node = Next()) != NULL)

   {
     delete (wxPropertyValidator *)node->Data();
   }
   {
     delete (wxPropertyValidator *)node->Data();
   }


@@ -1082,66 +1094,64 @@ wxPropertyValidator::wxPropertyValidator(long flags)
 wxPropertyValidator::~wxPropertyValidator(void)
 {}
 
 wxPropertyValidator::~wxPropertyValidator(void)
 {}
 

-bool wxPropertyValidator::StringToFloat (char *s, float *number) {
+bool wxPropertyValidator::StringToFloat (wxChar *s, float *number) {

        double num;
        bool ok = StringToDouble (s, &num);
        *number = (float) num;
        return ok;
 }
 
        double num;
        bool ok = StringToDouble (s, &num);
        *number = (float) num;
        return ok;
 }
 

-bool wxPropertyValidator::StringToDouble (char *s, double *number) {
+bool wxPropertyValidator::StringToDouble (wxChar *s, double *number) {

     bool ok = TRUE;
     bool ok = TRUE;

-    char *value_ptr;
-    *number = strtod (s, &value_ptr);
+    wxChar *value_ptr;
+    *number = wxStrtod (s, &value_ptr);

     if (value_ptr) {
     if (value_ptr) {

-               int len = strlen (value_ptr);
+               int len = wxStrlen (value_ptr);

                for (int i = 0; i < len; i++) {
                for (int i = 0; i < len; i++) {

-                       ok = (isspace (value_ptr[i]) != 0);
+                       ok = (wxIsspace (value_ptr[i]) != 0);

                        if (!ok) return FALSE;
                }
     }
     return ok;
 }
 
                        if (!ok) return FALSE;
                }
     }
     return ok;
 }
 

-bool wxPropertyValidator::StringToInt (char *s, int *number) {
+bool wxPropertyValidator::StringToInt (wxChar *s, int *number) {

        long num;
        bool ok = StringToLong (s, &num);
        *number = (int) num;
        return ok;
 }
 
        long num;
        bool ok = StringToLong (s, &num);
        *number = (int) num;
        return ok;
 }
 

-bool wxPropertyValidator::StringToLong (char *s, long *number) {
+bool wxPropertyValidator::StringToLong (wxChar *s, long *number) {

     bool ok = TRUE;
     bool ok = TRUE;

-    char *value_ptr;
-    *number = strtol (s, &value_ptr, 10);
+    wxChar *value_ptr;
+    *number = wxStrtol (s, &value_ptr, 10);

     if (value_ptr) {
     if (value_ptr) {

-               int len = strlen (value_ptr);
+               int len = wxStrlen (value_ptr);

                for (int i = 0; i < len; i++) {
                for (int i = 0; i < len; i++) {

-                       ok = (isspace (value_ptr[i]) != 0);
+                       ok = (wxIsspace (value_ptr[i]) != 0);

                        if (!ok) return FALSE;
                }
     }
     return ok;
 }
 
                        if (!ok) return FALSE;
                }
     }
     return ok;
 }
 

-char *wxPropertyValidator::FloatToString (float number) {
-       static char buf[20];
-       sprintf (buf, "%.6g", number);
+wxChar *wxPropertyValidator::FloatToString (float number) {
+       static wxChar buf[20];
+       wxSprintf (buf, wxT("%.6g"), number);

        return buf;
 }
 
        return buf;
 }
 

-char *wxPropertyValidator::DoubleToString (double number) {
-       static char buf[20];
-       sprintf (buf, "%.6g", number);
+wxChar *wxPropertyValidator::DoubleToString (double number) {
+       static wxChar buf[20];
+       wxSprintf (buf, wxT("%.6g"), number);

        return buf;
 }
 
        return buf;
 }
 

-char *wxPropertyValidator::IntToString (int number) {
+wxChar *wxPropertyValidator::IntToString (int number) {

        return ::IntToString (number);
 }
 
        return ::IntToString (number);
 }
 

-char *wxPropertyValidator::LongToString (long number) {
+wxChar *wxPropertyValidator::LongToString (long number) {

        return ::LongToString (number);
   }
        return ::LongToString (number);
   }

-
-