fix other insert() overloads to work when inserting at the end of the list, continuat...

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

diff --git a/src/propgrid/propgridpagestate.cpp b/src/propgrid/propgridpagestate.cpp
index 705baa516adafc44a82dffac78f540bfd79b106e..59c3a88a39d4bb15afc8698bde6d7c0aa1455fe6 100644 (file)
--- a/src/propgrid/propgridpagestate.cpp
+++ b/src/propgrid/propgridpagestate.cpp
@@ -201,12 +201,12 @@ void wxPropertyGridIteratorBase::Next( bool iterateChildren )
 
 wxPropertyGridPageState::wxPropertyGridPageState()
 {
 
 wxPropertyGridPageState::wxPropertyGridPageState()
 {

-    m_pPropGrid = (wxPropertyGrid*) NULL;
+    m_pPropGrid = NULL;

     m_regularArray.SetParentState(this);
     m_properties = &m_regularArray;
     m_regularArray.SetParentState(this);
     m_properties = &m_regularArray;

-    m_abcArray = (wxPGRootProperty*) NULL;
-    m_currentCategory = (wxPropertyCategory*) NULL;
-    m_selected = (wxPGProperty*) NULL;
+    m_abcArray = NULL;
+    m_currentCategory = NULL;
+    m_selected = NULL;

     m_width = 0;
     m_virtualHeight = 0;
     m_lastCaptionBottomnest = 1;
     m_width = 0;
     m_virtualHeight = 0;
     m_lastCaptionBottomnest = 1;


@@ -231,7 +231,7 @@ void wxPropertyGridPageState::InitNonCatMode()
 {
     if ( !m_abcArray )
     {
 {
     if ( !m_abcArray )
     {

-        m_abcArray = new wxPGRootProperty();
+        m_abcArray = new wxPGRootProperty(wxS("<Root_NonCat>"));

         m_abcArray->SetParentState(this);
         m_abcArray->SetFlag(wxPG_PROP_CHILDREN_ARE_COPIES);
     }
         m_abcArray->SetParentState(this);
         m_abcArray->SetFlag(wxPG_PROP_CHILDREN_ARE_COPIES);
     }


@@ -245,17 +245,17 @@ void wxPropertyGridPageState::InitNonCatMode()
 
     if ( m_properties->GetChildCount() )
     {
 
     if ( m_properties->GetChildCount() )
     {

-        // Copy items.
-        wxPropertyGridIterator it( this, wxPG_ITERATE_DEFAULT|wxPG_ITERATE_CATEGORIES );
+        //
+        // Prepare m_abcArray
+        wxPropertyGridIterator it( this, wxPG_ITERATE_PROPERTIES );

 
         for ( ; !it.AtEnd(); it.Next() )
         {
             wxPGProperty* p = it.GetProperty();
             wxPGProperty* parent = p->GetParent();
 
         for ( ; !it.AtEnd(); it.Next() )
         {
             wxPGProperty* p = it.GetProperty();
             wxPGProperty* parent = p->GetParent();

-            if ( p->HasFlag(wxPG_PROP_MISC_PARENT) &&
-                ( parent == m_properties || (parent->IsCategory() || parent->IsRoot()) ) )
+            if ( parent->IsCategory() || parent->IsRoot() )

             {
             {

-                m_abcArray->AddChild2( p );
+                m_abcArray->AddChild2(p);

                 p->m_parent = &m_regularArray;
             }
         }
                 p->m_parent = &m_regularArray;
             }
         }


@@ -274,14 +274,14 @@ void wxPropertyGridPageState::DoClear()
 
     m_dictName.clear();
 
 
     m_dictName.clear();
 

-    m_currentCategory = (wxPropertyCategory*) NULL;
+    m_currentCategory = NULL;

     m_lastCaptionBottomnest = 1;
     m_itemsAdded = 0;
 
     m_virtualHeight = 0;
     m_vhCalcPending = 0;
 
     m_lastCaptionBottomnest = 1;
     m_itemsAdded = 0;
 
     m_virtualHeight = 0;
     m_vhCalcPending = 0;
 

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

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


@@ -369,7 +369,7 @@ void wxPropertyGridPageState::OnClientWidthChange( int newWidth, int widthChange
 wxPGProperty* wxPropertyGridPageState::GetLastItem( int flags )
 {
     if ( !m_properties->GetChildCount() )
 wxPGProperty* wxPropertyGridPageState::GetLastItem( int flags )
 {
     if ( !m_properties->GetChildCount() )

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

 
     wxPG_ITERATOR_CREATE_MASKS(flags, int itemExMask, int parentExMask)
 
 
     wxPG_ITERATOR_CREATE_MASKS(flags, int itemExMask, int parentExMask)
 


@@ -403,7 +403,7 @@ wxPropertyCategory* wxPropertyGridPageState::GetPropertyCategory( const wxPGProp
             return (wxPropertyCategory*)parent;
     } while ( grandparent );
 
             return (wxPropertyCategory*)parent;
     } while ( grandparent );
 

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

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


@@ -443,7 +443,7 @@ wxPGProperty* wxPropertyGridPageState::BaseGetPropertyByName( const wxString& na
     it = m_dictName.find(name);
     if ( it != m_dictName.end() )
         return (wxPGProperty*) it->second;
     it = m_dictName.find(name);
     if ( it != m_dictName.end() )
         return (wxPGProperty*) it->second;

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

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


@@ -453,8 +453,15 @@ void wxPropertyGridPageState::DoSetPropertyName( wxPGProperty* p,
 {
     wxCHECK_RET( p, wxT("invalid property id") );
 
 {
     wxCHECK_RET( p, wxT("invalid property id") );
 

-    if ( p->GetBaseName().Len() ) m_dictName.erase( p->GetBaseName() );
-    if ( newName.Len() ) m_dictName[newName] = (void*) p;
+    wxPGProperty* parent = p->GetParent();
+
+    if ( parent->IsCategory() || parent->IsRoot() )
+    {
+        if ( p->GetBaseName().length() )
+            m_dictName.erase( p->GetBaseName() );
+        if ( newName.length() )
+            m_dictName[newName] = (void*) p;
+    }

 
     p->DoSetName(newName);
 }
 
     p->DoSetName(newName);
 }


@@ -483,7 +490,7 @@ void wxPropertyGridPageState::DoSetPropertyName( wxPGProperty* p,
 #define ITEM_ITERATION_INIT(startparent, startindex, state) \
     parent = startparent; \
     i = (unsigned int)startindex; \
 #define ITEM_ITERATION_INIT(startparent, startindex, state) \
     parent = startparent; \
     i = (unsigned int)startindex; \

-    if ( parent == (wxPGProperty*) NULL ) \
+    if ( parent == NULL ) \

     { \
         parent = state->m_properties; \
         i = 0; \
     { \
         parent = state->m_properties; \
         i = 0; \


@@ -595,64 +602,106 @@ bool wxPropertyGridPageState::EnableCategories( bool enable )
 #if wxUSE_STL
 #include <algorithm>
 
 #if wxUSE_STL
 #include <algorithm>
 

-static bool wxPG_SortFunc(wxPGProperty *p1, wxPGProperty *p2)
+static bool wxPG_SortFunc_ByFunction(wxPGProperty *p1, wxPGProperty *p2)

 {
 {

-    return p1->GetLabel() < p2->GetLabel();
+    wxPropertyGrid* pg = p1->GetGrid();
+    wxPGSortCallback sortFunction = pg->GetSortFunction();
+    return sortFunction(pg, p1, p2) < 0;
+}
+
+static bool wxPG_SortFunc_ByLabel(wxPGProperty *p1, wxPGProperty *p2)
+{
+    return p1->GetLabel().CmpNoCase( p2->GetLabel() ) < 0;

 }
 
 #else
 
 }
 
 #else
 

-static int wxPG_SortFunc(wxPGProperty **p1, wxPGProperty **p2)
+static int wxPG_SortFunc_ByFunction(wxPGProperty **pp1, wxPGProperty **pp2)

 {
 {

-    wxPGProperty *pp1 = *p1;
-    wxPGProperty *pp2 = *p2;
-    return pp1->GetLabel().compare( pp2->GetLabel() );
+    wxPGProperty *p1 = *pp1;
+    wxPGProperty *p2 = *pp2;
+    wxPropertyGrid* pg = p1->GetGrid();
+    wxPGSortCallback sortFunction = pg->GetSortFunction();
+    return sortFunction(pg, p1, p2);
+}
+
+static int wxPG_SortFunc_ByLabel(wxPGProperty **pp1, wxPGProperty **pp2)
+{
+    wxPGProperty *p1 = *pp1;
+    wxPGProperty *p2 = *pp2;
+    return p1->GetLabel().CmpNoCase( p2->GetLabel() );

 }
 
 #endif
 
 }
 
 #endif
 

-void wxPropertyGridPageState::SortChildren( wxPGProperty* p )
+void wxPropertyGridPageState::DoSortChildren( wxPGProperty* p,
+                                              int flags )

 {
     if ( !p )
 {
     if ( !p )

-        p = (wxPGProperty*)m_properties;
+        p = m_properties;

 
 

+    // Can only sort items with children

     if ( !p->GetChildCount() )
         return;
 
     if ( !p->GetChildCount() )
         return;
 

-    wxPGProperty* pwc = (wxPGProperty*)p;
+    // Never sort children of aggregate properties
+    if ( p->HasFlag(wxPG_PROP_AGGREGATE) )
+        return;

 
 

-    // Can only sort items with children
-    if ( pwc->GetChildCount() < 1 )
+    if ( (flags & wxPG_SORT_TOP_LEVEL_ONLY)
+         && !p->IsCategory() && !p->IsRoot() )

         return;
 
 #if wxUSE_STL
         return;
 
 #if wxUSE_STL

-    std::sort(pwc->m_children.begin(), pwc->m_children.end(), wxPG_SortFunc);
+    if ( GetGrid()->GetSortFunction() )
+        std::sort(p->m_children.begin(), p->m_children.end(),
+                  wxPG_SortFunc_ByFunction);
+    else
+        std::sort(p->m_children.begin(), p->m_children.end(),
+                  wxPG_SortFunc_ByLabel);

 #else
 #else

-    pwc->m_children.Sort( wxPG_SortFunc );
+    if ( GetGrid()->GetSortFunction() )
+        p->m_children.Sort( wxPG_SortFunc_ByFunction );
+    else
+        p->m_children.Sort( wxPG_SortFunc_ByLabel );

 #endif
 
 #endif
 

-    // Fix indexes
-    pwc->FixIndicesOfChildren();
+    // Fix indices
+    p->FixIndicesOfChildren();

 
 

+    if ( flags & wxPG_RECURSE )
+    {
+        // Apply sort recursively
+        for ( unsigned int i=0; i<p->GetChildCount(); i++ )
+            DoSortChildren(p->Item(i), flags);
+    }

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

-void wxPropertyGridPageState::Sort()
+void wxPropertyGridPageState::DoSort( int flags )

 {
 {

-    SortChildren( m_properties );
+    DoSortChildren( m_properties, flags | wxPG_RECURSE );

 
 

-    // Sort categories as well
-    if ( !IsInNonCatMode() )
-    {
-        size_t i;
-        for ( i=0;i<m_properties->GetChildCount();i++)
-        {
-            wxPGProperty* p = m_properties->Item(i);
-            if ( p->IsCategory() )
-                SortChildren( p );
-        }
-    }
+    // We used to sort categories as well here also if in non-categorized
+    // mode, but doing would naturally cause child indices to become
+    // corrupted.
+}
+
+// -----------------------------------------------------------------------
+
+bool wxPropertyGridPageState::PrepareAfterItemsAdded()
+{
+    if ( !m_itemsAdded ) return false;
+
+    wxPropertyGrid* pg = GetGrid();
+
+    m_itemsAdded = 0;
+
+    if ( pg->HasFlag(wxPG_AUTO_SORT) )
+        DoSort(wxPG_SORT_TOP_LEVEL_ONLY);
+
+    return true;

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


@@ -663,7 +712,7 @@ wxPGProperty* wxPropertyGridPageState::DoGetItemAtY( int y ) const
 {
     // Outside?
     if ( y < 0 )
 {
     // Outside?
     if ( y < 0 )

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

 
     unsigned int a = 0;
     return m_properties->GetItemAtY(y, GetGrid()->m_lineHeight, &a);
 
     unsigned int a = 0;
     return m_properties->GetItemAtY(y, GetGrid()->m_lineHeight, &a);


@@ -1114,7 +1163,7 @@ bool wxPropertyGridPageState::DoSetPropertyValueString( wxPGProperty* p, const w
         {
             p->SetValue(variant);
             if ( m_selected==p && this==m_pPropGrid->GetState() )
         {
             p->SetValue(variant);
             if ( m_selected==p && this==m_pPropGrid->GetState() )

-                p->UpdateControl(m_pPropGrid->GetEditorControl());
+                m_pPropGrid->RefreshEditor();

         }
 
         return true;
         }
 
         return true;


@@ -1130,7 +1179,7 @@ bool wxPropertyGridPageState::DoSetPropertyValue( wxPGProperty* p, wxVariant& va
     {
         p->SetValue(value);
         if ( m_selected==p && this==m_pPropGrid->GetState() )
     {
         p->SetValue(value);
         if ( m_selected==p && this==m_pPropGrid->GetState() )

-            p->UpdateControl(m_pPropGrid->GetEditorControl());
+            m_pPropGrid->RefreshEditor();

 
         return true;
     }
 
         return true;
     }


@@ -1151,33 +1200,6 @@ bool wxPropertyGridPageState::DoSetPropertyValueWxObjectPtr( wxPGProperty* p, wx
     return false;
 }
 
     return false;
 }
 

-// -----------------------------------------------------------------------
-
-void wxPropertyGridPageState::DoSetPropertyValueUnspecified( wxPGProperty* p )
-{
-    wxCHECK_RET( p, wxT("invalid property id") );
-
-    if ( !p->IsValueUnspecified() )
-    {
-        // Value should be set first - editor class methods may need it
-        p->m_value.MakeNull();
-
-        wxASSERT( m_pPropGrid );
-
-        if ( m_pPropGrid->GetState() == this )
-        {
-            if ( m_pPropGrid->m_selected == p && m_pPropGrid->m_wndEditor )
-            {
-                p->GetEditorClass()->SetValueToUnspecified(p, m_pPropGrid->GetEditorControl());
-            }
-        }
-
-        unsigned int i;
-        for ( i = 0; i < p->GetChildCount(); i++ )
-            DoSetPropertyValueUnspecified( p->Item(i) );
-    }
-}
-

 // -----------------------------------------------------------------------
 // wxPropertyGridPageState property operations
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPropertyGridPageState property operations
 // -----------------------------------------------------------------------


@@ -1401,7 +1423,7 @@ void wxPropertyGridPageState::DoSetPropertyValues( const wxVariantList& list, wx
                     if ( wxStrcmp(current->GetType(), wxS("list")) == 0 )
                     {
                         DoSetPropertyValues( current->GetList(),
                     if ( wxStrcmp(current->GetType(), wxS("list")) == 0 )
                     {
                         DoSetPropertyValues( current->GetList(),

-                                p->IsCategory()?p:((wxPGProperty*)NULL)
+                                p->IsCategory()?p:(NULL)

                             );
                     }
                     else
                             );
                     }
                     else


@@ -1497,9 +1519,7 @@ void wxPropertyGridPageState::DoSetPropertyValues( const wxVariantList& list, wx
         m_pPropGrid->Thaw();
 
         if ( this == m_pPropGrid->GetState() )
         m_pPropGrid->Thaw();
 
         if ( this == m_pPropGrid->GetState() )

-        {
-            m_selected->UpdateControl(m_pPropGrid->GetEditorControl());
-        }
+            m_pPropGrid->RefreshEditor();

     }
 
 }
     }
 
 }


@@ -1515,7 +1535,7 @@ bool wxPropertyGridPageState::PrepareToAddItem( wxPGProperty* property,
 
     // This will allow better behavior.
     if ( scheduledParent == m_properties )
 
     // This will allow better behavior.
     if ( scheduledParent == m_properties )

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

 
     if ( scheduledParent && !scheduledParent->IsCategory() )
     {
 
     if ( scheduledParent && !scheduledParent->IsCategory() )
     {


@@ -1593,7 +1613,7 @@ wxPGProperty* wxPropertyGridPageState::DoAppend( wxPGProperty* property )
 {
     wxPropertyCategory* cur_cat = m_currentCategory;
     if ( property->IsCategory() )
 {
     wxPropertyCategory* cur_cat = m_currentCategory;
     if ( property->IsCategory() )

-        cur_cat = (wxPropertyCategory*) NULL;
+        cur_cat = NULL;

 
     return DoInsert( cur_cat, -1, property );
 }
 
     return DoInsert( cur_cat, -1, property );
 }


@@ -1616,6 +1636,9 @@ wxPGProperty* wxPropertyGridPageState::DoInsert( wxPGProperty* parent, int index
     if ( !res )
         return m_currentCategory;
 
     if ( !res )
         return m_currentCategory;
 

+    bool parentIsRoot = parent->IsRoot();
+    bool parentIsCategory = parent->IsCategory();
+

     // Note that item must be added into current mode later.
 
     // If parent is wxParentProperty, just stick it in...
     // Note that item must be added into current mode later.
 
     // If parent is wxParentProperty, just stick it in...


@@ -1628,42 +1651,34 @@ wxPGProperty* wxPropertyGridPageState::DoInsert( wxPGProperty* parent, int index
     //   1) Add to given category in given index.
     //   2) Add as last item in m_abcArray.
 
     //   1) Add to given category in given index.
     //   2) Add as last item in m_abcArray.
 

-    if ( !parent->IsCategory() && !parent->IsRoot() )
-    {
-        // Parent is wxParentingProperty: Just stick it in...
-        parent->AddChild2( property, index );
-    }
-    else
+    if ( m_properties == &m_regularArray )

     {
     {

-        // Parent is Category or Root.
+        // We are currently in Categorized mode

 
 

-        if ( m_properties == &m_regularArray )
+        // Only add non-categories to m_abcArray.
+        if ( m_abcArray && !property->IsCategory() &&
+             (parentIsCategory || parentIsRoot) )

         {
         {

-            // Categorized mode
-
-            // Only add non-categories to m_abcArray.
-            if ( m_abcArray && !property->IsCategory() )
-                m_abcArray->AddChild2( property, -1, false );
-
-            // Add to current mode.
-            parent->AddChild2( property, index );
-
+            m_abcArray->AddChild2( property, -1, false );

         }
         }

-        else
-        {
-            // Non-categorized mode.

 
 

-            if ( parent != m_properties )
-                // Parent is category.
-                parent->AddChild2( property, index, false );
-            else
-                // Parent is root.
-                m_regularArray.AddChild2( property, -1, false );
-
-            // Add to current mode (no categories).
-            if ( !property->IsCategory() )
-                m_abcArray->AddChild2( property, index );
-        }
+        // Add to current mode.
+        parent->AddChild2( property, index, true );
+    }
+    else
+    {
+        // We are currently in Non-categorized/Alphabetic mode
+
+        if ( parentIsCategory )
+            // Parent is category.
+            parent->AddChild2( property, index, false );
+        else if ( parentIsRoot )
+            // Parent is root.
+            m_regularArray.AddChild2( property, -1, false );
+
+        // Add to current mode
+        if ( !property->IsCategory() )
+            m_abcArray->AddChild2( property, index, true );

     }
 
     // category stuff
     }
 
     // category stuff


@@ -1676,7 +1691,8 @@ wxPGProperty* wxPropertyGridPageState::DoInsert( wxPGProperty* parent, int index
     }
 
     // Only add name to hashmap if parent is root or category
     }
 
     // Only add name to hashmap if parent is root or category

-    if ( (parent->IsCategory() || parent->IsRoot()) && property->m_name.length() )
+    if ( property->m_name.length() &&
+        (parentIsCategory || parentIsRoot) )

         m_dictName[property->m_name] = (void*) property;
 
     VirtualHeightChanged();
         m_dictName[property->m_name] = (void*) property;
 
     VirtualHeightChanged();


@@ -1698,57 +1714,41 @@ void wxPropertyGridPageState::DoDelete( wxPGProperty* item, bool doDelete )
     wxCHECK_RET( item != &m_regularArray && item != m_abcArray,
         wxT("wxPropertyGrid: Do not attempt to remove the root item.") );
 
     wxCHECK_RET( item != &m_regularArray && item != m_abcArray,
         wxT("wxPropertyGrid: Do not attempt to remove the root item.") );
 

-    size_t i;

     unsigned int indinparent = item->GetIndexInParent();
 
     wxPGProperty* pwc = (wxPGProperty*)item;
     unsigned int indinparent = item->GetIndexInParent();
 
     wxPGProperty* pwc = (wxPGProperty*)item;

+    wxPGProperty* parent = item->GetParent();

 
 

-    wxCHECK_RET( !item->GetParent()->HasFlag(wxPG_PROP_AGGREGATE),
+    wxCHECK_RET( !parent->HasFlag(wxPG_PROP_AGGREGATE),

         wxT("wxPropertyGrid: Do not attempt to remove sub-properties.") );
 
         wxT("wxPropertyGrid: Do not attempt to remove sub-properties.") );
 

-    if ( item->IsCategory() )
+    // Delete children
+    if ( item->GetChildCount() && !item->HasFlag(wxPG_PROP_AGGREGATE) )

     {
         // deleting a category
     {
         // deleting a category

-
-        // erase category entries from the hash table
-        for ( i=0; i<pwc->GetChildCount(); i++ )
+        if ( item->IsCategory() )

         {
         {

-            wxPGProperty* sp = pwc->Item( i );
-            if ( sp->GetBaseName().Len() ) m_dictName.erase(sp->GetBaseName());
+            if ( pwc == m_currentCategory )
+                m_currentCategory = NULL;

         }
 
         }
 

-        if ( pwc == m_currentCategory )
-            m_currentCategory = (wxPropertyCategory*) NULL;
-
-        if ( m_abcArray )
-        {
-            // Remove children from non-categorized array.
-            for ( i=0; i<pwc->GetChildCount(); i++ )
-            {
-                wxPGProperty * p = pwc->Item( i );
-                wxASSERT( p != NULL );
-                if ( !p->IsCategory() )
-                    m_abcArray->RemoveChild(p);
-            }
-
-            if ( IsInNonCatMode() )
-                m_abcArray->FixIndicesOfChildren();
-        }
+        item->DeleteChildren();

     }
 
     if ( !IsInNonCatMode() )
     {
         // categorized mode - non-categorized array
 
     }
 
     if ( !IsInNonCatMode() )
     {
         // categorized mode - non-categorized array
 

-        // Remove from non-cat array, but only if parent is in it
-        if ( !item->IsCategory() && item->GetParent()->IsCategory() )
+        // Remove from non-cat array
+        if ( !item->IsCategory() &&
+             (parent->IsCategory() || parent->IsRoot()) )

         {
             if ( m_abcArray )
                 m_abcArray->RemoveChild(item);
         }
 
         // categorized mode - categorized array
         {
             if ( m_abcArray )
                 m_abcArray->RemoveChild(item);
         }
 
         // categorized mode - categorized array

-        wxArrayPGProperty& parentsChildren = item->m_parent->m_children;
+        wxArrayPGProperty& parentsChildren = parent->m_children;

         parentsChildren.erase( parentsChildren.begin() + indinparent );
         item->m_parent->FixIndicesOfChildren();
     }
         parentsChildren.erase( parentsChildren.begin() + indinparent );
         item->m_parent->FixIndicesOfChildren();
     }


@@ -1787,7 +1787,9 @@ void wxPropertyGridPageState::DoDelete( wxPGProperty* item, bool doDelete )
         }
     }
 
         }
     }
 

-    if ( item->GetBaseName().Len() ) m_dictName.erase(item->GetBaseName());
+    if ( item->GetBaseName().length() && 
+         (parent->IsCategory() || parent->IsRoot()) )
+        m_dictName.erase(item->GetBaseName());

 
     // We can actually delete it now
     if ( doDelete )
 
     // We can actually delete it now
     if ( doDelete )