fix wxGTK1 compilation after wxTextEntry DoGetValue() change

[wxWidgets.git] / src / propgrid / props.cpp

diff --git a/src/propgrid/props.cpp b/src/propgrid/props.cpp
index 69b21d2580af2ff4e003c6ce0061ebbd47455485..9014519cee5d3acff168ee4779e2303cb156b2a8 100644 (file)
--- a/src/propgrid/props.cpp
+++ b/src/propgrid/props.cpp
@@ -4,7 +4,7 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2005-05-14
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2005-05-14

-// RCS-ID:      $Id:
+// RCS-ID:      $Id$

 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////


@@ -16,6 +16,8 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_PROPGRID
+

 #ifndef WX_PRECOMP
     #include "wx/defs.h"
     #include "wx/object.h"
 #ifndef WX_PRECOMP
     #include "wx/defs.h"
     #include "wx/object.h"


@@ -44,18 +46,15 @@
     #include "wx/sizer.h"
     #include "wx/textdlg.h"
     #include "wx/filedlg.h"
     #include "wx/sizer.h"
     #include "wx/textdlg.h"
     #include "wx/filedlg.h"

-    #include "wx/statusbr.h"

     #include "wx/intl.h"
 #endif
 
     #include "wx/intl.h"
 #endif
 

-#include <wx/filename.h>
+#include "wx/filename.h"

 
 

-#include <wx/propgrid/propgrid.h>
+#include "wx/propgrid/propgrid.h"

 
 #define wxPG_CUSTOM_IMAGE_WIDTH     20 // for wxColourProperty etc.
 
 
 #define wxPG_CUSTOM_IMAGE_WIDTH     20 // for wxColourProperty etc.
 

-#include <typeinfo>
-

 
 // -----------------------------------------------------------------------
 // wxStringProperty
 
 // -----------------------------------------------------------------------
 // wxStringProperty


@@ -80,22 +79,30 @@ void wxStringProperty::OnSetValue()
     if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
     {
         wxString s;
     if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
     {
         wxString s;

-        GenerateComposedValue(s, 0);
+        DoGenerateComposedValue(s);

         m_value = s;
     }
 }
 
 wxStringProperty::~wxStringProperty() { }
 
         m_value = s;
     }
 }
 
 wxStringProperty::~wxStringProperty() { }
 

