fix wxGTK1 compilation after wxTextEntry DoGetValue() change

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

diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp
index ec75b88fcd8d3a9939e92c9fae05827662818364..bfb0e446e9d8104d360e79f1ed3f90984a17ada4 100644 (file)
--- a/src/propgrid/property.cpp
+++ b/src/propgrid/property.cpp
@@ -402,16 +402,16 @@ void wxPGProperty::Init()
     m_arrIndex = 0xFFFF;
     m_parent = NULL;
 
     m_arrIndex = 0xFFFF;
     m_parent = NULL;
 

-    m_parentState = (wxPropertyGridPageState*) NULL;
+    m_parentState = NULL;

 
     m_clientData = NULL;
     m_clientObject = NULL;
 
 
     m_clientData = NULL;
     m_clientObject = NULL;
 

-    m_customEditor = (wxPGEditor*) NULL;
+    m_customEditor = NULL;

 #if wxUSE_VALIDATORS
 #if wxUSE_VALIDATORS

-    m_validator = (wxValidator*) NULL;
+    m_validator = NULL;

 #endif
 #endif

-    m_valueBitmap = (wxBitmap*) NULL;
+    m_valueBitmap = NULL;

 
     m_maxLen = 0; // infinite maximum length
 
 
     m_maxLen = 0; // infinite maximum length
 


@@ -652,6 +652,10 @@ void wxPGProperty::RefreshChildren ()
 {
 }
 
 {
 }
 

+void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
+{
+}
+

 void wxPGProperty::GetDisplayInfo( unsigned int column,
                                    int choiceIndex,
                                    int flags,
 void wxPGProperty::GetDisplayInfo( unsigned int column,
                                    int choiceIndex,
                                    int flags,


@@ -972,6 +976,11 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
     for ( ;; )
     {
 
     for ( ;; )
     {

+        // How many units we iterate string forward at the end of loop?
+        // We need to keep track of this or risk going to negative
+        // with it-- operation.
+        unsigned int strPosIncrement = 1;
+

         if ( tokenStart != 0xFFFFFF )
         {
             // Token is running
         if ( tokenStart != 0xFFFFFF )
         {
             // Token is running


@@ -1077,23 +1086,23 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
                          !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
                     {
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
                          !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
                     {

-                        bool stvRes = child->StringToValue( variant, token, propagatedFlags );
+                        wxString childName = child->GetBaseName();
+
+                        bool stvRes = child->StringToValue( variant, token,
+                                                            propagatedFlags );

                         if ( stvRes || (variant != oldChildValue) )
                         {
                         if ( stvRes || (variant != oldChildValue) )
                         {

-                            if ( stvRes )
-                                changed = true;
+                            variant.SetName(childName);
+                            list.Append(variant);
+
+                            changed = true;

                         }
                         else
                         {
                         }
                         else
                         {

-                            // Failed, becomes unspecified
-                            variant.MakeNull();
-                            changed = true;
+                            // No changes...

                         }
                     }
 
                         }
                     }
 

-                    variant.SetName(child->GetBaseName());
-                    list.Append(variant);
-

                     curChild++;
                     if ( curChild >= iMax )
                         break;
                     curChild++;
                     if ( curChild >= iMax )
                         break;


@@ -1107,10 +1116,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     tokenStart = pos;
 
                     if ( a == delimeter )
                     tokenStart = pos;
 
                     if ( a == delimeter )

-                    {
-                        pos--;
-                        --it;
-                    }
+                        strPosIncrement -= 1;

                 }
             }
         }
                 }
             }
         }


@@ -1118,7 +1124,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
         if ( a == 0 )
             break;
 
         if ( a == 0 )
             break;
 

-        ++it;
+        it += strPosIncrement;
+

         if ( it != text.end() )
         {
             a = *it;
         if ( it != text.end() )
         {
             a = *it;


@@ -1127,7 +1134,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
         {
             a = 0;
         }
         {
             a = 0;
         }

-        pos++;
+
+        pos += strPosIncrement;

     }
 
     if ( changed )
     }
 
     if ( changed )


@@ -1281,9 +1289,6 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         {
             m_value = value;
             OnSetValue();
         {
             m_value = value;
             OnSetValue();

-
-            if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
-                UpdateParentValues();

         }
 
         if ( flags & wxPG_SETVAL_BY_USER )
         }
 
         if ( flags & wxPG_SETVAL_BY_USER )


@@ -1313,6 +1318,9 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         }
     }
 
         }
     }
 

+    if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
+        UpdateParentValues();
+

     //
     // Update editor control
     //
     //
     // Update editor control
     //


@@ -1707,7 +1715,7 @@ void wxPGProperty::SetFlagsFromString( const wxString& str )
 
 wxValidator* wxPGProperty::DoGetValidator() const
 {
 
 wxValidator* wxPGProperty::DoGetValidator() const
 {

-    return (wxValidator*) NULL;
+    return NULL;

 }
 
 int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
 }
 
 int wxPGProperty::InsertChoice( const wxString& label, int index, int value )


@@ -2127,7 +2135,7 @@ wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const
     // Does it have point, then?
     int pos = name.Find(wxS('.'));
     if ( pos <= 0 )
     // Does it have point, then?
     int pos = name.Find(wxS('.'));
     if ( pos <= 0 )

-        return (wxPGProperty*) NULL;
+        return NULL;

 
     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
 
 
     wxPGProperty* p = GetPropertyByName(name. substr(0,pos));
 


@@ -2396,7 +2404,7 @@ void wxPGProperty::SubPropsChanged( int oldSelInd )
         child->InitAfterAdded(state, grid);
     }
 
         child->InitAfterAdded(state, grid);
     }
 

