void wxPropertyGridIteratorBase::Init( wxPropertyGridPageState* state, int flags, int startPos, int dir )
{
- wxPGProperty* property;
+ wxPGProperty* property = NULL;
if ( startPos == wxTOP )
{
- property = NULL;
if ( dir == 0 )
dir = 1;
}
}
else
{
- wxASSERT_MSG( false, wxT("Only supported stating positions are wxTOP and wxBOTTOM") );
- property = NULL;
+ wxFAIL_MSG("Only supported starting positions are wxTOP and wxBOTTOM");
}
Init( state, flags, property, dir );
wxPropertyGridPageState::wxPropertyGridPageState()
{
- m_pPropGrid = (wxPropertyGrid*) NULL;
+ m_pPropGrid = NULL;
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;
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();
- 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;
}
}
m_dictName.clear();
- m_currentCategory = (wxPropertyCategory*) NULL;
+ m_currentCategory = NULL;
m_lastCaptionBottomnest = 1;
m_itemsAdded = 0;
m_virtualHeight = 0;
m_vhCalcPending = 0;
- m_selected = (wxPGProperty*) NULL;
+ m_selected = NULL;
}
// -----------------------------------------------------------------------
wxPGProperty* wxPropertyGridPageState::GetLastItem( int flags )
{
if ( !m_properties->GetChildCount() )
- return (wxPGProperty*) NULL;
+ return NULL;
wxPG_ITERATOR_CREATE_MASKS(flags, int itemExMask, int parentExMask)
return (wxPropertyCategory*)parent;
} while ( grandparent );
- return (wxPropertyCategory*) NULL;
+ return NULL;
}
// -----------------------------------------------------------------------
it = m_dictName.find(name);
if ( it != m_dictName.end() )
return (wxPGProperty*) it->second;
- return (wxPGProperty*) NULL;
+ return NULL;
}
// -----------------------------------------------------------------------
{
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);
}
// NB: Nowadays only needed for alphabetic/categoric mode switching.
// -----------------------------------------------------------------------
-#define II_INVALID_I 0x00FFFFFF
+//#define II_INVALID_I 0x00FFFFFF
#define ITEM_ITERATION_VARIABLES \
wxPGProperty* parent; \
parent = m_properties; \
i = 0;
+#if 0
#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; \
}
+#endif
#define ITEM_ITERATION_LOOP_BEGIN \
do \
#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
-static int wxPG_SortFunc(wxPGProperty **p1, wxPGProperty **p2)
+static int wxPG_SortFunc_ByFunction(wxPGProperty **pp1, wxPGProperty **pp2)
+{
+ 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 *pp1 = *p1;
- wxPGProperty *pp2 = *p2;
- return pp1->GetLabel().compare( pp2->GetLabel() );
+ wxPGProperty *p1 = *pp1;
+ wxPGProperty *p2 = *pp2;
+ return p1->GetLabel().CmpNoCase( p2->GetLabel() );
}
#endif
-void wxPropertyGridPageState::SortChildren( wxPGProperty* p )
+void wxPropertyGridPageState::DoSortChildren( wxPGProperty* p,
+ int flags )
{
if ( !p )
- p = (wxPGProperty*)m_properties;
+ p = m_properties;
+ // Can only sort items with children
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
- 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
- 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
- // 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() )
+ // Sort categories as well (but we need not do it recursively)
+ if ( IsInNonCatMode() )
{
size_t i;
- for ( i=0;i<m_properties->GetChildCount();i++)
+ for ( i=0;i<m_regularArray.GetChildCount();i++)
{
- wxPGProperty* p = m_properties->Item(i);
+ wxPGProperty* p = m_regularArray.Item(i);
if ( p->IsCategory() )
- SortChildren( p );
+ DoSortChildren( p, 0 );
}
}
}
+// -----------------------------------------------------------------------
+
+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;
+}
+
// -----------------------------------------------------------------------
// wxPropertyGridPageState splitter, column and hittest functions
// -----------------------------------------------------------------------
{
// Outside?
if ( y < 0 )
- return (wxPGProperty*) NULL;
+ return NULL;
unsigned int a = 0;
return m_properties->GetItemAtY(y, GetGrid()->m_lineHeight, &a);
int reduceCol = -1;
int highestColWidth = 0;
- bool minimizedCols = false;
-
#ifdef __WXDEBUG__
if ( debug )
wxLogDebug(wxT("ColumnWidthCheck (virtualWidth: %i, clientWidth: %i)"), width, clientWidth);
if ( m_colWidths[i] <= min )
{
m_colWidths[i] = min;
- minimizedCols = true;
}
else
{
if ( colsWidth < width )
{
// Increase column
- #ifdef __WXDEBUG__
- if ( debug )
- wxLogDebug(wxT(" Adjust last column to %i"), m_colWidths[lastColumn] + widthHigher);
- #endif
+#ifdef __WXDEBUG__
+ if ( debug )
+ wxLogDebug(wxT(" Adjust last column to %i"), m_colWidths[lastColumn] + widthHigher);
+#endif
m_colWidths[lastColumn] = m_colWidths[lastColumn] + widthHigher;
}
else if ( colsWidth > width )
{
p->SetValue(variant);
if ( m_selected==p && this==m_pPropGrid->GetState() )
- p->UpdateControl(m_pPropGrid->GetEditorControl());
+ m_pPropGrid->RefreshEditor();
}
return true;
{
p->SetValue(value);
if ( m_selected==p && this==m_pPropGrid->GetState() )
- p->UpdateControl(m_pPropGrid->GetEditorControl());
+ m_pPropGrid->RefreshEditor();
return true;
}
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
// -----------------------------------------------------------------------
//
// Second pass for special entries
- for ( node = list.begin(); node != list.end(); node++ )
+ for ( node = list.begin(); node != list.end(); ++node )
{
wxVariant *current = (wxVariant*)*node;
if ( wxStrcmp(current->GetType(), wxS("list")) == 0 )
{
DoSetPropertyValues( current->GetList(),
- p->IsCategory()?p:((wxPGProperty*)NULL)
+ p->IsCategory()?p:(NULL)
);
}
else
if ( numSpecialEntries )
{
- for ( node = list.begin(); node != list.end(); node++ )
+ for ( node = list.begin(); node != list.end(); ++node )
{
wxVariant *current = (wxVariant*)*node;
wxVariantList& list2 = current->GetList();
wxVariantList::const_iterator node2;
- for ( node2 = list2.begin(); node2 != list2.end(); node2++ )
+ for ( node2 = list2.begin(); node2 != list2.end(); ++node2 )
{
wxVariant *attr = (wxVariant*)*node2;
foundProp->SetAttribute( attr->GetName(), *attr );
m_pPropGrid->Thaw();
if ( this == m_pPropGrid->GetState() )
- {
- m_selected->UpdateControl(m_pPropGrid->GetEditorControl());
- }
+ m_pPropGrid->RefreshEditor();
}
}
// This will allow better behavior.
if ( scheduledParent == m_properties )
- scheduledParent = (wxPGProperty*) NULL;
+ scheduledParent = NULL;
if ( scheduledParent && !scheduledParent->IsCategory() )
{
{
wxPropertyCategory* cur_cat = m_currentCategory;
if ( property->IsCategory() )
- cur_cat = (wxPropertyCategory*) NULL;
+ cur_cat = NULL;
return DoInsert( cur_cat, -1, property );
}
}
// 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() &&
+ (parent->IsCategory() || parent->IsRoot()) )
m_dictName[property->m_name] = (void*) property;
VirtualHeightChanged();
// -----------------------------------------------------------------------
-void wxPropertyGridPageState::DoDelete( wxPGProperty* item )
+void wxPropertyGridPageState::DoDelete( wxPGProperty* item, bool doDelete )
{
wxCHECK_RET( item->GetParent(),
wxT("this property was already deleted") );
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;
+ 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.") );
- if ( item->IsCategory() )
+ // Delete children
+ if ( item->GetChildCount() && !item->HasFlag(wxPG_PROP_AGGREGATE) )
{
// 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
- // 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
- wxArrayPGProperty& parentsChildren = item->m_parent->m_children;
+ wxArrayPGProperty& parentsChildren = parent->m_children;
parentsChildren.erase( parentsChildren.begin() + indinparent );
item->m_parent->FixIndicesOfChildren();
}
}
}
- 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
- delete item;
+ if ( doDelete )
+ delete item;
m_itemsAdded = 1; // Not a logical assignment (but required nonetheless).
projects / wxWidgets.git / blobdiff