void SetFilter(wxString const& new_filter) {
		std::set<HotkeyModelCombo*> old_visible;
		for (auto item : visible_items)
			old_visible.insert(static_cast<HotkeyModelCombo*>(item.GetID()));

		visible_items.clear();

		wxDataViewItemArray added;
		wxDataViewItemArray removed;

		for (auto& combo : children) {
			bool was_visible = old_visible.count(&combo) > 0;
			bool is_visible = combo.IsVisible(new_filter);

			if (is_visible)
				visible_items.push_back(wxDataViewItem(&combo));
			if (was_visible && !is_visible)
				removed.push_back(wxDataViewItem(&combo));
			if (is_visible && !was_visible)
				added.push_back(wxDataViewItem(&combo));
		}

		if (!added.empty())
			model->ItemsAdded(wxDataViewItem(this), added);
		if (!removed.empty())
			model->ItemsDeleted(wxDataViewItem(this), removed);
	}

unsigned int MyMusicTreeModel::GetChildren( const wxDataViewItem &parent,
                                            wxDataViewItemArray &array ) const
{
    MyMusicTreeModelNode *node = (MyMusicTreeModelNode*) parent.GetID();
    if (!node)
    {
        array.Add( wxDataViewItem( (void*) m_root ) );
        return 1;
    }

    if (node == m_classical)
    {
        MyMusicTreeModel *model = (MyMusicTreeModel*)(const MyMusicTreeModel*) this;
        model->m_classicalMusicIsKnownToControl = true;
    }

    if (node->GetChildCount() == 0)
    {
        return 0;
    }

    unsigned int count = node->GetChildren().GetCount();
    for (unsigned int pos = 0; pos < count; pos++)
    {
        MyMusicTreeModelNode *child = node->GetChildren().Item( pos );
        array.Add( wxDataViewItem( (void*) child ) );
    }

    return count;
}

	void SetFilter(wxRegEx const& new_filter) {
		std::set<HotkeyModelCombo*> old_visible;
		for (size_t i = 0; i < visible_items.size(); ++i)
			old_visible.insert(static_cast<HotkeyModelCombo*>(visible_items[i].GetID()));

		visible_items.clear();

		wxDataViewItemArray added;
		wxDataViewItemArray removed;

		for (std::list<HotkeyModelCombo>::iterator it = children.begin(); it != children.end(); ++it) {
			bool was_visible = old_visible.count(&*it) > 0;
			bool is_visible = it->IsVisible(new_filter);

			if (is_visible)
				visible_items.push_back(wxDataViewItem(&*it));
			if (was_visible && !is_visible)
				removed.push_back(wxDataViewItem(&*it));
			if (is_visible && !was_visible)
				added.push_back(wxDataViewItem(&*it));
		}

		if (!added.empty())
			model->ItemsAdded(wxDataViewItem(this), added);
		if (!removed.empty())
			model->ItemsDeleted(wxDataViewItem(this), removed);
	}

unsigned int ArtifactViewModel::GetChildren(const wxDataViewItem &item, wxDataViewItemArray &children) const
{
    // Root item
    if (!item) {
        for (auto& slot : m_artifactBag) {
            auto artifactPtr = slot.second.get();
            children.Add(wxDataViewItem(artifactPtr));
        }

        return m_artifactBag.size();
    }

    const auto& artifact = *reinterpret_cast<Artifact*>(item.GetID());
    if (!artifact.GetInfusedArtifacts().empty()) {
        const auto& infusedArtifacts = artifact.GetInfusedArtifacts();
        for (auto& infusedArtifact : infusedArtifacts) {
            auto artifactPtr = infusedArtifact.get();
            children.Add(wxDataViewItem(artifactPtr));
        }

        return infusedArtifacts.size();
    }

    assert(!!"Should not happen");
    return 0;
}

    virtual unsigned int    GetChildren( wxDataViewItemArray& aItems ) const
    {
        /// @todo C++11
        for( std::list<Pin*>::const_iterator i = m_Members.begin(); i != m_Members.end(); ++i )
            aItems.push_back( wxDataViewItem( *i ) );

        return aItems.size();
    }

void TreeListModel::DeleteItems(const wxDataViewItem& parent, const wxDataViewItemArray& items)
{
    // sanity
    for(size_t i=0; i<items.GetCount(); ++i) {
        TreeListModel_Item* node = reinterpret_cast<TreeListModel_Item*>(items.Item(i).m_pItem);
        wxUnusedVar(node);
        wxASSERT(node && node->GetParent() == parent.m_pItem);
        DeleteItem(items.Item(i));
    }
}

/**
 * Adds each child row to the supplied list, and returns the total child count
 */
unsigned int BOM_TABLE_GROUP::GetChildren( wxDataViewItemArray& aChildren ) const
{
    // Show drop-down for child components
    for( auto& row : Components )
    {
        if( row )
        {
            aChildren.push_back( RowToItem( &*row ) );
        }
    }

    return aChildren.size();
}