-    wxPGProperty* sel = (wxPGProperty*) NULL;
+    wxPGProperty* sel = NULL;

     if ( oldSelInd >= (int)m_children.size() )
         oldSelInd = (int)m_children.size() - 1;
 
     if ( oldSelInd >= (int)m_children.size() )
         oldSelInd = (int)m_children.size() - 1;
 


@@ -2422,11 +2430,14 @@ WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
 
 

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

     : wxPGProperty()
 {
 #ifdef __WXDEBUG__
     : wxPGProperty()
 {
 #ifdef __WXDEBUG__

-    m_name = wxS("<root>");
+    m_name = name;
+    m_label = m_name;
+#else
+    wxUnusedVar(name);

 #endif
     SetParentalType(0);
     m_depth = 0;
 #endif
     SetParentalType(0);
     m_depth = 0;


@@ -2494,6 +2505,270 @@ void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font
     m_textExtent = x;
 }
 
     m_textExtent = x;
 }
 

+// -----------------------------------------------------------------------
+// wxPGChoices
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( -1, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    entry.SetBitmap(bitmap);
+    return m_data->Insert( -1, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
+{
+    AllocExclusive();
+
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
+{
+    AllocExclusive();
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
+{
+    AllocExclusive();
+
+    size_t index = 0;
+
+    while ( index < GetCount() )
+    {
+        int cmpRes = GetLabel(index).Cmp(label);
+        if ( cmpRes > 0 )
+            break;
+        index++;
+    }
+
+    wxPGChoiceEntry entry(label, value);
+    return m_data->Insert( index, entry );
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
+{
+    AllocExclusive();
+
+    unsigned int itemcount = 0;
+    const wxChar** p = &labels[0];
+    while ( *p ) { p++; itemcount++; }
+
+    unsigned int i;
+    for ( i = 0; i < itemcount; i++ )
+    {
+        int value = i;
+        if ( values )
+            value = values[i];
+        wxPGChoiceEntry entry(labels[i], value);
+        m_data->Insert( i, entry );
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
+{
+    AllocExclusive();
+
+    unsigned int i;
+    unsigned int itemcount = arr.size();
+
+    for ( i = 0; i < itemcount; i++ )
+    {
+        int value = i;
+        if ( &arrint && arrint.size() )
+            value = arrint[i];
+        wxPGChoiceEntry entry(arr[i], value);
+        m_data->Insert( i, entry );
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
+{
+    AllocExclusive();
+
+    wxASSERT( m_data->m_refCount != 0xFFFFFFF );
+    m_data->m_items.erase(m_data->m_items.begin()+nIndex,
+                          m_data->m_items.begin()+nIndex+count);
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Clear()
+{
+    if ( m_data != wxPGChoicesEmptyData )
+    {
+        AllocExclusive();
+        m_data->Clear();
+    }
+}
+
+// -----------------------------------------------------------------------
+
+int wxPGChoices::Index( const wxString& str ) const
+{
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< m_data->GetCount(); i++ )
+        {
+            const wxPGChoiceEntry& entry = m_data->Item(i);
+            if ( entry.HasText() && entry.GetText() == str )
+                return i;
+        }
+    }
+    return -1;
+}
+
+// -----------------------------------------------------------------------
+
+int wxPGChoices::Index( int val ) const
+{
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< m_data->GetCount(); i++ )
+        {
+            const wxPGChoiceEntry& entry = m_data->Item(i);
+            if ( entry.GetValue() == val )
+                return i;
+        }
+    }
+    return -1;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayString wxPGChoices::GetLabels() const
+{
+    wxArrayString arr;
+    unsigned int i;
+
+    if ( this && IsOk() )
+        for ( i=0; i<GetCount(); i++ )
+            arr.push_back(GetLabel(i));
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
+{
+    wxArrayInt arr;
+
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< strings.size(); i++ )
+        {
+            int index = Index(strings[i]);
+            if ( index >= 0 )
+                arr.Add(GetValue(index));
+            else
+                arr.Add(wxPG_INVALID_VALUE);
+        }
+    }
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings,
+                                              wxArrayString* unmatched ) const
+{
+    wxArrayInt arr;
+
+    if ( IsOk() )
+    {
+        unsigned int i;
+        for ( i=0; i< strings.size(); i++ )
+        {
+            const wxString& str = strings[i];
+            int index = Index(str);
+            if ( index >= 0 )
+                arr.Add(index);
+            else if ( unmatched )
+                unmatched->Add(str);
+        }
+    }
+
+    return arr;
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::AllocExclusive()
+{
+    EnsureData();
+
+    if ( m_data->m_refCount != 1 )
+    {
+        wxPGChoicesData* data = new wxPGChoicesData();
+        data->CopyDataFrom(m_data);
+        Free();
+        m_data = data;
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::AssignData( wxPGChoicesData* data )
+{
+    Free();
+
+    if ( data != wxPGChoicesEmptyData )
+    {
+        m_data = data;
+        data->m_refCount++;
+    }
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Init()
+{
+    m_data = wxPGChoicesEmptyData;
+}
+
+// -----------------------------------------------------------------------
+
+void wxPGChoices::Free()
+{
+    if ( m_data != wxPGChoicesEmptyData )
+    {
+        m_data->DecRef();
+        m_data = wxPGChoicesEmptyData;
+    }
+}
+

 // -----------------------------------------------------------------------
 // wxPGAttributeStorage
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPGAttributeStorage
 // -----------------------------------------------------------------------