bool RKObjectListViewSettings::filterAcceptsRow (int source_row, const QModelIndex& source_parent) const {
// RK_TRACE (APP);
// So I tried to use a KRecursiveFilterProxyModel, but
// a) we don't really want recursion to the full depth. Thus limiting it, here.
// b) While we don't handle insertions / removals of source indices in the presence of a filter, correctly, with KRecursiveFilterProxyModel
// I got crashes on this (arguably with the depth-limit in place)
if (acceptRow (source_row, source_parent)) return true;
RObject *parent = static_cast<RObject*> (source_parent.internalPointer ());
if (!parent) {
RK_ASSERT (parent); // should have been accepted, above
return true;
}
RObject *object = parent->findChildByObjectModelIndex (source_row);
if (!object) {
RK_ASSERT (object); // should have been accepted, above
RK_DEBUG (APP, DL_ERROR, "row %d of %d in %s", source_row, sourceModel ()->rowCount (source_parent), qPrintable (parent->getShortName ()));
return false;
}
if (object->isType (RObject::ToplevelEnv | RObject::Workspace) || ((depth_limit > 0) && parent->isType (RObject::ToplevelEnv | RObject::Workspace))) {
QModelIndex source_index = sourceModel ()->index (source_row, 0, source_parent);
for (int row = 0, rows = sourceModel()->rowCount (source_index); row < rows; ++row) {
if (filterAcceptsRow (row, source_index)) return true;
}
}
return false;
}
bool LibraryFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
if (filterAcceptsRowItself(sourceRow, sourceParent)) {
return true;
}
// Accept if any of the parents is accepted on it's own merits
QModelIndex parent = sourceParent;
while (parent.isValid()) {
if (filterAcceptsRowItself(parent.row(), parent.parent())) {
return true;
}
parent = parent.parent();
}
// Accept if any of the children is accepted on it's own merits
if (hasAcceptedChildren(sourceRow, sourceParent)) {
return true;
}
// Accept separators if any top level items and its children are accepted
QStandardItemModel *model = qobject_cast<QStandardItemModel*>(sourceModel());
QStandardItem *item = model->itemFromIndex(model->index(sourceRow, 0, sourceParent));
if (item && item->type() == Miam::IT_Separator) {
for (QModelIndex index : _topLevelItems.values(static_cast<SeparatorItem*>(item))) {
if (filterAcceptsRow(index.row(), sourceParent)) {
return true;
}
}
}
return (SettingsPrivate::instance()->librarySearchMode() == SettingsPrivate::LSM_HighlightOnly);
}
bool BtBookshelfFilterModel::hiddenFilterAcceptsRow(int row, const QModelIndex &parent) const
{
if (m_showHidden && m_showShown) return true;
typedef Qt::CheckState CS;
QAbstractItemModel *m(sourceModel());
Q_ASSERT(m != 0);
QModelIndex itemIndex(m->index(row, m_hiddenFilterColumn, parent));
int numChildren(m->rowCount(itemIndex));
if (numChildren == 0) {
if ((CS) m->data(itemIndex, m_hiddenFilterRole).toBool()) {
return m_showHidden;
}
else {
return m_showShown;
}
}
else {
for (int i(0); i < numChildren; i++) {
if (filterAcceptsRow(i, itemIndex)) return true;
}
return false;
}
}
bool KSortFilterProxyModel::filterAcceptsRow ( int source_row, const QModelIndex & source_parent ) const
{
if( filterRegExp().isEmpty() ) return true; //Shortcut for common case
if( QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent) )
return true;
//one of our children might be accepted, so accept this row if one of our children are accepted.
QModelIndex source_index = sourceModel()->index(source_row, 0, source_parent);
for(int i = 0 ; i < sourceModel()->rowCount(source_index); i++) {
if(filterAcceptsRow(i, source_index)) return true;
}
//one of our parents might be accepted, so accept this row if one of our parents is accepted.
if(d_ptr->showAllChildren) {
QModelIndex parent_index = source_parent;
while(parent_index.isValid()) {
int row = parent_index.row();
parent_index = parent_index.parent();
if(QSortFilterProxyModel::filterAcceptsRow(row, parent_index)) return true;
}
}
return false;
}
bool AndFilterProxy::filterAcceptsRow(int source_row, const QModelIndex & source_parent) const
{
QModelIndex currntIndex = sourceModel()->index(source_row, 0, source_parent);
if (sourceModel()->hasChildren(currntIndex)) {
bool result = false;
for (int i = 0; i < sourceModel()->rowCount(currntIndex) && !result; ++i) {
result = result || filterAcceptsRow(i, currntIndex);
}
return result;
}
else {
for (int i = 0; i < sourceModel()->columnCount(source_parent); ++i) {
currntIndex = sourceModel()->index(source_row, i, source_parent);
if (currntIndex.data().isNull() && currntIndex.parent().isValid()) {
currntIndex = sourceModel()->index(source_parent.row(), i, source_parent.parent());
}
for (auto dateRngIter = m_dateRangeFilter.at(i).constBegin(); dateRngIter != m_dateRangeFilter.at(i).constEnd(); ++dateRngIter) {
const QDate testDate = currntIndex.data(dateRngIter.key()).toDate();
if (!((testDate >= dateRngIter.value().first || dateRngIter.value().first.isNull()) && (testDate <= dateRngIter.value().second || dateRngIter.value().second.isNull())))
return false;
}
for (auto boolIter = m_boolFilter.at(i).constBegin(); boolIter != m_boolFilter.at(i).constEnd(); ++boolIter) {
const bool testBool = currntIndex.data(boolIter.key()).toBool();
if (testBool != boolIter.value())
return false;
}
for (auto regExpIter = m_regExpFilter.at(i).constBegin(); regExpIter != m_regExpFilter.at(i).constEnd(); ++regExpIter) {
if (regExpIter.value().first.match(currntIndex.data(regExpIter.key()).toString()).hasMatch() != regExpIter.value().second)
return false;
}
}
}
return true;
}
bool ChildrenFilter::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
// custom behaviour :
if(filterRegExp().isEmpty()==false)
{
// get source-model index for current row
QModelIndex source_index = sourceModel()->index(source_row, this->filterKeyColumn(), source_parent) ;
if(source_index.isValid())
{
// if any of children matches the filter, then current index matches the filter as well
int i, nb = sourceModel()->rowCount(source_index) ;
for(i=0; i<nb; ++i)
{
if(filterAcceptsRow(i, source_index))
{
return true ;
}
}
// check current index itself :
QString key = sourceModel()->data(source_index, filterRole()).toString();
return key.contains(filterRegExp()) ;
}
}
// parent call for initial behaviour
return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent) ;
}
bool ModListSortProxy::filterAcceptsRow(int row, const QModelIndex &parent) const
{
if (m_Profile == nullptr) {
return false;
}
if (row >= static_cast<int>(m_Profile->numMods())) {
qWarning("invalid row idx %d", row);
return false;
}
QModelIndex idx = sourceModel()->index(row, 0, parent);
if (!idx.isValid()) {
qDebug("invalid index");
return false;
}
if (sourceModel()->hasChildren(idx)) {
for (int i = 0; i < sourceModel()->rowCount(idx); ++i) {
if (filterAcceptsRow(i, idx)) {
return true;
}
}
return false;
} else {
bool modEnabled = idx.sibling(row, 0).data(Qt::CheckStateRole).toInt() == Qt::Checked;
unsigned int index = idx.data(Qt::UserRole + 1).toInt();
return filterMatchesMod(ModInfo::getByIndex(index), modEnabled);
}
}
void FilterProxyModel::commitBatchToModel (int src_from, int src_to, BatchCmd const & batch)
{
int const rows = src_to - src_from;
int const from = m_map_from_tgt.size();
m_map_from_src.reserve(m_log_widget.m_src_model->rowCount());
QVector<int> accepted_rows; // grr
accepted_rows.reserve(32);
int tgt_idx = m_map_from_tgt.size();
for (size_t src_idx = src_from; src_idx < src_to; ++src_idx)
{
if (filterAcceptsRow(src_idx, QModelIndex()))
{
accepted_rows.push_back(src_idx);
m_map_from_src.insert(std::make_pair(src_idx, tgt_idx));
++tgt_idx;
}
}
if (int const n_accepted = accepted_rows.size())
{
m_map_from_tgt.reserve(from + n_accepted);
int const to = from + n_accepted - 1;
beginInsertRows(QModelIndex(), from, to);
for (int i = 0, ie = n_accepted; i < ie; ++i)
{
m_map_from_tgt.push_back(accepted_rows[i]);
}
endInsertRows();
}
//@FIXME l8r: this does not work in general!
if (m_cmap_from_src.size() < m_log_widget.m_src_model->columnCount())
{
int const from = m_cmap_from_src.size();
m_cmap_from_tgt.clear();
m_cmap_from_src.clear();
m_cmap_from_src.reserve(m_log_widget.m_src_model->columnCount());
int ctgt_idx = 0;
for (size_t src_idx = 0, se = m_log_widget.m_src_model->columnCount(); src_idx < se; ++src_idx)
{
if (filterAcceptsColumn(src_idx, QModelIndex()))
{
m_cmap_from_src.insert(std::make_pair(src_idx, ctgt_idx));
++ctgt_idx;
}
}
int const to = ctgt_idx - 1;
beginInsertColumns(QModelIndex(), from, to);
m_cmap_from_tgt.resize(m_cmap_from_src.size());
for (map_t::const_iterator it = m_cmap_from_src.begin(), ite = m_cmap_from_src.end(); it != ite; ++it)
{
m_cmap_from_tgt[it->second] = it->first;
}
endInsertColumns();
}
}
bool DocumentFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
if( !index.isValid()) {
return false;
}
bool accepted = false;
// filter works on the document ID, the client name and the document type.
const QRegExp filter = filterRegExp();
if( filter.pattern().isEmpty() ) {
accepted = true;
} else {
const QModelIndex index0 = sourceModel()->index(sourceRow, DocumentModel::Document_Ident, sourceParent);
const QString idStr = sourceModel()->data(index0).toString();
const QModelIndex index1 = sourceModel()->index(sourceRow, DocumentModel::Document_Type, sourceParent);
const QString typeStr = sourceModel()->data(index1).toString();
const QModelIndex index2 = sourceModel()->index(sourceRow, DocumentModel::Document_ClientName, sourceParent);
const QString clientNameStr = sourceModel()->data(index2).toString();
const QModelIndex index3 = sourceModel()->index(sourceRow, DocumentModel::Document_Whiteboard, sourceParent);
const QString whiteboardStr = sourceModel()->data(index3).toString();
const QModelIndex index4 = sourceModel()->index(sourceRow, DocumentModel::Document_ProjectLabel, sourceParent);
const QString projectStr = sourceModel()->data(index4).toString();
if( idStr.contains(filter) || typeStr.contains(filter) || clientNameStr.contains(filter)
|| whiteboardStr.contains(filter) || projectStr.contains(filter)) {
accepted = true;
}
}
// for the treeview, check all the children
if( _enableTreeView ) {
int rows = sourceModel()->rowCount(index);
for (int row = 0; row < rows; row++) {
if (filterAcceptsRow(row, index)) {
accepted = true;
}
}
}
// if the entry is accepted so far, check if it is within the time limit
if( accepted && m_MaxRows > -1 ) {
const QModelIndex index = sourceModel()->index(sourceRow, DocumentModel::Document_CreationDateRaw, sourceParent);
const QDate docDate = sourceModel()->data(index).toDate();
int dateDiff = docDate.daysTo(QDate::currentDate());
if( dateDiff > m_MaxRows ) {
accepted = false;
}
}
return accepted;
}
void QtMessageLogProxyModel::onRowsInserted(const QModelIndex &index, int start, int end)
{
int rowIndex = end;
do {
if (filterAcceptsRow(rowIndex, index)) {
emit scrollToBottom();
break;
}
} while (--rowIndex >= start);
}
bool
PlayableProxyModel::filterAcceptsRow( int sourceRow, const QModelIndex& sourceParent ) const
{
PlayableItem* pi = itemFromIndex( sourceModel()->index( sourceRow, 0, sourceParent ) );
if ( !pi )
return false;
if ( m_maxVisibleItems >= 0 && sourceRow > m_maxVisibleItems - 1 )
return false;
if ( m_hideDupeItems )
{
for ( int i = 0; i < sourceRow; i++ )
{
PlayableItem* di = itemFromIndex( sourceModel()->index( i, 0, sourceParent ) );
if ( !di )
continue;
bool b = ( pi->query() && pi->query()->equals( di->query() ) ) ||
( pi->album() && pi->album() == di->album() ) ||
( pi->artist() && pi->artist()->name() == di->artist()->name() );
if ( b && filterAcceptsRow( i, sourceParent ) )
return false;
}
}
if ( pi->query() )
{
const Tomahawk::query_ptr& q = pi->query()->displayQuery();
if ( q.isNull() ) // uh oh? filter out invalid queries i guess
return false;
Tomahawk::result_ptr r;
if ( q->numResults() )
r = q->results().first();
if ( !m_showOfflineResults && ( r.isNull() || !r->isOnline() ) )
return false;
if ( filterRegExp().isEmpty() )
return true;
QStringList sl = filterRegExp().pattern().split( " ", QString::SkipEmptyParts );
foreach( QString s, sl )
{
s = s.toLower();
if ( !q->artist().toLower().contains( s ) &&
!q->album().toLower().contains( s ) &&
!q->track().toLower().contains( s ) )
{
return false;
}
}
}
bool QtSortFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const {
if (sourceParent.isValid()) {
return QSortFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent);
}
QModelIndex index = sourceModel()->index(sourceRow, filterKeyColumn(), sourceParent);
bool visibleChild = false;
for (int i = 0; i < sourceModel()->rowCount(index); i++) {
visibleChild |= filterAcceptsRow(i, index);
}
return visibleChild;
}
bool EventsProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
if (sourceParent.isValid())
return true;
EventData *eventData = sourceModel()->index(sourceRow, 0).data(EventsModel::EventDataPtr).value<EventData *>();
if (!eventData)
return false;
return filterAcceptsRow(eventData);
}
/** Redefined from MiamSortFilterProxyModel. */
bool UniqueLibraryFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
QStandardItem *item = _model->itemFromIndex(_model->index(sourceRow, 1, sourceParent));
if (!item) {
return false;
}
bool result = false;
switch (item->type()) {
case Miam::IT_Artist:
if (MiamSortFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent)) {
result = true;
} else {
QSqlQuery getArtist(*SqlDatabase::instance());
getArtist.prepare("SELECT * FROM tracks WHERE title LIKE ? AND artistId = ?");
getArtist.addBindValue("%" + filterRegExp().pattern() + "%");
getArtist.addBindValue(item->data(Miam::DF_ID).toUInt());
result = getArtist.exec() && getArtist.next();
}
break;
case Miam::IT_Album:
if (MiamSortFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent)) {
result = true;
} else if (filterRegExp().indexIn(item->data(Miam::DF_Artist).toString()) != -1) {
result = true;
} else {
QSqlQuery getAlbum(*SqlDatabase::instance());
getAlbum.prepare("SELECT * FROM tracks WHERE title LIKE ? AND albumId = ?");
getAlbum.addBindValue("%" + filterRegExp().pattern() + "%");
getAlbum.addBindValue(item->data(Miam::DF_ID).toUInt());
result = getAlbum.exec() && getAlbum.next();
}
break;
case Miam::IT_Track:
if (MiamSortFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent)) {
result = true;
} else {
result = filterRegExp().indexIn(item->data(Miam::DF_Artist).toString()) != -1 ||
filterRegExp().indexIn(item->data(Miam::DF_Album).toString()) != -1;
}
break;
case Miam::IT_Separator:
for (QModelIndex index : _topLevelItems.values(static_cast<SeparatorItem*>(item))) {
if (filterAcceptsRow(index.row(), sourceParent)) {
result = true;
}
}
break;
default:
break;
}
return result;
}
bool omni::ui::tree_sort_filter_proxy_model::filterAcceptsRow (int sourceRow, const QModelIndex & sourceParent) const
{
// If this row matches, return true:
if (filterAcceptsRowExactly (sourceRow, sourceParent)) {
return true;
}
// Now check whether any of this row's child rows matches:
QModelIndex row = sourceModel ()->index (sourceRow, filterKeyColumn (), sourceParent);
for (int i = 0; i < sourceModel ()->rowCount (row); ++ i) {
if (filterAcceptsRow (i, row)) {
return true;
}
}
// Neither this row, nor any children, match.
return false;
}
void FontFilter::processRowFilter() {
m_accepted_indexes.clear();
m_search_result_count = 0;
int source_row_count = totalFontCount();
for(int i=0; i<source_row_count; i++) {
if (filterAcceptsRow(i))
m_accepted_indexes.append(i);
}
if (searchFiltered())
emit searchResultsChanged(m_search_result_count);
else
emit searchResultsChanged(-1);
reset();
}
bool CategorySortFilterModel::filterAcceptsRow(int source_row,
const QModelIndex &source_parent) const
{
if (!source_parent.isValid()) {
// category items should be visible if any of its children match
const QRegExp ®exp = filterRegExp();
const QModelIndex &categoryIndex = sourceModel()->index(source_row, 0, source_parent);
if (regexp.indexIn(sourceModel()->data(categoryIndex, filterRole()).toString()) != -1)
return true;
const int rowCount = sourceModel()->rowCount(categoryIndex);
for (int row = 0; row < rowCount; ++row) {
if (filterAcceptsRow(row, categoryIndex))
return true;
}
return false;
}
return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
}
bool SortFilterProxy::filterAcceptsRow ( int source_row, const QModelIndex & source_parent ) const
{
const int column=0;
// Filter Mask/Value check
QModelIndex item=sourceModel()->index(source_row,column,source_parent);
QVariant filter=item.data(FilterRole);
if (filter.isValid())
{
bool f=filter.toBool();
if (f)
return false;
}
// parent check
QModelIndex p=source_parent;
while (p.isValid())
{
if (QSortFilterProxyModel::filterAcceptsRow(p.row(),p.parent()))
return true;
p=p.parent();
}
// Child check
if (QSortFilterProxyModel::filterAcceptsRow(source_row,source_parent))
return true;
else
{
if (! _recurse)
return false;
QModelIndex item=sourceModel()->index(source_row,column,source_parent);
for (int r=0;;r++)
{
if (! item.child(r,column).isValid() )
return false;
if (filterAcceptsRow(r,item))
return true;
}
}
}
bool BtBookshelfFilterModel::nameFilterAcceptsRow(int row, const QModelIndex &parent) const {
if (m_nameFilter.isEmpty()) return true;
const QAbstractItemModel *m(sourceModel());
Q_ASSERT(m != 0);
QModelIndex itemIndex(m->index(row, m_nameFilterColumn, parent));
int numChildren(m->rowCount(itemIndex));
if (numChildren == 0) {
QVariant data(m->data(itemIndex, m_nameFilterRole));
return data.toString().contains(m_nameFilter, m_nameFilterCase);
}
else {
for (int i(0); i < numChildren; i++) {
if (filterAcceptsRow(i, itemIndex)) return true;
}
return false;
}
}
bool BtModuleNameFilterProxyModel::filterAcceptsRow(int row,
const QModelIndex &p) const {
if (!m_enabled) return true;
const QAbstractItemModel *m(sourceModel());
Q_ASSERT(m != 0);
QModelIndex itemIndex(m->index(row, filterKeyColumn(), p));
int numChildren(m->rowCount(itemIndex));
if (numChildren == 0) {
return QSortFilterProxyModel::filterAcceptsRow(row, p);
}
else {
for (int i(0); i < numChildren; i++) {
if (filterAcceptsRow(i, itemIndex)) return true;
}
return false;
}
}
// this solution was taken from:
// http://stackoverflow.com/questions/250890/using-qsortfilterproxymodel-with-a-tree-model
bool TagSortFilterProxyModel::filterAcceptsRow(int source_row,
const QModelIndex &source_parent) const
{
if(filterRegExp().isEmpty() == false)
{
QModelIndex source_index = sourceModel()->index(source_row, filterKeyColumn(), source_parent) ;
if(source_index.isValid())
{
int nb = sourceModel()->rowCount(source_index) ;
for(int i = 0; i < nb; ++i)
if(filterAcceptsRow(i, source_index))
return true;
QString key = sourceModel()->data(source_index, filterRole()).toString();
return key.contains(filterRegExp());
}
}
return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent) ;
}
bool MimetypeFilterItemModel::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
{
QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
if (source_parent.isValid())
{
return filterHelper(index);
}
else
{
for (int i = 0; i < sourceModel()->rowCount(index); i++)
{
if (filterAcceptsRow(i, index))
{
return true;
}
}
}
return false;
}
bool BtBookshelfFilterModel::categoryFilterAcceptsRow(int row,
const QModelIndex &parent) const
{
if (m_categoryFilter == CSwordModuleInfo::AllCategories) return true;
QAbstractItemModel *m(sourceModel());
Q_ASSERT(m != 0);
QModelIndex itemIndex(m->index(row, m_categoryFilterColumn, parent));
int numChildren(m->rowCount(itemIndex));
if (numChildren == 0) {
int cat = m->data(itemIndex, m_categoryFilterRole).toInt();
return m_categoryFilter.testFlag((CSwordModuleInfo::Category) cat);
}
else {
for (int i(0); i < numChildren; i++) {
if (filterAcceptsRow(i, itemIndex)) return true;
}
return false;
}
}
bool DwarfModelProxy::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const {
bool matches = true;
int dwarf_id = 0;
const DwarfModel *m = get_dwarf_model();
if (m->current_grouping() == DwarfModel::GB_NOTHING) {
QModelIndex idx = m->index(source_row, 0, source_parent);
dwarf_id = m->data(idx, DwarfModel::DR_ID).toInt();
QString data = m->data(idx, filterRole()).toString();
if (!m_filter_text.isEmpty())
matches = matches && data.contains(m_filter_text, Qt::CaseInsensitive);
} else {
QModelIndex tmp_idx = m->index(source_row, 0, source_parent);
QStandardItem *item = m->itemFromIndex(tmp_idx);
if (m->data(tmp_idx, DwarfModel::DR_IS_AGGREGATE).toBool()) {
int matches = 0;
for(int i = 0; i < item->rowCount(); ++i) {
if (filterAcceptsRow(i, tmp_idx)) // a child matches
matches++;
}
matches = matches && matches > 0;
} else {
QModelIndex idx = m->index(source_row, 0, source_parent);
dwarf_id = m->data(idx, DwarfModel::DR_ID).toInt();
QString data = m->data(idx, filterRole()).toString();
if (!m_filter_text.isEmpty())
matches = matches && data.contains(m_filter_text, Qt::CaseInsensitive);
}
}
if (dwarf_id && !m_active_filter_script.isEmpty()) {
Dwarf *d = m->get_dwarf_by_id(dwarf_id);
if (d) {
QScriptValue d_obj = m_engine->newQObject(d);
m_engine->globalObject().setProperty("d", d_obj);
matches = matches && m_engine->evaluate(m_active_filter_script).toBool();
}
}
return matches;
}
bool BtBookshelfFilterModel::hiddenFilterAcceptsRow(int row,
const QModelIndex & parent) const
{
if (m_showHidden && m_showShown)
return true;
const QAbstractItemModel * const m = sourceModel();
Q_ASSERT(m != 0);
const QModelIndex itemIndex = m->index(row, m_hiddenFilterColumn, parent);
const int numChildren = m->rowCount(itemIndex);
if (numChildren == 0) {
if (static_cast<Qt::CheckState>(m->data(itemIndex, m_hiddenFilterRole).toBool()))
return m_showHidden;
return m_showShown;
}
for (int i = 0; i < numChildren; i++)
if (filterAcceptsRow(i, itemIndex))
return true;
return false;
}
bool ShortcutsFilterModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
if (filterRegExp().isEmpty())
return true;
if (source_parent.isValid())
{
QModelIndex index = source_parent.child(source_row, filterKeyColumn());
QString data = sourceModel()->data(index, filterRole()).toString();
return data.contains(filterRegExp());
}
else
{
QModelIndex index = sourceModel()->index(source_row, filterKeyColumn());
for (int row = 0; row < sourceModel()->rowCount(index); row++)
{
if (filterAcceptsRow(row, index))
return true;
}
}
return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
}
bool QFPseudoTreeModelSortFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
QFPseudoTreeModel* tree=qobject_cast<QFPseudoTreeModel*>(sourceModel());
if (tree) {
QModelIndex idx=tree->index(sourceRow, 0, sourceParent);
if (idx.isValid()) {
if (tree->isFolder(idx)) {
QList<int> c=tree->folderContentsRows(idx);
for (int i=0; i<c.size(); i++) {
if (filterAcceptsRow(c[i], sourceParent)) {
return true;
}
}
return false;
} else {
return QSortFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent);
}
}
} else {
return QSortFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent);
}
return true;
}
bool SortFilterProxyModel::filterAcceptsRow (int row, const QModelIndex& parent) const
{
if (MUCMode_)
{
if (!MUCEntry_)
return false;
const QModelIndex& idx = sourceModel ()->index (row, 0, parent);
switch (GetType (idx))
{
case Core::CLETAccount:
{
QObject *acc = qobject_cast<ICLEntry*> (MUCEntry_)->GetParentAccount ();
return acc == idx.data (Core::CLRAccountObject).value<QObject*> ();
}
case Core::CLETCategory:
{
const QString& gName = idx.data ().toString ();
return gName == qobject_cast<IMUCEntry*> (MUCEntry_)->GetGroupName () ||
qobject_cast<ICLEntry*> (MUCEntry_)->Groups ().contains (gName);
}
default:
break;
}
}
else
{
const QModelIndex& idx = sourceModel ()->index (row, 0, parent);
if (!filterRegExp ().isEmpty ())
return GetType (idx) == Core::CLETContact ?
idx.data ().toString ().contains (filterRegExp ()) :
true;
if (idx.data (Core::CLRUnreadMsgCount).toInt ())
return true;
const auto type = GetType (idx);
if (type == Core::CLETContact)
{
ICLEntry *entry = GetEntry (idx);
const State state = entry->GetStatus ().State_;
if (!ShowOffline_ &&
state == SOffline &&
!idx.data (Core::CLRUnreadMsgCount).toInt ())
return false;
if (HideMUCParts_ &&
entry->GetEntryType () == ICLEntry::ETPrivateChat)
return false;
if (!ShowSelfContacts_ &&
entry->GetEntryFeatures () & ICLEntry::FSelfContact)
return false;
}
else if (type == Core::CLETCategory)
{
if (!ShowOffline_ &&
!idx.data (Core::CLRNumOnline).toInt ())
return false;
for (int subRow = 0; subRow < sourceModel ()->rowCount (idx); ++subRow)
if (filterAcceptsRow (subRow, idx))
return true;
return false;
}
else if (type == Core::CLETAccount)
{
const auto& accObj = idx.data (Core::CLRAccountObject).value<QObject*> ();
auto acc = qobject_cast<IAccount*> (accObj);
return acc->IsShownInRoster ();
}
}
return QSortFilterProxyModel::filterAcceptsRow (row, parent);
}
bool
NameNumberFilterProxy::filterAcceptsRow(int source_row, const QModelIndex & source_parent) const
{
// we filter the regex only on Calls, Contacts and ContactMethods; however we don't want to display
// the top nodes (Categories) if they have no children
if (!source_parent.isValid() && filterRegExp().isEmpty()) {
return true;
} else if (!source_parent.isValid()) {
// check if there are any children, don't display the categroy if not
auto idx = sourceModel()->index(source_row, 0, source_parent);
if (!idx.isValid())
return false;
for (int row = 0; row < sourceModel()->rowCount(idx); ++row) {
if (filterAcceptsRow(row, idx)) {
return true;
}
}
return false;
} else {
auto idx = sourceModel()->index(source_row, 0, source_parent);
if (!idx.isValid()) {
return false;
}
//we want to filter on name and number; note that Person object may have many numbers
if (idx.data(static_cast<int>(Ring::Role::Name)).toString().contains(filterRegExp())) {
return true;
} else {
auto type = idx.data(static_cast<int>(Ring::Role::ObjectType));
auto object = idx.data(static_cast<int>(Ring::Role::Object));
if (!type.isValid() || !object.isValid()) {
return false;
}
switch (type.value<Ring::ObjectType>()) {
case Ring::ObjectType::Person:
{
auto p = object.value<Person *>();
for (auto cm : p->phoneNumbers()) {
if (cm->uri().full().contains(filterRegExp())) {
return true;
}
}
return false;
}
break;
case Ring::ObjectType::ContactMethod:
{
auto cm = object.value<ContactMethod *>();
return cm->uri().full().contains(filterRegExp());
}
break;
case Ring::ObjectType::Call:
{
auto call = object.value<Call *>();
return call->peerContactMethod()->uri().full().contains(filterRegExp());
}
break;
case Ring::ObjectType::Media:
case Ring::ObjectType::Certificate:
case Ring::ObjectType::COUNT__:
break;
}
}
return false; // no matches
}
}