void wxOSXDataViewModelNotifier::AdjustRowHeights(wxDataViewItemArray const& items)
{
  if ((m_DataViewCtrlPtr->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) != 0)
  {
      size_t const noOfItems = items.GetCount();

      wxDataViewModel *model = GetOwner();

      for (size_t itemIndex=0; itemIndex<noOfItems; ++itemIndex)
      {
        int height = 20; // TODO find out standard height
        unsigned int num = m_DataViewCtrlPtr->GetColumnCount();
        unsigned int col;

        for (col = 0; col < num; col++)
        {
            wxDataViewColumn* column(m_DataViewCtrlPtr->GetColumnPtr(col));

            if (!(column->IsHidden()))
            {
              wxDataViewCustomRenderer *renderer = dynamic_cast<wxDataViewCustomRenderer*>(column->GetRenderer());
              if (renderer)
              {
                  wxVariant value;
                  model->GetValue( value, items[itemIndex], column->GetModelColumn() );
                  renderer->SetValue( value );
                  height = wxMax( height, renderer->GetSize().y );
              }
            }
        }
        if (height > 20)
          m_DataViewCtrlPtr->GetDataViewPeer()->SetRowHeight(items[itemIndex],height);
      }
  }
}

void wxDataViewCtrl::SetSelections(wxDataViewItemArray const& sel)
{
    size_t const noOfSelections = sel.GetCount();

    size_t i;

    wxDataViewItem last_parent;


   // make sure that all to be selected items are visible in the control:
    for (i = 0; i < noOfSelections; i++)
    {
        wxDataViewItem item   = sel[i];
        wxDataViewItem parent = GetModel()->GetParent( item );

        if (parent.IsOk() && (parent != last_parent))
          ExpandAncestors(item);
        last_parent = parent;
    }

   // finally select the items:
    wxDataViewWidgetImpl* dataViewWidgetPtr(GetDataViewPeer()); // variable definition for abbreviational purposes

    for (i=0; i<noOfSelections; ++i)
      dataViewWidgetPtr->Select(sel[i]);
}

void MyListModel::DeleteItems( const wxDataViewItemArray &items )
{
    unsigned i;
    wxArrayInt rows;
    for (i = 0; i < items.GetCount(); i++)
    {
        unsigned int row = GetRow( items[i] );
        if (row < m_textColValues.GetCount())
            rows.Add( row );
    }

    if (rows.GetCount() == 0)
    {
        // none of the selected items were in the range of the items
        // which we store... for simplicity, don't allow removing them
        wxLogError( "Cannot remove rows with an index greater than %d", m_textColValues.GetCount() );
        return;
    }

    // Sort in descending order so that the last
    // row will be deleted first. Otherwise the
    // remaining indeces would all be wrong.
    rows.Sort( my_sort_reverse );
    for (i = 0; i < rows.GetCount(); i++)
        m_textColValues.RemoveAt( rows[i] );

    // This is just to test if wxDataViewCtrl can
    // cope with removing rows not sorted in
    // descending order
    rows.Sort( my_sort );
    RowsDeleted( rows );
}

unsigned int ProjectViewModel::GetChildren( const wxDataViewItem& item, wxDataViewItemArray& items ) const
{
	int count = 0;
	Asset *pAsset = NULL;

	if (!item.IsOk())
	{
		ForciblyFullyLoadedPackageManager::GetStaticInstance()->ForceFullyLoadRootPackages();
		pAsset = Asset::GetFirstTopLevelAsset();
	}
	else
	{
		Asset* pParentAsset = static_cast< Asset* >( item.GetID() );

		if ( pParentAsset->IsPackage() )
		{
			ForciblyFullyLoadedPackageManager::GetStaticInstance()->ForceFullyLoadPackage( pParentAsset->GetPath() );
		}

		pAsset = pParentAsset->GetFirstChild();
	}

	while (pAsset)
	{
		//if ( m_AssetsInTree.Insert( pAsset ).Second() )
		{
			items.Add( wxDataViewItem( pAsset ) );
			++count;
		}

		pAsset = pAsset->GetNextSibling();
	}

	return count;
}

void CTimeBarListModel::DeleteItems( const wxDataViewItemArray &items )
{
    wxArrayInt rows;
    for (unsigned i = 0; i < items.GetCount(); i++)
    {
        unsigned int row = GetRow( items[i] );
        if (row < m_textColValues.GetCount())
            rows.Add( row );
    }

    if (rows.GetCount() > 0)
    {
        // Sort in descending order so that the last
        // row will be deleted first. Otherwise the
        // remaining indeces would all be wrong.
        rows.Sort([](int *v1, int *v2)
        {
            return *v2-*v1;
        });
        for (unsigned i = 0; i < rows.GetCount(); i++)
        {
            m_textColValues.RemoveAt( rows[i] );
            m_view.RemoveAt( rows[i] );
            m_lock.RemoveAt( rows[i] );
        }
        // This is just to test if wxDataViewCtrl can
        // cope with removing rows not sorted in
        // descending order
        rows.Sort([](int *v1, int *v2)
        {
            return *v1-*v2;
        });
        RowsDeleted( rows );
    }
}