-wxString wxStringProperty::GetValueAsString( int argFlags ) const
+wxString wxStringProperty::ValueToString( wxVariant& value,
+                                          int argFlags ) const

 {
 {

-    wxString s = m_value.GetString();
+    wxString s = value.GetString();

 
     if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
     {
         // Value stored in m_value is non-editable, non-full value
         if ( (argFlags & wxPG_FULL_VALUE) || (argFlags & wxPG_EDITABLE_VALUE) )
 
     if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
     {
         // Value stored in m_value is non-editable, non-full value
         if ( (argFlags & wxPG_FULL_VALUE) || (argFlags & wxPG_EDITABLE_VALUE) )

-            GenerateComposedValue(s, argFlags);
+        {
+            // Calling this under incorrect conditions will fail
+            wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
+                          "Sorry, currently default wxPGProperty::ValueToString() "
+                          "implementation only works if value is m_value." );
+
+            DoGenerateComposedValue(s, argFlags);
+        }

 
         return s;
     }
 
         return s;
     }


@@ -113,7 +120,7 @@ bool wxStringProperty::StringToValue( wxVariant& variant, const wxString& text,
     if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
         return wxPGProperty::StringToValue(variant, text, argFlags);
 
     if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
         return wxPGProperty::StringToValue(variant, text, argFlags);
 

-    if ( m_value.GetString() != text )
+    if ( variant != text )

     {
         variant = text;
         return true;
     {
         variant = text;
         return true;


@@ -150,21 +157,26 @@ wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
 wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
     const wxLongLong& value ) : wxPGProperty(label,name)
 {
 wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
     const wxLongLong& value ) : wxPGProperty(label,name)
 {

-    SetValue(wxLongLongToVariant(value));
+    SetValue(WXVARIANT(value));

 }
 
 wxIntProperty::~wxIntProperty() { }
 
 }
 
 wxIntProperty::~wxIntProperty() { }
 

-wxString wxIntProperty::GetValueAsString( int ) const
+wxString wxIntProperty::ValueToString( wxVariant& value,
+                                       int WXUNUSED(argFlags) ) const

 {
 {

-    if ( wxPGIsVariantType(m_value, long) )
-        return wxString::Format(wxS("%li"),m_value.GetLong());
-
-       wxLongLong* ll = &wxLongLongFromVariant(m_value);
-       if ( ll )
-               return ll->ToString();
+    if ( value.GetType() == wxPG_VARIANT_TYPE_LONG )
+    {
+        return wxString::Format(wxS("%li"),value.GetLong());
+    }
+    else if ( value.GetType() == wxLongLong_VariantType )
+    {
+           wxLongLong ll;
+        ll << value;
+           return ll.ToString();
+    }

 
 

-       return wxEmptyString;
+    return wxEmptyString;

 }
 
 bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 }
 
 bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const


@@ -188,7 +200,7 @@ bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
         int firstNonZeroPos = 0;
 
 
         int firstNonZeroPos = 0;
 

-        for ( ; i != iMax; i++ )
+        for ( ; i != iMax; ++i )

         {
             wxChar c = *i;
             if ( c != wxS('0') && c != wxS(' ') )
         {
             wxChar c = *i;
             if ( c != wxS('0') && c != wxS(' ') )


@@ -198,7 +210,8 @@ bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
         wxString useText = text.substr(firstNonZeroPos, text.length() - firstNonZeroPos);
 
 
         wxString useText = text.substr(firstNonZeroPos, text.length() - firstNonZeroPos);
 

-        bool isPrevLong = wxPGIsVariantType(variant, long);
+        wxString variantType = variant.GetType();
+        bool isPrevLong = variantType == wxPG_VARIANT_TYPE_LONG;

 
         wxLongLong_t value64 = 0;
 
 
         wxLongLong_t value64 = 0;
 


@@ -206,17 +219,27 @@ bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int
              ( value64 >= INT_MAX || value64 <= INT_MIN )
            )
         {
              ( value64 >= INT_MAX || value64 <= INT_MIN )
            )
         {

-            wxLongLong* _m_value64 = &wxLongLongFromVariant(m_value);
-            if ( isPrevLong || !_m_value64 || _m_value64->GetValue() != value64 )
+            bool doChangeValue = isPrevLong;
+
+            if ( !isPrevLong && variantType == wxLongLong_VariantType )
+            {
+                wxLongLong oldValue;
+                oldValue << variant;
+                if ( oldValue.GetValue() != value64 )
+                    doChangeValue = true;
+            }
+
+            if ( doChangeValue )

             {
             {

-                variant = wxLongLongToVariant(value64);
+                wxLongLong ll(value64);
+                variant << ll;

                 return true;
             }
         }
 
         if ( useText.ToLong( &value32, 0 ) )
         {
                 return true;
             }
         }
 
         if ( useText.ToLong( &value32, 0 ) )
         {

-            if ( !isPrevLong || m_value.GetLong() != value32 )
+            if ( !isPrevLong || variant != value32 )

             {
                 variant = value32;
                 return true;
             {
                 variant = value32;
                 return true;


@@ -231,7 +254,7 @@ bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
 bool wxIntProperty::IntToValue( wxVariant& variant, int value, int WXUNUSED(argFlags) ) const
 {
 
 bool wxIntProperty::IntToValue( wxVariant& variant, int value, int WXUNUSED(argFlags) ) const
 {

-    if ( !wxPGIsVariantType(variant, long) || variant.GetLong() != value )
+    if ( variant.GetType() != wxPG_VARIANT_TYPE_LONG || variant != (long)value )

     {
         variant = (long)value;
         return true;
     {
         variant = (long)value;
         return true;


@@ -267,7 +290,9 @@ bool wxIntProperty::DoValidation( const wxPGProperty* property, wxLongLong_t& va
         if ( value < min )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
         if ( value < min )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )

-                pValidationInfo->m_failureMessage = wxString::Format(_("Value must be %lld or higher"),min);
+                pValidationInfo->SetFailureMessage(
+                    wxString::Format(_("Value must be %lld or higher"),min)
+                    );

             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = min;
             else
             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = min;
             else


@@ -281,7 +306,9 @@ bool wxIntProperty::DoValidation( const wxPGProperty* property, wxLongLong_t& va
         if ( value > max )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
         if ( value > max )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )

-                pValidationInfo->m_failureMessage = wxString::Format(_("Value must be %lld or higher"),min);
+                pValidationInfo->SetFailureMessage(
+                    wxString::Format(_("Value must be %lld or higher"),min)
+                    );

             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = max;
             else
             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = max;
             else


@@ -365,27 +392,33 @@ wxUIntProperty::wxUIntProperty( const wxString& label, const wxString& name,
     const wxULongLong& value ) : wxPGProperty(label,name)
 {
     Init();
     const wxULongLong& value ) : wxPGProperty(label,name)
 {
     Init();

-    SetValue(wxULongLongToVariant(value));
+    SetValue(WXVARIANT(value));

 }
 
 wxUIntProperty::~wxUIntProperty() { }
 
 }
 
 wxUIntProperty::~wxUIntProperty() { }
 

-wxString wxUIntProperty::GetValueAsString( int ) const
+wxString wxUIntProperty::ValueToString( wxVariant& value,
+                                        int WXUNUSED(argFlags) ) const

 {
     size_t index = m_base + m_prefix;
     if ( index >= wxPG_UINT_TEMPLATE_MAX )
         index = wxPG_BASE_DEC;
 
 {
     size_t index = m_base + m_prefix;
     if ( index >= wxPG_UINT_TEMPLATE_MAX )
         index = wxPG_BASE_DEC;
 

-    if ( wxPGIsVariantType(m_value, long) )
-        return wxString::Format(gs_uintTemplates32[index],(unsigned long)m_value.GetLong());
-    else
-        return wxString::Format(gs_uintTemplates64[index],wxULongLongFromVariant(m_value).GetValue());
+    if ( value.GetType() == wxPG_VARIANT_TYPE_LONG )
+    {
+        return wxString::Format(gs_uintTemplates32[index], (unsigned long)value.GetLong());
+    }
+
+    wxULongLong ull;
+    ull << value;
+
+    return wxString::Format(gs_uintTemplates64[index], ull.GetValue());

 }
 
 bool wxUIntProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
 {
 }
 
 bool wxUIntProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
 {

-    //long unsigned value32 = 0;
-    bool isPrevLong = wxPGIsVariantType(variant, long);
+    wxString variantType = variant.GetType();
+    bool isPrevLong = variantType == wxPG_VARIANT_TYPE_LONG;

 
     if ( text.length() == 0 )
     {
 
     if ( text.length() == 0 )
     {


@@ -404,17 +437,27 @@ bool wxUIntProperty::StringToValue( wxVariant& variant, const wxString& text, in
     {
         if ( value64 >= LONG_MAX )
         {
     {
         if ( value64 >= LONG_MAX )
         {

-            wxULongLong* _m_value64 = &wxULongLongFromVariant(m_value);
-            if ( isPrevLong || !_m_value64 || _m_value64->GetValue() != value64 )
+            bool doChangeValue = isPrevLong;
+
+            if ( !isPrevLong && variantType == wxULongLong_VariantType )

             {
             {

-                variant = wxULongLongToVariant(value64);
+                wxULongLong oldValue;
+                oldValue << variant;
+                if ( oldValue.GetValue() != value64 )
+                    doChangeValue = true;
+            }
+
+            if ( doChangeValue )
+            {
+                wxULongLong ull(value64);
+                variant << ull;

                 return true;
             }
         }
         else
         {
             unsigned long value32 = wxLongLong(value64).GetLo();
                 return true;
             }
         }
         else
         {
             unsigned long value32 = wxLongLong(value64).GetLo();

-            if ( !isPrevLong || m_value.GetLong() != (long)value32 )
+            if ( !isPrevLong || m_value != (long)value32 )

             {
                 variant = (long)value32;
                 return true;
             {
                 variant = (long)value32;
                 return true;


@@ -427,7 +470,7 @@ bool wxUIntProperty::StringToValue( wxVariant& variant, const wxString& text, in
 
 bool wxUIntProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
 {
 
 bool wxUIntProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
 {

-    if ( m_value != (long)number )
+    if ( variant != (long)number )

     {
         variant = (long)number;
         return true;
     {
         variant = (long)number;
         return true;


@@ -459,7 +502,9 @@ bool wxUIntProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& valida
             wxPGVariantToULongLong(variant, &min);
             if ( ll < min )
             {
             wxPGVariantToULongLong(variant, &min);
             if ( ll < min )
             {

-                validationInfo.m_failureMessage = wxString::Format(_("Value must be %llu or higher"),min);
+                validationInfo.SetFailureMessage(
+                    wxString::Format(_("Value must be %llu or higher"),min)
+                    );

                 return false;
             }
         }
                 return false;
             }
         }


@@ -469,7 +514,9 @@ bool wxUIntProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& valida
             wxPGVariantToULongLong(variant, &max);
             if ( ll > max )
             {
             wxPGVariantToULongLong(variant, &max);
             if ( ll > max )
             {

-                validationInfo.m_failureMessage = wxString::Format(_("Value must be %llu or less"),max);
+                validationInfo.SetFailureMessage(
+                    wxString::Format(_("Value must be %llu or less"),max)
+                    );

                 return false;
             }
         }
                 return false;
             }
         }


@@ -559,7 +606,7 @@ void wxPropertyGrid::DoubleToString(wxString& target,
         wxString::const_iterator i = target.end() - 1;
         size_t new_len = target.length() - 1;
 
         wxString::const_iterator i = target.end() - 1;
         size_t new_len = target.length() - 1;
 

-        for ( ; i != target.begin(); i-- )
+        for ( ; i != target.begin(); --i )

         {
             if ( *i != wxS('0') )
                 break;
         {
             if ( *i != wxS('0') )
                 break;


@@ -575,16 +622,17 @@ void wxPropertyGrid::DoubleToString(wxString& target,
     }
 }
 
     }
 }
 

-wxString wxFloatProperty::GetValueAsString( int argFlags ) const
+wxString wxFloatProperty::ValueToString( wxVariant& value,
+                                         int argFlags ) const

 {
     wxString text;
 {
     wxString text;

-    if ( !m_value.IsNull() )
+    if ( !value.IsNull() )

     {
         wxPropertyGrid::DoubleToString(text,
     {
         wxPropertyGrid::DoubleToString(text,

-                                       m_value,
+                                       value,

                                        m_precision,
                                        !(argFlags & wxPG_FULL_VALUE),
                                        m_precision,
                                        !(argFlags & wxPG_FULL_VALUE),

-                                       (wxString*) NULL);
+                                       NULL);

     }
     return text;
 }
     }
     return text;
 }


@@ -603,7 +651,7 @@ bool wxFloatProperty::StringToValue( wxVariant& variant, const wxString& text, i
     bool res = text.ToDouble(&value);
     if ( res )
     {
     bool res = text.ToDouble(&value);
     if ( res )
     {

-        if ( m_value != value )
+        if ( variant != value )

         {
             variant = value;
             return true;
         {
             variant = value;
             return true;


@@ -643,7 +691,9 @@ bool wxFloatProperty::DoValidation( const wxPGProperty* property, double& value,
         if ( value < min )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
         if ( value < min )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )

-                pValidationInfo->m_failureMessage = wxString::Format(_("Value must be %f or higher"),min);
+                pValidationInfo->SetFailureMessage(
+                    wxString::Format(_("Value must be %f or higher"),min)
+                    );

             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = min;
             else
             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = min;
             else


@@ -658,7 +708,9 @@ bool wxFloatProperty::DoValidation( const wxPGProperty* property, double& value,
         if ( value > max )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
         if ( value > max )
         {
             if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )

-                pValidationInfo->m_failureMessage = wxString::Format(_("Value must be %f or less"),max);
+                pValidationInfo->SetFailureMessage(
+                    wxString::Format(_("Value must be %f or less"),max)
+                    );

             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = max;
             else
             else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
                 value = max;
             else


@@ -706,16 +758,18 @@ const wxPGEditor* wxBoolProperty::DoGetEditorClass() const
     // Select correct editor control.
 #if wxPG_INCLUDE_CHECKBOX
     if ( !(m_flags & wxPG_PROP_USE_CHECKBOX) )
     // Select correct editor control.
 #if wxPG_INCLUDE_CHECKBOX
     if ( !(m_flags & wxPG_PROP_USE_CHECKBOX) )

-        return wxPG_EDITOR(Choice);
-    return wxPG_EDITOR(CheckBox);
+        return wxPGEditor_Choice;
+    return wxPGEditor_CheckBox;

 #else
 #else

-    return wxPG_EDITOR(Choice);
+    return wxPGEditor_Choice;

 #endif
 }
 
 wxBoolProperty::wxBoolProperty( const wxString& label, const wxString& name, bool value ) :
     wxPGProperty(label,name)
 {
 #endif
 }
 
 wxBoolProperty::wxBoolProperty( const wxString& label, const wxString& name, bool value ) :
     wxPGProperty(label,name)
 {

+    m_choices.Assign(wxPGGlobalVars->m_boolChoices);
+

     SetValue(wxPGVariant_Bool(value));
 
     m_flags |= wxPG_PROP_USE_DCC;
     SetValue(wxPGVariant_Bool(value));
 
     m_flags |= wxPG_PROP_USE_DCC;


@@ -723,15 +777,16 @@ wxBoolProperty::wxBoolProperty( const wxString& label, const wxString& name, boo
 
 wxBoolProperty::~wxBoolProperty() { }
 
 
 wxBoolProperty::~wxBoolProperty() { }
 

-wxString wxBoolProperty::GetValueAsString( int argFlags ) const
+wxString wxBoolProperty::ValueToString( wxVariant& value,
+                                        int argFlags ) const

 {
 {

-    bool value = m_value.GetBool();
+    bool boolValue = value.GetBool();

 
     // As a fragment of composite string value,
     // make it a little more readable.
     if ( argFlags & wxPG_COMPOSITE_FRAGMENT )
     {
 
     // As a fragment of composite string value,
     // make it a little more readable.
     if ( argFlags & wxPG_COMPOSITE_FRAGMENT )
     {

-        if ( value )
+        if ( boolValue )

         {
             return m_label;
         }
         {
             return m_label;
         }


@@ -740,46 +795,36 @@ wxString wxBoolProperty::GetValueAsString( int argFlags ) const
             if ( argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT )
                 return wxEmptyString;
 
             if ( argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT )
                 return wxEmptyString;
 

-            const wxChar* notFmt;
+            wxString notFmt;

             if ( wxPGGlobalVars->m_autoGetTranslation )
                 notFmt = _("Not %s");
             else
             if ( wxPGGlobalVars->m_autoGetTranslation )
                 notFmt = _("Not %s");
             else

-                notFmt = wxT("Not %s");
+                notFmt = wxS("Not %s");

 
 

-            return wxString::Format(notFmt,m_label.c_str());
+            return wxString::Format(notFmt.c_str(), m_label.c_str());

         }
     }
 
     if ( !(argFlags & wxPG_FULL_VALUE) )
     {
         }
     }
 
     if ( !(argFlags & wxPG_FULL_VALUE) )
     {

-        return wxPGGlobalVars->m_boolChoices[value?1:0].GetText();
+        return wxPGGlobalVars->m_boolChoices[boolValue?1:0].GetText();

     }
 
     wxString text;
 
     }
 
     wxString text;
 

-    if (value) text = wxS("true");
+    if ( boolValue ) text = wxS("true");

     else text = wxS("false");
 
     return text;
 }
 
     else text = wxS("false");
 
     return text;
 }
 

-int wxBoolProperty::GetChoiceInfo( wxPGChoiceInfo* choiceinfo )
-{
-    if ( IsValueUnspecified() )
-        return -1;
-
-    if ( choiceinfo )
-        choiceinfo->m_choices = &wxPGGlobalVars->m_boolChoices;
-    return m_value.GetBool()?1:0;
-}
-

 bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
 {
 bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
 {

-    int value = 0;
+    bool boolValue = false;

     if ( text.CmpNoCase(wxPGGlobalVars->m_boolChoices[1].GetText()) == 0 ||
          text.CmpNoCase(wxS("true")) == 0 ||
          text.CmpNoCase(m_label) == 0 )
     if ( text.CmpNoCase(wxPGGlobalVars->m_boolChoices[1].GetText()) == 0 ||
          text.CmpNoCase(wxS("true")) == 0 ||
          text.CmpNoCase(m_label) == 0 )

-        value = 1;
+        boolValue = true;

 
     if ( text.length() == 0 )
     {
 
     if ( text.length() == 0 )
     {


@@ -787,11 +832,9 @@ bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, in
         return true;
     }
 
         return true;
     }
 

-    bool oldValue = m_value.GetBool();
-
-    if ( (oldValue && !value) || (!oldValue && value) )
+    if ( variant != boolValue )

     {
     {

-        variant = wxPGVariant_Bool(value);
+        variant = wxPGVariant_Bool(boolValue);

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


@@ -800,9 +843,8 @@ bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, in
 bool wxBoolProperty::IntToValue( wxVariant& variant, int value, int ) const
 {
     bool boolValue = value ? true : false;
 bool wxBoolProperty::IntToValue( wxVariant& variant, int value, int ) const
 {
     bool boolValue = value ? true : false;

-    bool oldValue = m_value.GetBool();

 
 

-    if ( oldValue != boolValue )
+    if ( variant != boolValue )

     {
         variant = wxPGVariant_Bool(boolValue);
         return true;
     {
         variant = wxPGVariant_Bool(boolValue);
         return true;


@@ -836,33 +878,103 @@ bool wxBoolProperty::DoSetAttribute( const wxString& name, wxVariant& value )
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------

-// wxBaseEnumProperty
+// wxEnumProperty

 // -----------------------------------------------------------------------
 
 // -----------------------------------------------------------------------
 

-int wxBaseEnumProperty::ms_nextIndex = -2;
+IMPLEMENT_DYNAMIC_CLASS(wxEnumProperty, wxPGProperty)
+
+WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEnumProperty,long,Choice)
+
+wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
+    const long* values, int value ) : wxPGProperty(label,name)
+{
+    SetIndex(0);
+
+    if ( labels )
+    {
+        m_choices.Add(labels,values);
+
+        if ( GetItemCount() )
+            SetValue( (long)value );
+    }
+}
+
+wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
+    const long* values, wxPGChoices* choicesCache, int value )
+    : wxPGProperty(label,name)
+{
+    SetIndex(0);
+
+    wxASSERT( choicesCache );
+
+    if ( choicesCache->IsOk() )
+    {
+        m_choices.Assign( *choicesCache );
+        m_value = wxPGVariant_Zero;
+    }
+    else if ( labels )
+    {
+        m_choices.Add(labels,values);
+
+        if ( GetItemCount() )
+            SetValue( (long)value );
+    }
+}
+
+wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
+    const wxArrayString& labels, const wxArrayInt& values, int value )
+    : wxPGProperty(label,name)
+{
+    SetIndex(0);
+
+    if ( &labels && labels.size() )
+    {
+        m_choices.Set(labels, values);

 
 

-wxBaseEnumProperty::wxBaseEnumProperty( const wxString& label, const wxString& name )
+        if ( GetItemCount() )
+            SetValue( (long)value );
+    }
+}
+
+wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
+    wxPGChoices& choices, int value )

     : wxPGProperty(label,name)
 {
     : wxPGProperty(label,name)
 {

-    m_value = wxPGVariant_Zero;
+    m_choices.Assign( choices );
+
+    if ( GetItemCount() )
+        SetValue( (long)value );

 }
 
 }
 

-/** If has values array, then returns number at index with value -
-    otherwise just returns the value.
-*/
-int wxBaseEnumProperty::GetIndexForValue( int value ) const
+int wxEnumProperty::GetIndexForValue( int value ) const

 {
 {

+    if ( !m_choices.IsOk() )
+        return -1;
+
+    int intVal = m_choices.Index(value);
+    if ( intVal >= 0 )
+        return intVal;
+

     return value;
 }
 
     return value;
 }
 

-void wxBaseEnumProperty::OnSetValue()
+wxEnumProperty::~wxEnumProperty ()

 {
 {

-    if ( wxPGIsVariantType(m_value, long) )
+}
+
+int wxEnumProperty::ms_nextIndex = -2;
+int wxEnumProperty::ms_prevIndex = -1;
+
+void wxEnumProperty::OnSetValue()
+{
+    wxString variantType = m_value.GetType();
+
+    if ( variantType == wxPG_VARIANT_TYPE_LONG )

         ValueFromInt_( m_value, m_value.GetLong(), wxPG_FULL_VALUE );
         ValueFromInt_( m_value, m_value.GetLong(), wxPG_FULL_VALUE );

-    else if ( wxPGIsVariantType(m_value, string) )
+    else if ( variantType == wxPG_VARIANT_TYPE_STRING )

         ValueFromString_( m_value, m_value.GetString(), 0 );
     else
         ValueFromString_( m_value, m_value.GetString(), 0 );
     else

-        wxASSERT( false );
+        wxFAIL;

 
     if ( ms_nextIndex != -2 )
     {
 
     if ( ms_nextIndex != -2 )
     {


@@ -871,64 +983,55 @@ void wxBaseEnumProperty::OnSetValue()
     }
 }
 
     }
 }
 

-bool wxBaseEnumProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& WXUNUSED(validationInfo) ) const
+bool wxEnumProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& WXUNUSED(validationInfo) ) const

 {
     // Make sure string value is in the list,
     // unless property has string as preferred value type
     // To reduce code size, use conversion here as well
 {
     // Make sure string value is in the list,
     // unless property has string as preferred value type
     // To reduce code size, use conversion here as well

-    if ( wxPGIsVariantType(value, string) &&
+    if ( value.GetType() == wxPG_VARIANT_TYPE_STRING &&

          !this->IsKindOf(CLASSINFO(wxEditEnumProperty)) )
         return ValueFromString_( value, value.GetString(), wxPG_PROPERTY_SPECIFIC );
 
     return true;
 }
 
          !this->IsKindOf(CLASSINFO(wxEditEnumProperty)) )
         return ValueFromString_( value, value.GetString(), wxPG_PROPERTY_SPECIFIC );
 
     return true;
 }
 

-wxString wxBaseEnumProperty::GetValueAsString( int ) const
+wxString wxEnumProperty::ValueToString( wxVariant& value,
+                                            int WXUNUSED(argFlags) ) const

 {
 {

-    if ( wxPGIsVariantType(m_value, string) )
-        return m_value.GetString();
+    if ( value.GetType() == wxPG_VARIANT_TYPE_STRING )
+        return value.GetString();

 
 

-    if ( m_index >= 0 )
-    {
-        int unusedVal;
-        const wxString* pstr = GetEntry( m_index, &unusedVal );
+    int index = m_choices.Index(value.GetLong());
+    if ( index < 0 )
+        return wxEmptyString;

 
 

-        if ( pstr )
-            return *pstr;
-    }
-    return wxEmptyString;
+    return m_choices.GetLabel(index);

 }
 
 }
 

-bool wxBaseEnumProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
+bool wxEnumProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const

 {
     return ValueFromString_( variant, text, argFlags );
 }
 
 {
     return ValueFromString_( variant, text, argFlags );
 }
 

-bool wxBaseEnumProperty::IntToValue( wxVariant& variant, int intVal, int argFlags ) const
+bool wxEnumProperty::IntToValue( wxVariant& variant, int intVal, int argFlags ) const

 {
     return ValueFromInt_( variant, intVal, argFlags );
 }
 
 {
     return ValueFromInt_( variant, intVal, argFlags );
 }
 

-bool wxBaseEnumProperty::ValueFromString_( wxVariant& value, const wxString& text, int argFlags ) const
+bool wxEnumProperty::ValueFromString_( wxVariant& value, const wxString& text, int argFlags ) const

 {
 {

-    size_t i = 0;
-    const wxString* entryLabel;
-    int entryValue;

     int useIndex = -1;
     long useValue = 0;
 
     int useIndex = -1;
     long useValue = 0;
 

-    entryLabel = GetEntry(i, &entryValue);
-    while ( entryLabel )
+    for ( unsigned int i=0; i<m_choices.GetCount(); i++ )

     {
     {

-        if ( text.CmpNoCase(*entryLabel) == 0 )
+        const wxString& entryLabel = m_choices.GetLabel(i);
+        if ( text.CmpNoCase(entryLabel) == 0 )

         {
             useIndex = (int)i;
         {
             useIndex = (int)i;

-            useValue = (long)entryValue;
+            useValue = m_choices.GetValue(i);

             break;
         }
             break;
         }

-
-        i++;
-        entryLabel = GetEntry(i, &entryValue);

     }
 
     bool asText = false;
     }
 
     bool asText = false;


@@ -938,7 +1041,7 @@ bool wxBaseEnumProperty::ValueFromString_( wxVariant& value, const wxString& tex
     // If text not any of the choices, store as text instead
     // (but only if we are wxEditEnumProperty)
     if ( useIndex == -1 &&
     // If text not any of the choices, store as text instead
     // (but only if we are wxEditEnumProperty)
     if ( useIndex == -1 &&

-         (!wxPGIsVariantType(m_value, string) || (m_value.GetString() != text)) &&
+         (value.GetType() != wxPG_VARIANT_TYPE_STRING || (m_value.GetString() != text)) &&

          isEdit )
     {
         asText = true;
          isEdit )
     {
         asText = true;


@@ -951,7 +1054,7 @@ bool wxBaseEnumProperty::ValueFromString_( wxVariant& value, const wxString& tex
         setAsNextIndex = -1;
         value = text;
     }
         setAsNextIndex = -1;
         value = text;
     }

-    else if ( m_index != useIndex )
+    else if ( useIndex != GetIndex() )

     {
         if ( useIndex != -1 )
         {
     {
         if ( useIndex != -1 )
         {


@@ -980,7 +1083,7 @@ bool wxBaseEnumProperty::ValueFromString_( wxVariant& value, const wxString& tex
     return false;
 }
 
     return false;
 }
 

-bool wxBaseEnumProperty::ValueFromInt_( wxVariant& variant, int intVal, int argFlags ) const
+bool wxEnumProperty::ValueFromInt_( wxVariant& variant, int intVal, int argFlags ) const

 {
     // If wxPG_FULL_VALUE is *not* in argFlags, then intVal is index from combo box.
     //
 {
     // If wxPG_FULL_VALUE is *not* in argFlags, then intVal is index from combo box.
     //


@@ -992,7 +1095,7 @@ bool wxBaseEnumProperty::ValueFromInt_( wxVariant& variant, int intVal, int argF
     }
     else
     {
     }
     else
     {

-        if ( m_index != intVal )
+        if ( intVal != GetIndex() )

         {
             ms_nextIndex = intVal;
         }
         {
             ms_nextIndex = intVal;
         }


@@ -1001,7 +1104,7 @@ bool wxBaseEnumProperty::ValueFromInt_( wxVariant& variant, int intVal, int argF
     if ( ms_nextIndex != -2 )
     {
         if ( !(argFlags & wxPG_FULL_VALUE) )
     if ( ms_nextIndex != -2 )
     {
         if ( !(argFlags & wxPG_FULL_VALUE) )

-            GetEntry(intVal, &intVal);
+            intVal = m_choices.GetValue(intVal);

 
         variant = (long)intVal;
 
 
         variant = (long)intVal;
 


@@ -1011,131 +1114,30 @@ bool wxBaseEnumProperty::ValueFromInt_( wxVariant& variant, int intVal, int argF
     return false;
 }
 
     return false;
 }
 

-void wxBaseEnumProperty::SetIndex( int index )
-{
-    ms_nextIndex = -2;
-    m_index = index;
-}
-
-int wxBaseEnumProperty::GetIndex() const
-{
-    if ( ms_nextIndex != -2 )
-        return ms_nextIndex;
-    return m_index;
-}
-
-// -----------------------------------------------------------------------
-// wxEnumProperty
-// -----------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxEnumProperty, wxPGProperty)
-
-WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEnumProperty,long,Choice)
-
-wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
-    const long* values, int value ) : wxBaseEnumProperty(label,name)
-{
-    SetIndex(0);
-
-    if ( labels )
-    {
-        m_choices.Add(labels,values);
-
-        if ( GetItemCount() )
-            SetValue( (long)value );
-    }
-}
-
-wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar** labels,
-    const long* values, wxPGChoices* choicesCache, int value )
-    : wxBaseEnumProperty(label,name)
-{
-    SetIndex(0);
-
-    wxASSERT( choicesCache );
-
-    if ( choicesCache->IsOk() )
-    {
-        m_choices.Assign( *choicesCache );
-        m_value = wxPGVariant_Zero;
-    }
-    else if ( labels )
-    {
-        m_choices.Add(labels,values);
-
-        if ( GetItemCount() )
-            SetValue( (long)value );
-    }
-}
-
-wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
-    const wxArrayString& labels, const wxArrayInt& values, int value ) : wxBaseEnumProperty(label,name)
+void
+wxEnumProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )

 {
 {

-    SetIndex(0);
-
-    if ( &labels && labels.size() )
-    {
-        m_choices.Set(labels, values);
-
-        if ( GetItemCount() )
-            SetValue( (long)value );
-    }
+    // Revert index
+    m_index = ms_prevIndex;
+    ResetNextIndex();

 }
 
 }
 

-wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
-    wxPGChoices& choices, int value )
-    : wxBaseEnumProperty(label,name)
+void wxEnumProperty::SetIndex( int index )

 {
 {

-    m_choices.Assign( choices );
-
-    if ( GetItemCount() )
-        SetValue( (long)value );
+    ms_prevIndex = m_index;
+    ms_nextIndex = -2;
+    m_index = index;

 }
 
 }
 

-int wxEnumProperty::GetIndexForValue( int value ) const
+int wxEnumProperty::GetIndex() const

 {
 {

-    if ( !m_choices.IsOk() )
+    if ( m_value.IsNull() )

         return -1;
 
         return -1;
 

-    if ( m_choices.HasValues() )
-    {
-        int intVal = m_choices.Index(value);
-        if ( intVal >= 0 )
-            return intVal;
-    }
-
-    return value;
-}
-
-wxEnumProperty::~wxEnumProperty ()
-{
-}
-
-const wxString* wxEnumProperty::GetEntry( size_t index, int* pvalue ) const
-{
-    if ( m_choices.IsOk() && index < m_choices.GetCount() )
-    {
-        int value = (int)index;
-        if ( m_choices.HasValue(index) )
-            value = m_choices.GetValue(index);
-
-        if ( pvalue )
-            *pvalue = value;
-
-        return &m_choices.GetLabel(index);
-    }
-    return (const wxString*) NULL;
-}
-
-int wxEnumProperty::GetChoiceInfo( wxPGChoiceInfo* choiceinfo )
-{
-    if ( choiceinfo )
-        choiceinfo->m_choices = &m_choices;
-
-    if ( !m_choices.IsOk() )
-        return -1;
+    if ( ms_nextIndex != -2 )
+        return ms_nextIndex;

 
 

-    return GetIndex();
+    return m_index;

 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------


@@ -1188,8 +1190,7 @@ WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxFlagsProperty,long,TextCtrl)
 
 void wxFlagsProperty::Init()
 {
 
 void wxFlagsProperty::Init()
 {

-    SetFlag(wxPG_PROP_AGGREGATE);  // This is must be done here to support flag props
-                                   // with inital zero children.
+    SetParentalType(wxPG_PROP_AGGREGATE);

 
     long value = m_value;
 
 
     long value = m_value;
 


@@ -1198,7 +1199,7 @@ void wxFlagsProperty::Init()
     //
     unsigned int i;
 
     //
     unsigned int i;
 

-    unsigned int prevChildCount = m_children.GetCount();
+    unsigned int prevChildCount = m_children.size();

 
     int oldSel = -1;
     if ( prevChildCount )
 
     int oldSel = -1;
     if ( prevChildCount )


@@ -1214,7 +1215,7 @@ void wxFlagsProperty::Init()
             if ( selected )
             {
                 if ( selected->GetParent() == this )
             if ( selected )
             {
                 if ( selected->GetParent() == this )

-                    oldSel = selected->GetArrIndex();
+                    oldSel = selected->GetIndexInParent();

                 else if ( selected == this )
                     oldSel = -2;
             }
                 else if ( selected == this )
                     oldSel = -2;
             }


@@ -1224,9 +1225,9 @@ void wxFlagsProperty::Init()
 
     // Delete old children
     for ( i=0; i<prevChildCount; i++ )
 
     // Delete old children
     for ( i=0; i<prevChildCount; i++ )

-        delete ( (wxPGProperty*) m_children[i] );
+        delete m_children[i];

 
 

-    m_children.Empty();
+    m_children.clear();

 
     if ( m_choices.IsOk() )
     {
 
     if ( m_choices.IsOk() )
     {


@@ -1235,22 +1236,20 @@ void wxFlagsProperty::Init()
         for ( i=0; i<GetItemCount(); i++ )
         {
             bool child_val;
         for ( i=0; i<GetItemCount(); i++ )
         {
             bool child_val;

-            if ( choices.HasValue(i) )
-                child_val = ( value & choices.GetValue(i) )?true:false;
-            else
-                child_val = ( value & (1<<i) )?true:false;
+            child_val = ( value & choices.GetValue(i) )?true:false;

 
             wxPGProperty* boolProp;
 
             wxPGProperty* boolProp;

+            wxString label = GetLabel(i);

 
         #if wxUSE_INTL
             if ( wxPGGlobalVars->m_autoGetTranslation )
             {
 
         #if wxUSE_INTL
             if ( wxPGGlobalVars->m_autoGetTranslation )
             {

-                boolProp = new wxBoolProperty( ::wxGetTranslation( GetLabel(i) ), wxEmptyString, child_val );
+                boolProp = new wxBoolProperty( ::wxGetTranslation(label), label, child_val );

             }
             else
         #endif
             {
             }
             else
         #endif
             {

-                boolProp = new wxBoolProperty( GetLabel(i), wxEmptyString, child_val );
+                boolProp = new wxBoolProperty( label, label, child_val );

             }
             AddChild(boolProp);
         }
             }
             AddChild(boolProp);
         }


@@ -1267,7 +1266,7 @@ void wxFlagsProperty::Init()
 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
     const wxChar** labels, const long* values, long value ) : wxPGProperty(label,name)
 {
 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
     const wxChar** labels, const long* values, long value ) : wxPGProperty(label,name)
 {

-    m_oldChoicesData = (wxPGChoicesData*) NULL;
+    m_oldChoicesData = NULL;

 
     if ( labels )
     {
 
     if ( labels )
     {


@@ -1287,7 +1286,7 @@ wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
         const wxArrayString& labels, const wxArrayInt& values, int value )
     : wxPGProperty(label,name)
 {
         const wxArrayString& labels, const wxArrayInt& values, int value )
     : wxPGProperty(label,name)
 {

-    m_oldChoicesData = (wxPGChoicesData*) NULL;
+    m_oldChoicesData = NULL;

 
     if ( &labels && labels.size() )
     {
 
     if ( &labels && labels.size() )
     {


@@ -1307,7 +1306,7 @@ wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
     wxPGChoices& choices, long value )
     : wxPGProperty(label,name)
 {
     wxPGChoices& choices, long value )
     : wxPGProperty(label,name)
 {

-    m_oldChoicesData = (wxPGChoicesData*) NULL;
+    m_oldChoicesData = NULL;

 
     if ( choices.IsOk() )
     {
 
     if ( choices.IsOk() )
     {


@@ -1344,10 +1343,7 @@ void wxFlagsProperty::OnSetValue()
         const wxPGChoices& choices = m_choices;
         for ( i = 0; i < GetItemCount(); i++ )
         {
         const wxPGChoices& choices = m_choices;
         for ( i = 0; i < GetItemCount(); i++ )
         {

-            if ( choices.HasValue(i) )
-                fullFlags |= choices.GetValue(i);
-            else
-                fullFlags |= (1<<i);
+            fullFlags |= choices.GetValue(i);

         }
 
         val &= fullFlags;
         }
 
         val &= fullFlags;


@@ -1373,10 +1369,7 @@ void wxFlagsProperty::OnSetValue()
         {
             int flag;
 
         {
             int flag;
 

-            if ( choices.HasValue(i) )
-                flag = choices.GetValue(i);
-            else
-                flag = (1<<i);
+            flag = choices.GetValue(i);

 
             if ( (newFlags & flag) != (m_oldValue & flag) )
                 Item(i)->SetFlag( wxPG_PROP_MODIFIED );
 
             if ( (newFlags & flag) != (m_oldValue & flag) )
                 Item(i)->SetFlag( wxPG_PROP_MODIFIED );


@@ -1386,24 +1379,22 @@ void wxFlagsProperty::OnSetValue()
     }
 }
 
     }
 }
 

-wxString wxFlagsProperty::GetValueAsString( int ) const
+wxString wxFlagsProperty::ValueToString( wxVariant& value,
+                                         int WXUNUSED(argFlags) ) const

 {
     wxString text;
 
     if ( !m_choices.IsOk() )
         return text;
 
 {
     wxString text;
 
     if ( !m_choices.IsOk() )
         return text;
 

-    long flags = m_value;
+    long flags = value;

     unsigned int i;
     const wxPGChoices& choices = m_choices;
 
     for ( i = 0; i < GetItemCount(); i++ )
     {
         int doAdd;
     unsigned int i;
     const wxPGChoices& choices = m_choices;
 
     for ( i = 0; i < GetItemCount(); i++ )
     {
         int doAdd;

-        if ( choices.HasValue(i) )
-            doAdd = ( flags & choices.GetValue(i) );
-        else
-            doAdd = ( flags & (1<<i) );
+        doAdd = ( flags & choices.GetValue(i) );

 
         if ( doAdd )
         {
 
         if ( doAdd )
         {


@@ -1426,7 +1417,6 @@ bool wxFlagsProperty::StringToValue( wxVariant& variant, const wxString& text, i
         return false;
 
     long newFlags = 0;
         return false;
 
     long newFlags = 0;

-    long oldValue = m_value;

 
     // semicolons are no longer valid delimeters
     WX_PG_TOKENIZER1_BEGIN(text,wxS(','))
 
     // semicolons are no longer valid delimeters
     WX_PG_TOKENIZER1_BEGIN(text,wxS(','))


@@ -1449,10 +1439,11 @@ bool wxFlagsProperty::StringToValue( wxVariant& variant, const wxString& text, i
 
     WX_PG_TOKENIZER1_END()
 
 
     WX_PG_TOKENIZER1_END()
 

-    variant = newFlags;
-
-    if ( newFlags != oldValue )
+    if ( variant != (long)newFlags )
+    {
+        variant = (long)newFlags;

         return true;
         return true;

+    }

 
     return false;
 }
 
     return false;
 }


@@ -1465,9 +1456,7 @@ long wxFlagsProperty::IdToBit( const wxString& id ) const
     {
         if ( id == GetLabel(i) )
         {
     {
         if ( id == GetLabel(i) )
         {

-            if ( m_choices.HasValue(i) )
-                return m_choices.GetValue(i);
-            return (1<<i);
+            return m_choices.GetValue(i);

         }
     }
     return -1;
         }
     }
     return -1;


@@ -1485,10 +1474,7 @@ void wxFlagsProperty::RefreshChildren()
     {
         long flag;
 
     {
         long flag;
 

-        if ( choices.HasValue(i) )
-            flag = choices.GetValue(i);
-        else
-            flag = (1<<i);
+        flag = choices.GetValue(i);

 
         long subVal = flags & flag;
         wxPGProperty* p = Item(i);
 
         long subVal = flags & flag;
         wxPGProperty* p = Item(i);


@@ -1506,32 +1492,25 @@ void wxFlagsProperty::ChildChanged( wxVariant& thisValue, int childIndex, wxVari
 {
     long oldValue = thisValue.GetLong();
     long val = childValue.GetLong();
 {
     long oldValue = thisValue.GetLong();
     long val = childValue.GetLong();

-    unsigned long vi = (1<<childIndex);
-    if ( m_choices.HasValue(childIndex) ) vi = m_choices.GetValue(childIndex);
+    unsigned long vi = m_choices.GetValue(childIndex);

     if ( val )
         thisValue = (long)(oldValue | vi);
     else
         thisValue = (long)(oldValue & ~(vi));
 }
 
     if ( val )
         thisValue = (long)(oldValue | vi);
     else
         thisValue = (long)(oldValue & ~(vi));
 }
 

-int wxFlagsProperty::GetChoiceInfo( wxPGChoiceInfo* choiceinfo )
-{
-    if ( choiceinfo )
-        choiceinfo->m_choices = &m_choices;
-    return -1;
-}
-

 // -----------------------------------------------------------------------
 // wxDirProperty
 // -----------------------------------------------------------------------
 
 // -----------------------------------------------------------------------
 // wxDirProperty
 // -----------------------------------------------------------------------
 

-WX_PG_IMPLEMENT_DERIVED_PROPERTY_CLASS(wxDirProperty,wxLongStringProperty,const wxString&)
+IMPLEMENT_DYNAMIC_CLASS(wxDirProperty, wxLongStringProperty)

 
 wxDirProperty::wxDirProperty( const wxString& name, const wxString& label, const wxString& value )
   : wxLongStringProperty(name,label,value)
 {
 
 wxDirProperty::wxDirProperty( const wxString& name, const wxString& label, const wxString& value )
   : wxLongStringProperty(name,label,value)
 {

-    m_flags |= wxPG_NO_ESCAPE;
+    m_flags |= wxPG_PROP_NO_ESCAPE;

 }
 }

+

 wxDirProperty::~wxDirProperty() { }
 
 wxValidator* wxDirProperty::DoGetValidator() const
 wxDirProperty::~wxDirProperty() { }
 
 wxValidator* wxDirProperty::DoGetValidator() const


@@ -1541,19 +1520,24 @@ wxValidator* wxDirProperty::DoGetValidator() const
 
 bool wxDirProperty::OnButtonClick( wxPropertyGrid* propGrid, wxString& value )
 {
 
 bool wxDirProperty::OnButtonClick( wxPropertyGrid* propGrid, wxString& value )
 {

+    // Update property value from editor, if necessary

     wxSize dlg_sz(300,400);
 
     wxSize dlg_sz(300,400);
 

+    wxString dlgMessage(m_dlgMessage);
+    if ( dlgMessage.empty() )
+        dlgMessage = _("Choose a directory:");

     wxDirDialog dlg( propGrid,
     wxDirDialog dlg( propGrid,

-                     m_dlgMessage.length() ? m_dlgMessage : wxString(_("Choose a directory:")),
+                     dlgMessage,

                      value,
                      0,
 #if !wxPG_SMALL_SCREEN
                      propGrid->GetGoodEditorDialogPosition(this,dlg_sz),
                      value,
                      0,
 #if !wxPG_SMALL_SCREEN
                      propGrid->GetGoodEditorDialogPosition(this,dlg_sz),

-                     dlg_sz );
+                     dlg_sz

 #else
                      wxDefaultPosition,
 #else
                      wxDefaultPosition,

-                     wxDefaultSize );
+                     wxDefaultSize

 #endif
 #endif

+                    );

 
     if ( dlg.ShowModal() == wxID_OK )
     {
 
     if ( dlg.ShowModal() == wxID_OK )
     {


@@ -1586,7 +1570,8 @@ bool wxPGFileDialogAdapter::DoShowDialog( wxPropertyGrid* propGrid, wxPGProperty
     if ( property->IsKindOf(CLASSINFO(wxFileProperty)) )
     {
         fileProp = ((wxFileProperty*)property);
     if ( property->IsKindOf(CLASSINFO(wxFileProperty)) )
     {
         fileProp = ((wxFileProperty*)property);

-        path = fileProp->m_filename.GetPath();
+        wxFileName filename = fileProp->GetValue().GetString();
+        path = filename.GetPath();

         indFilter = fileProp->m_indFilter;
 
         if ( !path.length() && fileProp->m_basePath.length() )
         indFilter = fileProp->m_indFilter;
 
         if ( !path.length() && fileProp->m_basePath.length() )


@@ -1672,18 +1657,17 @@ void wxFileProperty::OnSetValue()
 {
     const wxString& fnstr = m_value.GetString();
 
 {
     const wxString& fnstr = m_value.GetString();
 

-    m_filename = fnstr;
+    wxFileName filename = fnstr;

 
 

-    if ( !m_filename.HasName() )
+    if ( !filename.HasName() )

     {
         m_value = wxPGVariant_EmptyString;
     {
         m_value = wxPGVariant_EmptyString;

-        m_filename.Clear();

     }
 
     // Find index for extension.
     if ( m_indFilter < 0 && fnstr.length() )
     {
     }
 
     // Find index for extension.
     if ( m_indFilter < 0 && fnstr.length() )
     {

-        wxString ext = m_filename.GetExt();
+        wxString ext = filename.GetExt();

         int curind = 0;
         size_t pos = 0;
         size_t len = m_wildcard.length();
         int curind = 0;
         size_t pos = 0;
         size_t len = m_wildcard.length();


@@ -1720,29 +1704,44 @@ void wxFileProperty::OnSetValue()
     }
 }
 
     }
 }
 

-wxString wxFileProperty::GetValueAsString( int argFlags ) const
+wxFileName wxFileProperty::GetFileName() const
+{
+    wxFileName filename;
+
+    if ( !m_value.IsNull() )
+        filename = m_value.GetString();
+
+    return filename;
+}
+
+wxString wxFileProperty::ValueToString( wxVariant& value,
+                                        int argFlags ) const

 {
 {

-    // Always return empty string when name component is empty
-    wxString fullName = m_filename.GetFullName();
+    wxFileName filename = value.GetString();
+
+    if ( !filename.HasName() )
+        return wxEmptyString;
+
+    wxString fullName = filename.GetFullName();

     if ( !fullName.length() )
     if ( !fullName.length() )

-        return fullName;
+        return wxEmptyString;

 
     if ( argFlags & wxPG_FULL_VALUE )
     {
 
     if ( argFlags & wxPG_FULL_VALUE )
     {

-        return m_filename.GetFullPath();
+        return filename.GetFullPath();

     }
     else if ( m_flags & wxPG_PROP_SHOW_FULL_FILENAME )
     {
         if ( m_basePath.Length() )
         {
     }
     else if ( m_flags & wxPG_PROP_SHOW_FULL_FILENAME )
     {
         if ( m_basePath.Length() )
         {

-            wxFileName fn2(m_filename);
+            wxFileName fn2(filename);

             fn2.MakeRelativeTo(m_basePath);
             return fn2.GetFullPath();
         }
             fn2.MakeRelativeTo(m_basePath);
             return fn2.GetFullPath();
         }

-        return m_filename.GetFullPath();
+        return filename.GetFullPath();

     }
 
     }
 

-    return m_filename.GetFullName();
+    return filename.GetFullName();

 }
 
 wxPGEditorDialogAdapter* wxFileProperty::GetEditorDialog() const
 }
 
 wxPGEditorDialogAdapter* wxFileProperty::GetEditorDialog() const


@@ -1752,9 +1751,11 @@ wxPGEditorDialogAdapter* wxFileProperty::GetEditorDialog() const
 
 bool wxFileProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 {
 
 bool wxFileProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
 {

+    wxFileName filename = variant.GetString();
+

     if ( (m_flags & wxPG_PROP_SHOW_FULL_FILENAME) || (argFlags & wxPG_FULL_VALUE) )
     {
     if ( (m_flags & wxPG_PROP_SHOW_FULL_FILENAME) || (argFlags & wxPG_FULL_VALUE) )
     {

-        if ( m_filename != text )
+        if ( filename != text )

         {
             variant = text;
             return true;
         {
             variant = text;
             return true;


@@ -1762,9 +1763,9 @@ bool wxFileProperty::StringToValue( wxVariant& variant, const wxString& text, in
     }
     else
     {
     }
     else
     {

-        if ( m_filename.GetFullName() != text )
+        if ( filename.GetFullName() != text )

         {
         {

-            wxFileName fn = m_filename;
+            wxFileName fn = filename;

             fn.SetFullName(text);
             variant = fn.GetFullPath();
             return true;
             fn.SetFullName(text);
             variant = fn.GetFullPath();
             return true;


@@ -1857,9 +1858,10 @@ wxLongStringProperty::wxLongStringProperty( const wxString& label, const wxStrin
 
 wxLongStringProperty::~wxLongStringProperty() {}
 
 
 wxLongStringProperty::~wxLongStringProperty() {}
 

-wxString wxLongStringProperty::GetValueAsString( int ) const
+wxString wxLongStringProperty::ValueToString( wxVariant& value,
+                                              int WXUNUSED(argFlags) ) const

 {
 {

-    return m_value;
+    return value;

 }
 
 bool wxLongStringProperty::OnEvent( wxPropertyGrid* propGrid, wxWindow* WXUNUSED(primary),
 }
 
 bool wxLongStringProperty::OnEvent( wxPropertyGrid* propGrid, wxWindow* WXUNUSED(primary),


@@ -1868,9 +1870,9 @@ bool wxLongStringProperty::OnEvent( wxPropertyGrid* propGrid, wxWindow* WXUNUSED
     if ( propGrid->IsMainButtonEvent(event) )
     {
         // Update the value
     if ( propGrid->IsMainButtonEvent(event) )
     {
         // Update the value

-        PrepareValueForDialogEditing(propGrid);
+        wxVariant useValue = propGrid->GetUncommittedPropertyValue();

 
 

-        wxString val1 = GetValueAsString(0);
+        wxString val1 = useValue.GetString();

         wxString val_orig = val1;
 
         wxString value;
         wxString val_orig = val1;
 
         wxString value;


@@ -1956,7 +1958,7 @@ bool wxLongStringProperty::DisplayEditorDialog( wxPGProperty* prop, wxPropertyGr
 
 bool wxLongStringProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
 {
 
 bool wxLongStringProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
 {

-    if ( m_value != text )
+    if ( variant != text )

     {
         variant = text;
         return true;
     {
         variant = text;
         return true;


@@ -1982,7 +1984,7 @@ END_EVENT_TABLE()
 
 IMPLEMENT_ABSTRACT_CLASS(wxArrayEditorDialog, wxDialog)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxArrayEditorDialog, wxDialog)
 

-#include <wx/statline.h>
+#include "wx/statline.h"

 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 


@@ -2066,6 +2068,7 @@ bool wxArrayEditorDialog::Create( wxWindow *parent,
     // On wxMAC the dialog shows incorrectly if style is not exactly wxCAPTION
     // FIXME: This should be only a temporary fix.
 #ifdef __WXMAC__
     // On wxMAC the dialog shows incorrectly if style is not exactly wxCAPTION
     // FIXME: This should be only a temporary fix.
 #ifdef __WXMAC__

+    wxUnusedVar(style);

     int useStyle = wxCAPTION;
 #else
     int useStyle = style;
     int useStyle = wxCAPTION;
 #else
     int useStyle = style;


@@ -2129,7 +2132,7 @@ bool wxArrayEditorDialog::Create( wxWindow *parent,
 
     // Manipulator buttons
     wxBoxSizer* colsizer = new wxBoxSizer( wxVERTICAL );
 
     // Manipulator buttons
     wxBoxSizer* colsizer = new wxBoxSizer( wxVERTICAL );

-    m_butCustom = (wxButton*) NULL;
+    m_butCustom = NULL;

     if ( m_custBtText )
     {
         m_butCustom = new wxButton(this,28,::wxGetTranslation(m_custBtText));
     if ( m_custBtText )
     {
         m_butCustom = new wxButton(this,28,::wxGetTranslation(m_custBtText));


@@ -2339,7 +2342,7 @@ wxPGArrayStringEditorDialog::wxPGArrayStringEditorDialog()
 
 void wxPGArrayStringEditorDialog::Init()
 {
 
 void wxPGArrayStringEditorDialog::Init()
 {

-    m_pCallingClass = (wxArrayStringProperty*) NULL;
+    m_pCallingClass = NULL;

 }
 
 void wxPGArrayStringEditorDialog::OnCustomEditClick(wxCommandEvent& )
 }
 
 void wxPGArrayStringEditorDialog::OnCustomEditClick(wxCommandEvent& )


@@ -2380,9 +2383,23 @@ void wxArrayStringProperty::OnSetValue()
     GenerateValueAsString();
 }
 
     GenerateValueAsString();
 }
 

-wxString wxArrayStringProperty::GetValueAsString( int WXUNUSED(argFlags) ) const
+#define ARRSTRPROP_ARRAY_TO_STRING(STRING,ARRAY) \
+    wxPropertyGrid::ArrayStringToString(STRING,ARRAY,wxS('"'),wxS('"'),1)
+
+wxString wxArrayStringProperty::ValueToString( wxVariant& WXUNUSED(value),
+                                               int argFlags ) const

 {
 {

-    return m_display;
+    //
+    // If this is called from GetValueAsString(), return cached string
+    if ( argFlags & wxPG_VALUE_IS_CURRENT )
+    {
+        return m_display;
+    }
+
+    wxArrayString arr = m_value.GetArrayString();
+    wxString s;
+    ARRSTRPROP_ARRAY_TO_STRING(s, arr);
+    return s;

 }
 
 // Converts wxArrayString to a string separated by delimeters and spaces.
 }
 
 // Converts wxArrayString to a string separated by delimeters and spaces.


@@ -2397,16 +2414,13 @@ void wxPropertyGrid::ArrayStringToString( wxString& dst, const wxArrayString& sr
     unsigned int i;
     unsigned int itemCount = src.size();
 
     unsigned int i;
     unsigned int itemCount = src.size();
 

-    wxChar preas[2];
+    wxChar preas[2] = { 0, 0 };

 
     dst.Empty();
 
 
     dst.Empty();
 

-    if ( !preDelim )
-        preas[0] = 0;
-    else if ( (flags & 1) )
+    if ( flags & 1 )

     {
         preas[0] = preDelim;
     {
         preas[0] = preDelim;

-        preas[1] = 0;

         pdr = wxS("\\");
         pdr += preDelim;
     }
         pdr = wxS("\\");
         pdr += preDelim;
     }


@@ -2445,13 +2459,10 @@ void wxPropertyGrid::ArrayStringToString( wxString& dst, const wxArrayString& sr
     }
 }
 
     }
 }
 

-#define ARRSTRPROP_ARRAY_TO_STRING(STRING,ARRAY) \
-    wxPropertyGrid::ArrayStringToString(STRING,ARRAY,wxS('"'),wxS('"'),1);
-

 void wxArrayStringProperty::GenerateValueAsString()
 {
     wxArrayString arr = m_value.GetArrayString();
 void wxArrayStringProperty::GenerateValueAsString()
 {
     wxArrayString arr = m_value.GetArrayString();

-    ARRSTRPROP_ARRAY_TO_STRING(m_display, arr)
+    ARRSTRPROP_ARRAY_TO_STRING(m_display, arr);

 }
 
 // Default implementation doesn't do anything.
 }
 
 // Default implementation doesn't do anything.


@@ -2470,7 +2481,7 @@ bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid* propGrid,
                                            const wxChar* cbt )
 {
     // Update the value
                                            const wxChar* cbt )
 {
     // Update the value

-    PrepareValueForDialogEditing(propGrid);
+    wxVariant useValue = propGrid->GetUncommittedPropertyValue();

 
     if ( !propGrid->EditorValidate() )
         return false;
 
     if ( !propGrid->EditorValidate() )
         return false;


@@ -2487,7 +2498,7 @@ bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid* propGrid,
     if ( strEdDlg )
         strEdDlg->SetCustomButton(cbt, this);
 
     if ( strEdDlg )
         strEdDlg->SetCustomButton(cbt, this);
 

-    dlg->SetDialogValue( wxVariant(m_value) );
+    dlg->SetDialogValue( useValue );

     dlg->Create(propGrid, wxEmptyString, m_label);
 
 #if !wxPG_SMALL_SCREEN
     dlg->Create(propGrid, wxEmptyString, m_label);
 
 #if !wxPG_SMALL_SCREEN


@@ -2509,7 +2520,7 @@ bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid* propGrid,
             {
                 wxArrayString actualValue = value.GetArrayString();
                 wxString tempStr;
             {
                 wxArrayString actualValue = value.GetArrayString();
                 wxString tempStr;

-                ARRSTRPROP_ARRAY_TO_STRING(tempStr, actualValue)
+                ARRSTRPROP_ARRAY_TO_STRING(tempStr, actualValue);

             #if wxUSE_VALIDATORS
                 if ( dialogValidator.DoValidate( propGrid, validator, tempStr ) )
             #endif
             #if wxUSE_VALIDATORS
                 if ( dialogValidator.DoValidate( propGrid, validator, tempStr ) )
             #endif


@@ -2602,3 +2613,4 @@ bool wxPGInDialogValidator::DoValidate( wxPropertyGrid* WXUNUSED(propGrid),
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

+#endif  // wxUSE_PROPGRID