MenuProxyModel::MenuProxyModel( QObject * parent )
: KCategorizedSortFilterProxyModel( parent )
{
setSortRole( MenuModel::UserSortRole );
setFilterRole( MenuModel::UserFilterRole );
setFilterCaseSensitivity( Qt::CaseInsensitive );
}
QmlProfilerStatisticsMainView::QmlProfilerStatisticsMainView(QmlProfilerStatisticsModel *model) :
m_model(model)
{
setViewDefaults(this);
setObjectName(QLatin1String("QmlProfilerEventsTable"));
auto sortModel = new QSortFilterProxyModel(this);
sortModel->setSourceModel(model);
sortModel->setSortRole(SortRole);
sortModel->setSortCaseSensitivity(Qt::CaseInsensitive);
sortModel->setFilterRole(FilterRole);
sortModel->setFilterKeyColumn(MainType);
sortModel->setFilterFixedString("+");
setModel(sortModel);
connect(this, &QAbstractItemView::activated, this, [this](const QModelIndex &index) {
jumpToItem(index.data(TypeIdRole).toInt());
});
setSortingEnabled(true);
sortByColumn(DEFAULT_SORT_COLUMN, Qt::DescendingOrder);
setShowExtendedStatistics(m_showExtendedStatistics);
setRootIsDecorated(false);
resizeColumnToContents(MainLocation);
resizeColumnToContents(MainType);
}
HistoryModel::HistoryModel(const QString &path, QObject *parent) : QStandardItemModel(parent)
{
QFile file(path);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
Console::addMessage(tr("Failed to open history file: %1").arg(file.errorString()), Console::OtherCategory, Console::ErrorLevel, path);
return;
}
const QJsonArray array(QJsonDocument::fromJson(file.readAll()).array());
file.close();
for (int i = 0; i < array.count(); ++i)
{
const QJsonObject object(array.at(i).toObject());
addEntry(QUrl(object.value(QLatin1String("url")).toString()), object.value(QLatin1String("title")).toString(), QIcon(), QDateTime::fromString(object.value(QLatin1String("time")).toString(), QLatin1String("yyyy-MM-dd hh:mm:ss")));
}
setSortRole(TimeVisitedRole);
sort(0, Qt::DescendingOrder);
}
streamDirectoryProxyModel::streamDirectoryProxyModel(streamDirectoryModel *parent)
: QSortFilterProxyModel(parent)
{
setDynamicSortFilter(true);
setSortCaseSensitivity(Qt::CaseInsensitive);
setSortRole(Qt::UserRole);
QSortFilterProxyModel::setSourceModel(parent);
}
QgsBrowserProxyModel::QgsBrowserProxyModel( QObject *parent )
: QSortFilterProxyModel( parent )
{
setDynamicSortFilter( true );
setSortRole( QgsBrowserModel::SortRole );
setSortCaseSensitivity( Qt::CaseInsensitive );
sort( 0 );
}
/******************************************************************************************
* NickViewFilter
******************************************************************************************/
NickViewFilter::NickViewFilter(const BufferId &bufferId, NetworkModel *parent)
: QSortFilterProxyModel(parent),
_bufferId(bufferId)
{
setSourceModel(parent);
setDynamicSortFilter(true);
setSortCaseSensitivity(Qt::CaseInsensitive);
setSortRole(TreeModel::SortRole);
}
QgsAttributeTableFilterModel::QgsAttributeTableFilterModel( QgsMapCanvas *canvas, QgsAttributeTableModel *sourceModel, QObject *parent )
: QSortFilterProxyModel( parent )
, mCanvas( canvas )
{
setSourceModel( sourceModel );
setDynamicSortFilter( true );
setSortRole( QgsAttributeTableModel::SortRole );
connect( layer(), &QgsVectorLayer::selectionChanged, this, &QgsAttributeTableFilterModel::selectionChanged );
}
DevicesSortProxyModel::DevicesSortProxyModel(DevicesModel* devicesModel)
: QSortFilterProxyModel(devicesModel)
{
setSourceModel(devicesModel);
setSortRole(DevicesModel::StatusModelRole);
connect(devicesModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(sourceDataChanged(QModelIndex,QModelIndex)));
sort(0);
}
UsersModel::UsersModel(QObject* parent)
: UnitySortFilterProxyModelQML(parent)
{
setModel(new MangleModel(this));
setSortCaseSensitivity(Qt::CaseInsensitive);
setSortLocaleAware(true);
setSortRole(QLightDM::UsersModel::RealNameRole);
sort(0);
}
void SortFilterModel::setModel(QObject *model)
{
QAbstractItemModel* tmpModel = qobject_cast<QAbstractItemModel*>(model);
if (tmpModel == NULL)
return;
setSourceModel(tmpModel);
setSortRole(m_sortRole);
setFilterRole(m_filterRole);
}
CallHistoryStructModel::CallHistoryStructModel(IPhoneManager *APhoneManager, QObject *AParent) : AdvancedItemModel(AParent)
{
FPhoneManager = APhoneManager;
connect(FPhoneManager->instance(),SIGNAL(callHistoryRequestFailed(const QString &, const XmppError &)),
SLOT(onCallHistoryRequestFailed(const QString &, const XmppError &)));
connect(FPhoneManager->instance(),SIGNAL(callHistoryItemsLoaded(const QString &, const QList<IPhoneCallHistoryItem> &)),
SLOT(onCallHistoryItemsLoaded(const QString &, const QList<IPhoneCallHistoryItem> &)));
setColumnCount(1);
setSortRole(RoleSort);
}
QgsAttributeTableFilterModel::QgsAttributeTableFilterModel( QgsMapCanvas* canvas, QgsAttributeTableModel* sourceModel, QObject* parent )
: QSortFilterProxyModel( parent )
, mCanvas( canvas )
, mFilterMode( ShowAll )
, mSelectedOnTop( false )
{
setSourceModel( sourceModel );
setDynamicSortFilter( true );
setSortRole( QgsAttributeTableModel::SortRole );
connect( layer(), SIGNAL( selectionChanged() ), SLOT( selectionChanged() ) );
}
GamesProxyModel::GamesProxyModel(QObject *parent, ServerInfo_User *_ownUser)
: QSortFilterProxyModel(parent),
ownUser(_ownUser),
unavailableGamesVisible(false),
passwordProtectedGamesVisible(false),
maxPlayersFilterMin(-1),
maxPlayersFilterMax(-1)
{
setSortRole(GamesModel::SORT_ROLE);
setDynamicSortFilter(true);
}
int QSortFilterProxyModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QAbstractProxyModel::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 20)
qt_static_metacall(this, _c, _id, _a);
_id -= 20;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QRegExp*>(_v) = filterRegExp(); break;
case 1: *reinterpret_cast< int*>(_v) = filterKeyColumn(); break;
case 2: *reinterpret_cast< bool*>(_v) = dynamicSortFilter(); break;
case 3: *reinterpret_cast< Qt::CaseSensitivity*>(_v) = filterCaseSensitivity(); break;
case 4: *reinterpret_cast< Qt::CaseSensitivity*>(_v) = sortCaseSensitivity(); break;
case 5: *reinterpret_cast< bool*>(_v) = isSortLocaleAware(); break;
case 6: *reinterpret_cast< int*>(_v) = sortRole(); break;
case 7: *reinterpret_cast< int*>(_v) = filterRole(); break;
}
_id -= 8;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setFilterRegExp(*reinterpret_cast< QRegExp*>(_v)); break;
case 1: setFilterKeyColumn(*reinterpret_cast< int*>(_v)); break;
case 2: setDynamicSortFilter(*reinterpret_cast< bool*>(_v)); break;
case 3: setFilterCaseSensitivity(*reinterpret_cast< Qt::CaseSensitivity*>(_v)); break;
case 4: setSortCaseSensitivity(*reinterpret_cast< Qt::CaseSensitivity*>(_v)); break;
case 5: setSortLocaleAware(*reinterpret_cast< bool*>(_v)); break;
case 6: setSortRole(*reinterpret_cast< int*>(_v)); break;
case 7: setFilterRole(*reinterpret_cast< int*>(_v)); break;
}
_id -= 8;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 8;
}
#endif // QT_NO_PROPERTIES
return _id;
}
MessagesProxyModel::MessagesProxyModel(QObject *parent)
: QSortFilterProxyModel(parent) {
m_sourceModel = new MessagesModel(this);
setObjectName(QSL("MessagesProxyModel"));
setSortRole(Qt::EditRole);
setSortCaseSensitivity(Qt::CaseInsensitive);
setFilterCaseSensitivity(Qt::CaseInsensitive);
setFilterKeyColumn(-1);
setFilterRole(Qt::EditRole);
setDynamicSortFilter(false);
setSourceModel(m_sourceModel);
}
FChannelListSortProxy::FChannelListSortProxy(QObject *parent) :
QSortFilterProxyModel(parent),
_showType(FChannelSummary::Unknown),
_showEmpty(false)
{
setDynamicSortFilter(true);
setSortRole(FChannelListModel::SortKeyRole);
setFilterRole(FChannelListModel::SortKeyRole);
setFilterKeyColumn(-1);
setSortLocaleAware(true);
setSortCaseSensitivity(Qt::CaseInsensitive);
setFilterCaseSensitivity(Qt::CaseInsensitive);
}
void SortFilterModel::syncRoleNames()
{
if (!sourceModel()) {
return;
}
m_roleIds.clear();
const QHash<int, QByteArray> rNames = roleNames();
for (auto i = rNames.constBegin(); i != rNames.constEnd(); ++i) {
m_roleIds[i.value()] = i.key();
}
setRoleNames(sourceModel()->roleNames());
setFilterRole(m_filterRole);
setSortRole(m_sortRole);
}
KRunnerModel::KRunnerModel(QObject *parent)
: QStandardItemModel(parent)
, d(new Private())
{
connect(runnerManager(),
SIGNAL(matchesChanged(QList<Plasma::QueryMatch>)),
this,
SLOT(matchesChanged(QList<Plasma::QueryMatch>)));
QHash<int, QByteArray> newRoleNames = roleNames();
newRoleNames[CommonModel::Description] = "description";
newRoleNames[CommonModel::Url] = "url";
newRoleNames[CommonModel::Weight] = "weight";
newRoleNames[CommonModel::ActionTypeRole] = "action";
setRoleNames(newRoleNames);
setSortRole(CommonModel::Weight);
}
int QStandardItemModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QAbstractItemModel::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
*reinterpret_cast< int*>(_v) = sortRole();
break;
}
_id -= 1;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
setSortRole(*reinterpret_cast< int*>(_v));
break;
}
_id -= 1;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 1;
}
#endif // QT_NO_PROPERTIES
return _id;
}
QmlProfilerStatisticsRelativesView::QmlProfilerStatisticsRelativesView(
QmlProfilerStatisticsRelativesModel *model) :
m_model(model)
{
setViewDefaults(this);
auto sortModel = new QSortFilterProxyModel(this);
sortModel->setSourceModel(model);
sortModel->setSortRole(SortRole);
sortModel->setSortCaseSensitivity(Qt::CaseInsensitive);
setModel(sortModel);
setRootIsDecorated(false);
setSortingEnabled(true);
sortByColumn(DEFAULT_SORT_COLUMN, Qt::DescendingOrder);
connect(this, &QAbstractItemView::activated, this, [this](const QModelIndex &index) {
jumpToItem(index.data(TypeIdRole).toInt());
});
}
void DwarfModelProxy::sort(int column, DWARF_SORT_ROLE role) {
Qt::SortOrder order;
if (column == 0) {
switch(role) {
case DSR_NAME_ASC:
order = Qt::AscendingOrder;
setSortRole(Qt::DisplayRole);
break;
case DSR_NAME_DESC:
order = Qt::DescendingOrder;
setSortRole(Qt::DisplayRole);
break;
case DSR_ID_ASC:
order = Qt::AscendingOrder;
setSortRole(DwarfModel::DR_ID);
break;
case DSR_ID_DESC:
order = Qt::DescendingOrder;
setSortRole(DwarfModel::DR_ID);
break;
case DSR_GAME_ORDER:
order = Qt::AscendingOrder;
setSortRole(DwarfModel::DR_SORT_VALUE);
break;
}
} else {
switch(role) {
case DSR_NAME_ASC:
order = Qt::AscendingOrder;
break;
case DSR_NAME_DESC:
order = Qt::DescendingOrder;
break;
}
setSortRole(DwarfModel::DR_SORT_VALUE);
}
setFilterCaseSensitivity(Qt::CaseInsensitive);
setSortLocaleAware(true);
QSortFilterProxyModel::sort(column, order);
}
void QgsPluginSortFilterProxyModel::sortPluginsByStatus()
{
setAcceptedSpacers( "status" );
sort( 0, Qt::DescendingOrder );
setSortRole( PLUGIN_STATUS_ROLE );
}
void QgsPluginSortFilterProxyModel::sortPluginsByVote()
{
setAcceptedSpacers();
sort( 0, Qt::DescendingOrder );
setSortRole( PLUGIN_VOTE_ROLE );
}
void QgsPluginSortFilterProxyModel::sortPluginsByDownloads()
{
setAcceptedSpacers();
sort( 0, Qt::DescendingOrder );
setSortRole( PLUGIN_DOWNLOADS_ROLE );
}
void QgsPluginSortFilterProxyModel::sortPluginsByName()
{
setAcceptedSpacers();
sort( 0, Qt::AscendingOrder );
setSortRole( Qt::DisplayRole );
}
void SongsProxyModel::sortByDate()
{
setSortRole(Song::DateRole);
sort(0, Qt::DescendingOrder);
}
GamesListSortFilterProxyModel::GamesListSortFilterProxyModel(QObject * parent) :
QSortFilterProxyModel(parent), watches(false)
{
setSortCaseSensitivity(Qt::CaseInsensitive);
setSortRole(LIST_SORT_ROLE);
}
InfoKcmProxyModel::InfoKcmProxyModel(QObject *parent) : QSortFilterProxyModel(parent)
{
setSortRole(Qt::UserRole);
}
BedItemModel::BedItemModel(QObject* p)
: StandardItemModel(p),
_profile(0),
_currentBed(0) {
setSortRole(Qt::UserRole);
}
QgsGCPListModel::QgsGCPListModel( QObject *parent )
: QStandardItemModel( parent )
{
// Use data provided by Qt::UserRole as sorting key (needed for numerical sorting).
setSortRole( Qt::UserRole );
}