unsigned int GNC::GUI::AcquisitionTableModel::GetChildren( const wxDataViewItem &parent, wxDataViewItemArray &array ) const
{
        AcquisitionNode *node = (AcquisitionNode*) parent.GetID();
        if (!node) {
                unsigned int count = studyMap.size();
                for (TMapIndex::const_iterator it = studyMap.begin(); it !=  studyMap.end(); ++it) {
                        array.Add( wxDataViewItem( (void*) (*it).second) );
                }
                return count;
        } else if (node->IsStudyNode()) {
                //return series from study...
                node->GetChildren(array);
                return array.Count();
        }
        return 0;
}

unsigned int DIALOG_LIB_EDIT_PIN_TABLE::DataViewModel::GetChildren( const wxDataViewItem& aItem,
        wxDataViewItemArray& aItems ) const
{
    if( !aItem.IsOk() )
    {
        for( std::map<wxString, Group>::iterator i = m_Groups.begin(); i != m_Groups.end(); ++i )
            if( i->second.GetCount() > 1 )
                aItems.push_back( wxDataViewItem( &i->second ) );

        for( std::list<Pin>::iterator i = m_Pins.begin(); i != m_Pins.end(); ++i )
            if( !i->GetParent().IsOk() )
                aItems.push_back( wxDataViewItem( &*i ) );

        return aItems.size();
    }
    else
        return reinterpret_cast<Item const*>( aItem.GetID() )->GetChildren( aItems );
}

unsigned int TreeListModel::GetChildren(const wxDataViewItem& item, wxDataViewItemArray& children) const
{
    if(item.GetID() == NULL) {
        // Root
        for(size_t i=0; i<m_data.size(); ++i) {
            children.Add( wxDataViewItem( m_data.at(i) ) );
        }
        return children.size();
    }

    children.Clear();
    TreeListModel_Item* node = reinterpret_cast<TreeListModel_Item*>(item.m_pItem);
    if ( node ) {
        for(size_t i=0; i<node->GetChildren().size(); ++i) {
            children.Add( wxDataViewItem( node->GetChildren().at(i) ) );
        }
    }
    return children.GetCount();
}

unsigned int TreeModelFilter::GetChildren(const wxDataViewItem& item, wxDataViewItemArray& children) const
{
	if (_filterColumn == NULL && !_customVisibleFunc)
	{
		return _childModel->GetChildren(item, children);
	}

	// Get the raw child list
	wxDataViewItemArray unfilteredChildren;
	_childModel->GetChildren(item, unfilteredChildren);

	// Only add the visible ones to the result set
	std::for_each(unfilteredChildren.begin(), unfilteredChildren.end(), [&] (const wxDataViewItem& item)
	{
        if (ItemIsVisible(item))
		{
			children.Add(item);
		}
	});

	return children.size();
}

	virtual unsigned int GetChildren(const wxDataViewItem &parent, wxDataViewItemArray &array) const
	{
		const ReplayProvider* provider = (ReplayProvider*)parent.GetID();
		if (!provider)
			provider = m_root;

		for (auto it = provider->provider.begin(); it != provider->provider.end(); ++it)
		{
			ReplayProvider* childProvider = (ReplayProvider*)it->get();
			array.Add(wxDataViewItem((void*)childProvider));
		}

		return provider->provider.size();
	}

unsigned
wxTreeListModel::GetChildren(const wxDataViewItem& item,
                             wxDataViewItemArray& children) const
{
    Node* const node = FromDVI(item);

    unsigned numChildren = 0;
    for ( Node* child = node->GetChild(); child; child = child->GetNext() )
    {
        children.push_back(ToDVI(child));
        numChildren++;
    }

    return numChildren;
}

//=====================================================================================
/*virtual*/ unsigned int WinnerPanel::WinEntryDataViewModel::GetChildren( const wxDataViewItem& item, wxDataViewItemArray& children ) const
{
	if( item.IsOk() )
		return 0;

	for( Mongo::WinEntryList::const_iterator iter = winEntryList.cbegin(); iter != winEntryList.cend(); iter++ )
	{
		const Mongo::WinEntry* winEntry = *iter;

		wxDataViewItem item;
		item.m_pItem = ( void* )winEntry;

		children.Add( item );
	}

	return winEntryList.size();
}

unsigned int vvStampsModel::GetChildren(
	const wxDataViewItem& cItem,
	wxDataViewItemArray&  cChildren
	) const
{
	// if this isn't the invisible root, it has no children
	if (cItem.IsOk())
	{
		return 0u;
	}

	// return a list of all of our items
	for (stlDataItemMap::const_iterator it = this->mcDataItems.begin(); it != this->mcDataItems.end(); ++it)
	{
		cChildren.Add(this->ConvertDataItem(it));
	}
	return this->mcDataItems.size();
}