[SCM] ktp-common-internals packaging branch, master, updated. debian/15.12.1-2-1839-gf0635e9
Maximiliano Curia
maxy at moszumanska.debian.org
Mon May 9 09:04:55 UTC 2016
Gitweb-URL: http://git.debian.org/?p=pkg-kde/applications/ktp-common-internals.git;a=commitdiff;h=d8ba62a
The following commit has been merged in the master branch:
commit d8ba62a6e8f0845c7a34306dd18145bbecc53bb6
Author: Daniele E. Domenichelli <daniele.domenichelli at gmail.com>
Date: Thu Feb 2 21:23:00 2012 +0100
Refactor AccountsFilterModel
---
KTp/Models/accounts-filter-model.cpp | 709 +++++++++++++++++++++++++++++++----
KTp/Models/accounts-filter-model.h | 265 ++++++++++---
2 files changed, 849 insertions(+), 125 deletions(-)
diff --git a/KTp/Models/accounts-filter-model.cpp b/KTp/Models/accounts-filter-model.cpp
index 859c673..a10ec29 100644
--- a/KTp/Models/accounts-filter-model.cpp
+++ b/KTp/Models/accounts-filter-model.cpp
@@ -3,6 +3,7 @@
*
* Copyright (C) 2011 David Edmundson <kde at davidedmundson.co.uk>
* Copyright (C) 2011 Martin Klapetek <martin dot klapetek at gmail dot com>
+ * Copyright (C) 2012 Daniele E. Domenichelli <daniele.domenichelli at gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -31,132 +32,617 @@
#include <KDebug>
+
+class AccountsFilterModel::Private
+{
+public:
+ Private(AccountsFilterModel *parent)
+ : q(parent),
+ presenceTypeFilterFlags(DoNotFilterByCapability),
+ capabilityFilterFlags(DoNotFilterByCapability),
+ subscriptionStateFilterFlags(DoNotFilterBySubscription),
+ globalFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap),
+// displayNameFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap),
+ displayNameFilterMatchFlags(Qt::MatchContains | Qt::MatchWrap),
+ nicknameFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap),
+ aliasFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap),
+ groupsFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap)
+ {
+ }
+
+ AccountsFilterModel *q;
+
+ PresenceTypeFilterFlags presenceTypeFilterFlags;
+ CapabilityFilterFlags capabilityFilterFlags;
+ SubscriptionStateFilterFlags subscriptionStateFilterFlags;
+
+ QString globalFilterString;
+ Qt::MatchFlags globalFilterMatchFlags;
+
+ QString displayNameFilterString;
+ QString nicknameFilterString;
+ QString aliasFilterString;
+ QString groupsFilterString;
+ Qt::MatchFlags displayNameFilterMatchFlags;
+ Qt::MatchFlags nicknameFilterMatchFlags;
+ Qt::MatchFlags aliasFilterMatchFlags;
+ Qt::MatchFlags groupsFilterMatchFlags;
+
+ bool filterAcceptsAccount(const QModelIndex &index) const;
+ bool filterAcceptsContact(const QModelIndex &index) const;
+ bool filterAcceptsGroup(const QModelIndex &index) const;
+};
+
+bool AccountsFilterModel::Private::filterAcceptsAccount(const QModelIndex &index) const
+{
+ //hide disabled accounts
+ if (!index.data(AccountsModel::EnabledRole).toBool()) {
+ return false;
+ }
+ //hide
+ if (index.data(AccountsModel::ConnectionStatusRole).toUInt()
+ != Tp::ConnectionStatusConnected) {
+ return false;
+ }
+ return true;
+}
+
+bool AccountsFilterModel::Private::filterAcceptsContact(const QModelIndex &index) const
+{
+ // Presence type, capability and subscription state are always checked
+ // Then if global filter is set we can return true if a result is found for
+ // any of the strings, otherwise we check all of them
+
+ Q_ASSERT(index.isValid());
+ if (!index.isValid()) {
+ return false;
+ }
+
+ // Check presence type
+ if (presenceTypeFilterFlags != DoNotFilterByCapability) {
+ switch (static_cast<Tp::ConnectionPresenceType>(index.data(AccountsModel::PresenceTypeRole).toUInt())) {
+ case Tp::ConnectionPresenceTypeUnset:
+ if (presenceTypeFilterFlags & HidePresenceTypeUnset) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeOffline:
+ if (presenceTypeFilterFlags & HidePresenceTypeOffline) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeAvailable:
+ if (presenceTypeFilterFlags & HidePresenceTypeAvailable) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeAway:
+ if (presenceTypeFilterFlags & HidePresenceTypeAway) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeExtendedAway:
+ if (presenceTypeFilterFlags & HidePresenceTypeExtendedAway) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeHidden:
+ if (presenceTypeFilterFlags & HidePresenceTypeHidden) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeBusy:
+ if (presenceTypeFilterFlags & HidePresenceTypeBusy) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeUnknown:
+ if (presenceTypeFilterFlags & HidePresenceTypeUnknown) {
+ return false;
+ }
+ break;
+ case Tp::ConnectionPresenceTypeError:
+ if (presenceTypeFilterFlags & HidePresenceTypeError) {
+ return false;
+ }
+ break;
+ default:
+ //This should never happen
+ Q_ASSERT(false);
+ return false;
+ }
+ }
+
+
+ // Check capability
+ if (capabilityFilterFlags != DoNotFilterByCapability) {
+ if ((capabilityFilterFlags & FilterByTextChatCapability)
+ && !index.data(AccountsModel::TextChatCapabilityRole).toBool()) {
+ return false;
+ }
+ if ((capabilityFilterFlags & FilterByMediaCallCapability)
+ && !index.data(AccountsModel::MediaCallCapabilityRole).toBool()) {
+ return false;
+ }
+ if ((capabilityFilterFlags & FilterByAudioCallCapability)
+ && !index.data(AccountsModel::AudioCallCapabilityRole).toBool()) {
+ return false;
+ }
+ if ((capabilityFilterFlags & FilterByVideoCallCapability)
+ && !index.data(AccountsModel::VideoCallCapabilityRole).toBool()) {
+ return false;
+ }
+ if ((capabilityFilterFlags & FilterByFileTransferCapability)
+ && !index.data(AccountsModel::FileTransferCapabilityRole).toBool()) {
+ return false;
+ }
+ if ((capabilityFilterFlags & FilterByDesktopSharingCapability)
+ && !index.data(AccountsModel::DesktopSharingCapabilityRole).toBool()) {
+ return false;
+ }
+ }
+
+
+ // Check subscription state
+ if (subscriptionStateFilterFlags != DoNotFilterBySubscription) {
+ switch (index.data(AccountsModel::SubscriptionStateRole).toUInt()) {
+ case Tp::Contact::PresenceStateNo:
+ if (subscriptionStateFilterFlags & HideSubscriptionStateNo) {
+ return false;
+ }
+ break;
+ case Tp::Contact::PresenceStateAsk:
+ if (subscriptionStateFilterFlags & HideSubscriptionStateAsk) {
+ return false;
+ }
+ break;
+ case Tp::Contact::PresenceStateYes:
+ if (subscriptionStateFilterFlags & HideSubscriptionStateYes) {
+ return false;
+ }
+ break;
+ default:
+ //This should never happen
+ Q_ASSERT(false);
+ return false;
+ }
+
+ switch (index.data(AccountsModel::PublishStateRole).toUInt()) {
+ case Tp::Contact::PresenceStateNo:
+ if (subscriptionStateFilterFlags & HidePublishStateNo) {
+ return false;
+ }
+ break;
+ case Tp::Contact::PresenceStateAsk:
+ if (subscriptionStateFilterFlags & HidePublishStateAsk) {
+ return false;
+ }
+ break;
+ case Tp::Contact::PresenceStateYes:
+ if (subscriptionStateFilterFlags & HidePublishStateYes) {
+ return false;
+ }
+ break;
+ default:
+ //This should never happen
+ Q_ASSERT(false);
+ return false;
+ }
+
+ if (index.data(AccountsModel::BlockedRole).toBool()) {
+ if (subscriptionStateFilterFlags & HideBlocked) {
+ return false;
+ }
+ } else {
+ if (subscriptionStateFilterFlags & HideNonBlocked) {
+ return false;
+ }
+ }
+ }
+
+
+ if (!globalFilterString.isEmpty()) {
+ // Check global filter (search on all the roles)
+
+ // Check display name
+ if (!q->match(index, Qt::DisplayRole, globalFilterString, 1, globalFilterMatchFlags).isEmpty()) {
+ return true;
+ }
+
+ // Check nickname
+ if (!q->match(index, AccountsModel::NicknameRole, globalFilterString, 1, globalFilterMatchFlags).isEmpty()) {
+ return true;
+ }
+
+ // check alias
+ if (!q->match(index, AccountsModel::AliasRole, globalFilterString, 1, globalFilterMatchFlags).isEmpty()) {
+ return true;
+ }
+
+ // check groups
+ // TODO Check if exact match on a single group works
+ if (!q->match(index, AccountsModel::GroupsRole, globalFilterString, 1, globalFilterMatchFlags).isEmpty()) {
+ return true;
+ }
+ } else {
+ // Check on single filters
+ // Check display name
+ if (!displayNameFilterString.isEmpty()) {
+ if (q->match(index, Qt::DisplayRole, displayNameFilterString, 1, displayNameFilterMatchFlags).isEmpty()) {
+ return false;
+ }
+ }
+
+ // Check nickname
+ if (!nicknameFilterString.isEmpty()) {
+ if (q->match(index, AccountsModel::NicknameRole, nicknameFilterString, 1, nicknameFilterMatchFlags).isEmpty()) {
+ return false;
+ }
+ }
+
+ // check alias
+ if (!aliasFilterString.isEmpty()) {
+ if (q->match(index, AccountsModel::AliasRole, aliasFilterString, 1, aliasFilterMatchFlags).isEmpty()) {
+ return false;
+ }
+ }
+ // check groups
+ // TODO Check if exact match on a single group works
+ if (!groupsFilterString.isEmpty()) {
+ if (q->match(index, AccountsModel::GroupsRole, groupsFilterString, 1, groupsFilterMatchFlags).isEmpty()) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
+bool AccountsFilterModel::Private::filterAcceptsGroup(const QModelIndex &index) const
+{
+ if (presenceTypeFilterFlags != DoNotFilterByPresence) {
+ if (index.data(AccountsModel::OnlineUsersCountRole).toInt() == 0) {
+ return false;
+ }
+ }
+ return true;
+}
+
AccountsFilterModel::AccountsFilterModel(QObject *parent)
: QSortFilterProxyModel(parent),
- m_showOfflineUsers(false),
- m_filterByName(false),
- m_filterByFileTransferCapability(false)
+ d(new Private(this))
{
}
-void AccountsFilterModel::setShowOfflineUsers(bool showOfflineUsers)
+AccountsFilterModel::~AccountsFilterModel()
{
- m_showOfflineUsers = showOfflineUsers;
- invalidateFilter();
+ delete d;
}
-bool AccountsFilterModel::showOfflineUsers() const
+AccountsFilterModel::SortMode AccountsFilterModel::sortMode() const
{
- return m_showOfflineUsers;
+ switch (sortRole()) {
+ case Qt::DisplayRole:
+ return DoNotSort;
+ case AccountsModel::PresenceTypeRole:
+ return SortByPresence;
+ case AccountsModel::NicknameRole:
+ return SortByNickname;
+ case AccountsModel::AliasRole:
+ return SortByAlias;
+ default:
+ //This should never happen
+ Q_ASSERT(false);
+ return DoNotSort;
+ }
}
-void AccountsFilterModel::setFilterByFileTransferCapability(bool filterByFileTransferCapability)
+void AccountsFilterModel::resetSortMode()
{
- m_filterByFileTransferCapability = filterByFileTransferCapability;
- invalidateFilter();
+ setSortMode(DoNotSort);
}
-bool AccountsFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+void AccountsFilterModel::setSortMode(SortMode sortMode)
{
- QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
+ switch (sortMode) {
+ case DoNotSort:
+ setSortRole(Qt::DisplayRole);
+ break;
+ case SortByPresence:
+ setSortRole(AccountsModel::PresenceTypeRole);
+ break;
+ case SortByNickname:
+ setSortRole(AccountsModel::NicknameRole);
+ break;
+ case SortByAlias:
+ setSortRole(AccountsModel::AliasRole);
+ break;
+ default:
+ //This should never happen
+ Q_ASSERT(false);
+ return;
+ }
+ Q_EMIT sortModeChanged(sortMode);
+}
- int type = index.data(AccountsModel::ItemRole).userType();
- if (type == qMetaTypeId<ContactModelItem*>()) {
- return filterAcceptsContact(index);
+AccountsFilterModel::PresenceTypeFilterFlags AccountsFilterModel::presenceTypeFilterFlags() const
+{
+ return d->presenceTypeFilterFlags;
+}
+
+void AccountsFilterModel::clearPresenceTypeFilterFlags()
+{
+ setPresenceTypeFilterFlags(DoNotFilterByPresence);
+}
+
+void AccountsFilterModel::setPresenceTypeFilterFlags(AccountsFilterModel::PresenceTypeFilterFlags presenceTypeFilterFlags)
+{
+ if (d->presenceTypeFilterFlags != presenceTypeFilterFlags) {
+ d->presenceTypeFilterFlags = presenceTypeFilterFlags;
+ invalidateFilter();
+ Q_EMIT presenceTypeFilterFlagsChanged(presenceTypeFilterFlags);
}
- else if (type == qMetaTypeId<AccountsModelItem*>()) {
- return filterAcceptsAccount(index);
+}
+
+AccountsFilterModel::CapabilityFilterFlags AccountsFilterModel::capabilityFilterFlags() const
+{
+ return d->capabilityFilterFlags;
+}
+
+void AccountsFilterModel::clearCapabilityFilterFlags()
+{
+ setCapabilityFilterFlags(DoNotFilterByCapability);
+}
+
+void AccountsFilterModel::setCapabilityFilterFlags(AccountsFilterModel::CapabilityFilterFlags capabilityFilterFlags)
+{
+ if (d->capabilityFilterFlags != capabilityFilterFlags) {
+ d->capabilityFilterFlags = capabilityFilterFlags;
+ invalidateFilter();
+ Q_EMIT capabilityFilterFlagsChanged(capabilityFilterFlags);
}
- else if (type == qMetaTypeId<GroupsModelItem*>()) {
- return filterAcceptsGroup(index);
+}
+
+AccountsFilterModel::SubscriptionStateFilterFlags AccountsFilterModel::subscriptionStateFilterFlags() const
+{
+ return d->subscriptionStateFilterFlags;
+}
+
+void AccountsFilterModel::clearSubscriptionStateFilterFlags()
+{
+ setSubscriptionStateFilterFlags(DoNotFilterBySubscription);
+}
+
+void AccountsFilterModel::setSubscriptionStateFilterFlags(AccountsFilterModel::SubscriptionStateFilterFlags subscriptionStateFilterFlags)
+{
+ if (d->subscriptionStateFilterFlags != subscriptionStateFilterFlags) {
+ d->subscriptionStateFilterFlags = subscriptionStateFilterFlags;
+ invalidateFilter();
+ Q_EMIT subscriptionStateFilterFlagsChanged(subscriptionStateFilterFlags);
}
- else {
- kDebug() << "Unknown type found in Account Filter";
- return true;
+}
+
+QString AccountsFilterModel::globalFilterString() const
+{
+ return d->globalFilterString;
+}
+
+void AccountsFilterModel::clearGlobalFilterString()
+{
+ setGlobalFilterString(QString());
+}
+
+void AccountsFilterModel::setGlobalFilterString(const QString &globalFilterString)
+{
+ if (d->globalFilterString != globalFilterString) {
+ d->globalFilterString = globalFilterString;
+ invalidateFilter();
+ Q_EMIT globalFilterStringChanged(globalFilterString);
}
}
-bool AccountsFilterModel::filterAcceptsAccount(const QModelIndex &index) const
+Qt::MatchFlags AccountsFilterModel::globalFilterMatchFlags() const
{
- bool rowAccepted = true;
- //hide disabled accounts
- if (!index.data(AccountsModel::EnabledRole).toBool()) {
- rowAccepted = false;
+ return d->globalFilterMatchFlags;
+}
+
+void AccountsFilterModel::resetGlobalFilterMatchFlags()
+{
+ setGlobalFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap);
+}
+
+void AccountsFilterModel::setGlobalFilterMatchFlags(Qt::MatchFlags globalFilterMatchFlags)
+{
+ if (d->globalFilterMatchFlags != globalFilterMatchFlags) {
+ d->globalFilterMatchFlags = globalFilterMatchFlags;
+ invalidateFilter();
+ Q_EMIT globalFilterMatchFlagsChanged(globalFilterMatchFlags);
}
- //hide
- if (index.data(AccountsModel::ConnectionStatusRole).toUInt()
- != Tp::ConnectionStatusConnected) {
- rowAccepted = false;
+}
+
+QString AccountsFilterModel::displayNameFilterString() const
+{
+ return d->displayNameFilterString;
+}
+
+void AccountsFilterModel::clearDisplayNameFilterString()
+{
+ setDisplayNameFilterString(QString());
+}
+
+void AccountsFilterModel::setDisplayNameFilterString(const QString &displayNameFilterString)
+{
+ if (d->displayNameFilterString != displayNameFilterString) {
+ d->displayNameFilterString = displayNameFilterString;
+ invalidateFilter();
+ Q_EMIT displayNameFilterStringChanged(displayNameFilterString);
+ }
+}
+
+Qt::MatchFlags AccountsFilterModel::displayNameFilterMatchFlags() const
+{
+ return d->displayNameFilterMatchFlags;
+}
+
+void AccountsFilterModel::resetDisplayNameFilterMatchFlags()
+{
+ setDisplayNameFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap);
+}
+
+void AccountsFilterModel::setDisplayNameFilterMatchFlags(Qt::MatchFlags displayNameFilterMatchFlags)
+{
+ if (d->displayNameFilterMatchFlags != displayNameFilterMatchFlags) {
+ d->displayNameFilterMatchFlags = displayNameFilterMatchFlags;
+ invalidateFilter();
+ Q_EMIT displayNameFilterMatchFlagsChanged(displayNameFilterMatchFlags);
+ }
+}
+
+QString AccountsFilterModel::nicknameFilterString() const
+{
+ return d->nicknameFilterString;
+}
+
+void AccountsFilterModel::clearNicknameFilterString()
+{
+ setNicknameFilterString(QString());
+}
+
+void AccountsFilterModel::setNicknameFilterString(const QString &nicknameFilterString)
+{
+ if (d->nicknameFilterString != nicknameFilterString) {
+ d->nicknameFilterString = nicknameFilterString;
+ invalidateFilter();
+ Q_EMIT nicknameFilterStringChanged(nicknameFilterString);
}
- return rowAccepted;
}
-bool AccountsFilterModel::filterAcceptsContact(const QModelIndex &index) const
+Qt::MatchFlags AccountsFilterModel::nicknameFilterMatchFlags() const
{
- bool rowAccepted = true;
- if (m_filterByName &&
- !index.data(AccountsModel::AliasRole).toString().contains(m_filterString, Qt::CaseInsensitive)) {
- rowAccepted = false;
+ return d->nicknameFilterMatchFlags;
+}
+
+void AccountsFilterModel::resetNicknameFilterMatchFlags()
+{
+ setNicknameFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap);
+}
+
+void AccountsFilterModel::setNicknameFilterMatchFlags(Qt::MatchFlags nicknameFilterMatchFlags)
+{
+ if (d->nicknameFilterMatchFlags != nicknameFilterMatchFlags) {
+ d->nicknameFilterMatchFlags = nicknameFilterMatchFlags;
+ invalidateFilter();
+ Q_EMIT nicknameFilterMatchFlagsChanged(nicknameFilterMatchFlags);
}
+}
+
+QString AccountsFilterModel::aliasFilterString() const
+{
+ return d->aliasFilterString;
+}
+
+void AccountsFilterModel::clearAliasFilterString()
+{
+ setAliasFilterString(QString());
+}
- //check if contact has file-transfer capability
- if (m_filterByFileTransferCapability && !index.data(AccountsModel::FileTransferCapabilityRole).toBool()) {
- rowAccepted = false;
+void AccountsFilterModel::setAliasFilterString(const QString &aliasFilterString)
+{
+ if (d->aliasFilterString != aliasFilterString) {
+ d->aliasFilterString = aliasFilterString;
+ invalidateFilter();
+ Q_EMIT aliasFilterStringChanged(aliasFilterString);
}
+}
+
+Qt::MatchFlags AccountsFilterModel::aliasFilterMatchFlags() const
+{
+ return d->aliasFilterMatchFlags;
+}
+
+void AccountsFilterModel::resetAliasFilterMatchFlags()
+{
+ setAliasFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap);
+}
- //filter offline users out
- if (!m_showOfflineUsers &&
- ((index.data(AccountsModel::PresenceTypeRole).toUInt()
- == Tp::ConnectionPresenceTypeOffline) ||
- (index.data(AccountsModel::PresenceTypeRole).toUInt()
- == Tp::ConnectionPresenceTypeUnknown))) {
- rowAccepted = false;
+void AccountsFilterModel::setAliasFilterMatchFlags(Qt::MatchFlags aliasFilterMatchFlags)
+{
+ if (d->aliasFilterMatchFlags != aliasFilterMatchFlags) {
+ d->aliasFilterMatchFlags = aliasFilterMatchFlags;
+ invalidateFilter();
+ Q_EMIT aliasFilterMatchFlagsChanged(aliasFilterMatchFlags);
}
- return rowAccepted;
}
-bool AccountsFilterModel::filterAcceptsGroup(const QModelIndex &index) const
+QString AccountsFilterModel::groupsFilterString() const
{
- bool acceptRow = true;
- if (!m_showOfflineUsers) {
- if (index.data(AccountsModel::OnlineUsersCountRole).toInt() == 0) {
- acceptRow = false;
- }
+ return d->groupsFilterString;
+}
+
+void AccountsFilterModel::clearGroupsFilterString()
+{
+ setGroupsFilterString(QString());
+}
+
+void AccountsFilterModel::setGroupsFilterString(const QString &groupsFilterString)
+{
+ if (d->groupsFilterString != groupsFilterString) {
+ d->groupsFilterString = groupsFilterString;
+ invalidateFilter();
+ Q_EMIT groupsFilterStringChanged(groupsFilterString);
}
- return acceptRow;
}
-void AccountsFilterModel::setFilterString(const QString &str)
+Qt::MatchFlags AccountsFilterModel::groupsFilterMatchFlags() const
+{
+ return d->groupsFilterMatchFlags;
+}
+
+void AccountsFilterModel::resetGroupsFilterMatchFlags()
{
- m_filterString = str;
- m_filterByName = true;
- invalidateFilter();
+ setGroupsFilterMatchFlags(Qt::MatchStartsWith | Qt::MatchWrap);
}
-void AccountsFilterModel::clearFilterStringAndHideOfflineUsers(const bool &showOfflineUsers)
+void AccountsFilterModel::setGroupsFilterMatchFlags(Qt::MatchFlags groupsFilterMatchFlags)
{
- m_showOfflineUsers = showOfflineUsers;
- clearFilterString();
+ if (d->groupsFilterMatchFlags != groupsFilterMatchFlags) {
+ d->groupsFilterMatchFlags = groupsFilterMatchFlags;
+ invalidateFilter();
+ Q_EMIT groupsFilterMatchFlagsChanged(groupsFilterMatchFlags);
+ }
}
-void AccountsFilterModel::clearFilterString()
+bool AccountsFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
- m_filterString.clear();
- m_filterByName = false;
- invalidateFilter();
+ QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
+
+ int type = index.data(AccountsModel::ItemRole).userType();
+ if (type == qMetaTypeId<ContactModelItem*>()) {
+ return d->filterAcceptsContact(index);
+ }
+ else if (type == qMetaTypeId<AccountsModelItem*>()) {
+ return d->filterAcceptsAccount(index);
+ }
+ else if (type == qMetaTypeId<GroupsModelItem*>()) {
+ return d->filterAcceptsGroup(index);
+ }
+ else {
+ kDebug() << "Unknown type found in Account Filter";
+ return true;
+ }
}
bool AccountsFilterModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
{
- Tp::ConnectionPresenceType leftPresence;
- Tp::ConnectionPresenceType rightPresence;
QString leftDisplayedName = sourceModel()->data(left).toString();
QString rightDisplayedName = sourceModel()->data(right).toString();
- if (sortRole() == AccountsModel::PresenceTypeRole) {
- leftPresence = (Tp::ConnectionPresenceType)sourceModel()->data(left, AccountsModel::PresenceTypeRole).toUInt();
- rightPresence = (Tp::ConnectionPresenceType)sourceModel()->data(right, AccountsModel::PresenceTypeRole).toUInt();
+ switch (sortRole()) {
+ case AccountsModel::PresenceTypeRole:
+ {
+ Tp::ConnectionPresenceType leftPresence = (Tp::ConnectionPresenceType)sourceModel()->data(left, AccountsModel::PresenceTypeRole).toUInt();
+ Tp::ConnectionPresenceType rightPresence = (Tp::ConnectionPresenceType)sourceModel()->data(right, AccountsModel::PresenceTypeRole).toUInt();
if (leftPresence == rightPresence) {
return QString::localeAwareCompare(leftDisplayedName, rightDisplayedName) < 0;
@@ -173,23 +659,82 @@ bool AccountsFilterModel::lessThan(const QModelIndex &left, const QModelIndex &r
return KTp::Presence::sortPriority(leftPresence) < KTp::Presence::sortPriority(rightPresence);
}
- } else {
+ }
+ case AccountsModel::NicknameRole:
+ {
+ QString leftNickname = sourceModel()->data(left, AccountsModel::NicknameRole).toString();
+ QString rightNickName = sourceModel()->data(right, AccountsModel::NicknameRole).toString();
+ return QString::localeAwareCompare(leftNickname, rightNickName) < 0;
+ }
+ case AccountsModel::AliasRole:
+ {
+ QString leftAlias = sourceModel()->data(left, AccountsModel::AliasRole).toString();
+ QString rightAlias = sourceModel()->data(right, AccountsModel::AliasRole).toString();
+ return QString::localeAwareCompare(rightAlias, rightAlias) < 0;
+ }
+ case Qt::DisplayRole:
+ default:
return QString::localeAwareCompare(leftDisplayedName, rightDisplayedName) < 0;
}
}
-void AccountsFilterModel::setSortByPresence(bool enabled)
+
+QModelIndexList AccountsFilterModel::match(const QModelIndex &start, int role,
+ const QVariant &value, int hits,
+ Qt::MatchFlags flags) const
{
- if (enabled) {
- setSortRole(AccountsModel::PresenceTypeRole);
- } else {
- setSortRole(Qt::DisplayRole);
+ if (!start.isValid()) {
+ return QModelIndexList();
}
-}
-bool AccountsFilterModel::isSortedByPresence() const
-{
- return sortRole() == AccountsModel::PresenceTypeRole;
+ QModelIndexList result;
+ uint matchType = flags & 0x0F;
+ Qt::CaseSensitivity cs = flags & Qt::MatchCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
+ bool recurse = flags & Qt::MatchRecursive;
+ bool allHits = (hits == -1);
+ QString text; // only convert to a string if it is needed
+ QVariant v = start.data(role);
+ // QVariant based matching
+ if (matchType == Qt::MatchExactly) {
+ if (value == v)
+ result.append(start);
+ } else { // QString based matching
+ if (text.isEmpty()) // lazy conversion
+ text = value.toString();
+ QString t = v.toString();
+ switch (matchType) {
+ case Qt::MatchRegExp:
+ if (QRegExp(text, cs).exactMatch(t))
+ result.append(start);
+ break;
+ case Qt::MatchWildcard:
+ if (QRegExp(text, cs, QRegExp::Wildcard).exactMatch(t))
+ result.append(start);
+ break;
+ case Qt::MatchStartsWith:
+ if (t.startsWith(text, cs))
+ result.append(start);
+ break;
+ case Qt::MatchEndsWith:
+ if (t.endsWith(text, cs))
+ result.append(start);
+ break;
+ case Qt::MatchFixedString:
+ if (t.compare(text, cs) == 0)
+ result.append(start);
+ break;
+ case Qt::MatchContains:
+ default:
+ if (t.contains(text, cs))
+ result.append(start);
+ }
+ }
+ if (recurse && hasChildren(start)) { // search the hierarchy
+ result += match(index(0, start.column(), start), role,
+ (text.isEmpty() ? value : text),
+ (allHits ? -1 : hits - result.count()), flags);
+ }
+ return result;
}
diff --git a/KTp/Models/accounts-filter-model.h b/KTp/Models/accounts-filter-model.h
index 36f8288..c23b284 100644
--- a/KTp/Models/accounts-filter-model.h
+++ b/KTp/Models/accounts-filter-model.h
@@ -2,6 +2,7 @@
* Provide some filters on the account model
*
* Copyright (C) 2011 David Edmundson <kde at davidedmundson.co.uk>
+ * Copyright (C) 2012 Daniele E. Domenichelli <daniele.domenichelli at gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -30,63 +31,241 @@ class ContactModelItem;
/**
* rief Class used to sort and filter the contacts.
- *
- * Filters:
- * Hide offline contacts
- * Hide contacts not matching a string in the search bar
- * Sort contacts:
- * By name
- * By presence
*/
class KTP_EXPORT AccountsFilterModel : public QSortFilterProxyModel
{
Q_OBJECT
+ Q_DISABLE_COPY(AccountsFilterModel)
+
+ Q_ENUMS(SortMode
+ PresenceFilterFlag
+ CapabilityFilterFlag
+ SubscriptionStateFilterFlag)
+
+ Q_FLAGS(PresenceFilterFlags
+ CapabilityFilterFlags
+ SubscriptionStateFilterFlags)
+
+ Q_PROPERTY(SortMode sortMode
+ READ sortMode
+ WRITE setSortMode
+ NOTIFY sortModeChanged)
+
+ Q_PROPERTY(PresenceTypeFilterFlags presenceTypeFilterFlags
+ READ presenceTypeFilterFlags
+ RESET clearPresenceTypeFilterFlags
+ WRITE setPresenceTypeFilterFlags
+ NOTIFY presenceTypeFilterFlagsChanged)
+
+ Q_PROPERTY(CapabilityFilterFlags capabilityFilterFlags
+ READ capabilityFilterFlags
+ RESET clearCapabilityFilterFlags
+ WRITE setCapabilityFilterFlags
+ NOTIFY capabilityFilterFlagsChanged)
+
+ // FIXME This resumes Subscription state, Publish state and blocking state, perhaps we should find a better name
+ Q_PROPERTY(SubscriptionStateFilterFlags subscriptionStateFilterFlags
+ READ subscriptionStateFilterFlags
+ RESET clearSubscriptionStateFilterFlags
+ WRITE setSubscriptionStateFilterFlags
+ NOTIFY subscriptionStateFilterFlagsChanged)
+
+ // Filters on all fields
+ Q_PROPERTY(QString globalFilterString
+ READ globalFilterString
+ RESET clearGlobalFilterString
+ WRITE setGlobalFilterString
+ NOTIFY globalFilterStringChanged)
+ Q_PROPERTY(Qt::MatchFlags globalFilterMatchFlags
+ READ globalFilterMatchFlags
+ RESET resetGlobalFilterMatchFlags
+ WRITE setGlobalFilterMatchFlags
+ NOTIFY globalFilterMatchFlagsChanged)
+
+ Q_PROPERTY(QString displayNameFilterString
+ READ displayNameFilterString
+ RESET clearDisplayNameFilterString
+ WRITE setDisplayNameFilterString
+ NOTIFY displayNameFilterStringChanged)
+ Q_PROPERTY(QString nicknameFilterString
+ READ nicknameFilterString
+ RESET clearNicknameFilterString
+ WRITE setNicknameFilterString
+ NOTIFY nicknameFilterStringChanged)
+ Q_PROPERTY(QString aliasFilterString
+ READ aliasFilterString
+ RESET clearAliasFilterString
+ WRITE setAliasFilterString
+ NOTIFY aliasFilterStringChanged)
+ Q_PROPERTY(QString groupsFilterString
+ READ groupsFilterString
+ RESET clearGroupsFilterString
+ WRITE setGroupsFilterString
+ NOTIFY groupsFilterStringChanged)
+ Q_PROPERTY(Qt::MatchFlags displayNameFilterMatchFlags
+ READ displayNameFilterMatchFlags
+ RESET resetDisplayNameFilterMatchFlags
+ WRITE setDisplayNameFilterMatchFlags
+ NOTIFY displayNameFilterMatchFlagsChanged)
+ Q_PROPERTY(Qt::MatchFlags nicknameFilterMatchFlags
+ READ nicknameFilterMatchFlags
+ RESET resetNicknameFilterMatchFlags
+ WRITE setNicknameFilterMatchFlags
+ NOTIFY nicknameFilterMatchFlagsChanged)
+ Q_PROPERTY(Qt::MatchFlags aliasFilterMatchFlags
+ READ aliasFilterMatchFlags
+ RESET resetAliasFilterMatchFlags
+ WRITE setAliasFilterMatchFlags
+ NOTIFY aliasFilterMatchFlagsChanged)
+ Q_PROPERTY(Qt::MatchFlags groupsFilterMatchFlags
+ READ groupsFilterMatchFlags
+ RESET resetGroupsFilterMatchFlags
+ WRITE setGroupsFilterMatchFlags
+ NOTIFY groupsFilterMatchFlagsChanged)
public:
+ enum SortMode {
+ DoNotSort = 0,
+ SortByPresence,
+ SortByNickname,
+ SortByAlias
+ };
+
+ enum PresenceTypeFilterFlag {
+ DoNotFilterByPresence = 0x0000,
+ HidePresenceTypeUnset = 0x0001,
+ HidePresenceTypeOffline = 0x0002,
+ HidePresenceTypeAvailable = 0x0004,
+ HidePresenceTypeAway = 0x0008,
+ HidePresenceTypeExtendedAway = 0x0010,
+ HidePresenceTypeHidden = 0x0020,
+ HidePresenceTypeBusy = 0x0040,
+ HidePresenceTypeUnknown = 0x0080,
+ HidePresenceTypeError = 0x0100,
+ HideAllOffline = HidePresenceTypeUnset |
+ HidePresenceTypeOffline |
+ HidePresenceTypeUnknown |
+ HidePresenceTypeError,
+ HideAllOnline = HidePresenceTypeAvailable |
+ HidePresenceTypeAway |
+ HidePresenceTypeExtendedAway |
+ HidePresenceTypeHidden |
+ HidePresenceTypeBusy,
+ HideAllUnavailable = HideAllOffline |
+ HidePresenceTypeAway |
+ HidePresenceTypeExtendedAway |
+ HidePresenceTypeBusy,
+ ShowOnlyConnected = HideAllOffline,
+ ShowOnlyDisconnected = HideAllOnline,
+ ShowAll = DoNotFilterByPresence
+ };
+ Q_DECLARE_FLAGS(PresenceTypeFilterFlags, PresenceTypeFilterFlag)
+
+ enum CapabilityFilterFlag {
+ DoNotFilterByCapability = 0x0000,
+ FilterByTextChatCapability = 0x0001,
+ FilterByMediaCallCapability = 0x0002,
+ FilterByAudioCallCapability = 0x0004,
+ FilterByVideoCallCapability = 0x0008,
+ FilterByFileTransferCapability = 0x0010,
+ FilterByDesktopSharingCapability = 0x0020,
+
+ CustomFilterCapability = 0x10000 // a placemark for custom capabilities in inherited classes
+ };
+ Q_DECLARE_FLAGS(CapabilityFilterFlags, CapabilityFilterFlag)
+
+ enum SubscriptionStateFilterFlag {
+ DoNotFilterBySubscription = 0x0000,
+ HideSubscriptionStateNo = 0x0001,
+ HideSubscriptionStateAsk = 0x0002,
+ HideSubscriptionStateYes = 0x0004,
+ HidePublishStateNo = 0x0010,
+ HidePublishStateAsk = 0x0020,
+ HidePublishStateYes = 0x0040,
+ HideBlocked = 0x0100,
+ HideNonBlocked = 0x0200,
+ ShowOnlyBlocked = HideNonBlocked
+ };
+ Q_DECLARE_FLAGS(SubscriptionStateFilterFlags, SubscriptionStateFilterFlag)
+
AccountsFilterModel(QObject *parent = 0);
+ virtual ~AccountsFilterModel();
- bool showOfflineUsers() const;
-
- /**
- * rief Flag to sort the contactlist by presence.
- *
- * If set to false, the contact list is only sorted by name.
- */
- bool isSortedByPresence() const;
-
-public Q_SLOTS:
- void setShowOfflineUsers(bool showOfflineUsers);
- void setFilterByFileTransferCapability(bool filterByFileTransferCapability);
- void setFilterString(const QString &str);
- /// This overloaded method takes into account showing/hiding offline users
- void clearFilterStringAndHideOfflineUsers(const bool& showOfflineUsers);
- void clearFilterString();
- /**
- * rief Lets the proxy know whether the model should get sorted by presence or not.
- *
- * \param enabled if true, the model will get sorted by presence, otherwise just by name.
- */
- void setSortByPresence(bool enabled);
+ SortMode sortMode() const;
+ void resetSortMode();
+ Q_SLOT void setSortMode(SortMode sortMode);
+ Q_SIGNAL void sortModeChanged(SortMode sortMode);
-protected:
- bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const;
- bool lessThan ( const QModelIndex &left, const QModelIndex &right ) const;
+ PresenceTypeFilterFlags presenceTypeFilterFlags() const;
+ Q_SLOT void clearPresenceTypeFilterFlags();
+ Q_SLOT void setPresenceTypeFilterFlags(PresenceTypeFilterFlags presenceTypeFilterFlags);
+ Q_SIGNAL void presenceTypeFilterFlagsChanged(PresenceTypeFilterFlags presenceTypeFilterFlags);
-private:
+ CapabilityFilterFlags capabilityFilterFlags() const;
+ Q_SLOT void clearCapabilityFilterFlags();
+ Q_SLOT void setCapabilityFilterFlags(CapabilityFilterFlags capabilityFilterFlags);
+ Q_SIGNAL void capabilityFilterFlagsChanged(CapabilityFilterFlags capabilityFilterFlags);
+
+ SubscriptionStateFilterFlags subscriptionStateFilterFlags() const;
+ Q_SLOT void clearSubscriptionStateFilterFlags();
+ Q_SLOT void setSubscriptionStateFilterFlags(SubscriptionStateFilterFlags subscriptionStateFilterFlags);
+ Q_SIGNAL void subscriptionStateFilterFlagsChanged(SubscriptionStateFilterFlags subscriptionStateFilterFlags);
+
+ QString globalFilterString() const;
+ Q_SLOT void clearGlobalFilterString();
+ Q_SLOT void setGlobalFilterString(const QString &globalFilterString);
+ Q_SIGNAL void globalFilterStringChanged(const QString &globalFilterString);
+ Qt::MatchFlags globalFilterMatchFlags() const;
+ Q_SLOT void resetGlobalFilterMatchFlags();
+ Q_SLOT void setGlobalFilterMatchFlags(Qt::MatchFlags globalStringMatchFlags);
+ Q_SIGNAL void globalFilterMatchFlagsChanged(Qt::MatchFlags globalStringMatchFlags);
- bool filterAcceptsAccount(const QModelIndex &index) const;
- bool filterAcceptsContact(const QModelIndex &index) const;
- bool filterAcceptsGroup(const QModelIndex &index) const;
+ QString displayNameFilterString() const;
+ Q_SLOT void clearDisplayNameFilterString();
+ Q_SLOT void setDisplayNameFilterString(const QString &displayNameFilterString);
+ Q_SIGNAL void displayNameFilterStringChanged(const QString &displayNameFilterString);
+ Qt::MatchFlags displayNameFilterMatchFlags() const;
+ Q_SLOT void resetDisplayNameFilterMatchFlags();
+ Q_SLOT void setDisplayNameFilterMatchFlags(Qt::MatchFlags displayNameFilterMatchFlags);
+ Q_SIGNAL void displayNameFilterMatchFlagsChanged(Qt::MatchFlags displayNameFilterMatchFlags);
- /// Shows offline users
- bool m_showOfflineUsers;
+ QString nicknameFilterString() const;
+ Q_SLOT void clearNicknameFilterString();
+ Q_SLOT void setNicknameFilterString(const QString &nicknameFilterString);
+ Q_SIGNAL void nicknameFilterStringChanged(const QString &nicknameFilterString);
+ Qt::MatchFlags nicknameFilterMatchFlags() const;
+ Q_SLOT void resetNicknameFilterMatchFlags();
+ Q_SLOT void setNicknameFilterMatchFlags(Qt::MatchFlags nicknameFilterMatchFlags);
+ Q_SIGNAL void nicknameFilterMatchFlagsChanged(Qt::MatchFlags nicknameFilterMatchFlags);
- /// Used when searching for contact
- bool m_filterByName;
- bool m_filterByFileTransferCapability;
+ QString aliasFilterString() const;
+ Q_SLOT void clearAliasFilterString();
+ Q_SLOT void setAliasFilterString(const QString &aliasFilterString);
+ Q_SIGNAL void aliasFilterStringChanged(const QString &aliasFilterString);
+ Qt::MatchFlags aliasFilterMatchFlags() const;
+ Q_SLOT void resetAliasFilterMatchFlags();
+ Q_SLOT void setAliasFilterMatchFlags(Qt::MatchFlags aliasFilterMatchFlags);
+ Q_SIGNAL void aliasFilterMatchFlagsChanged(Qt::MatchFlags aliasFilterMatchFlags);
- /// Holds the string which is searched in the model
- QString m_filterString;
+ QString groupsFilterString() const;
+ Q_SLOT void clearGroupsFilterString();
+ Q_SLOT void setGroupsFilterString(const QString &groupsFilterString);
+ Q_SIGNAL void groupsFilterStringChanged(const QString &groupsFilterString);
+ Qt::MatchFlags groupsFilterMatchFlags() const;
+ Q_SLOT void resetGroupsFilterMatchFlags();
+ Q_SLOT void setGroupsFilterMatchFlags(Qt::MatchFlags groupsFilterMatchFlags);
+ Q_SIGNAL void groupsFilterMatchFlagsChanged(Qt::MatchFlags groupsFilterMatchFlags);
+
+protected:
+ bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const;
+ bool lessThan ( const QModelIndex &left, const QModelIndex &right ) const;
+QModelIndexList match(const QModelIndex &start, int role,
+ const QVariant &value, int hits,
+ Qt::MatchFlags flags) const;
+
+private:
+ class Private;
+ Private * const d;
};
#endif // ACCOUNTFILTERMODEL_H
--
ktp-common-internals packaging
More information about the pkg-kde-commits
mailing list