1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove QRegExp support from QSortFilterProxyModel

Browse Source 
Map setFilterWildcard() and setFilterFixedString() to now use
QRegularExpression.

Change-Id: I2dff2015234decb2badfd306975dcff8553cdd7f
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>
This commit is contained in:
Lars Knoll 2020-04-02 14:21:50 +02:00
parent 48794f5057
commit eb349930ee
11 changed files with 35 additions and 363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/corelib/doc/snippets/qsortfilterproxymodel-details/main.cpp
View File

@ -94,8 +94,7 @@ Widget::Widget(QWidget *parent)
//! [4] //! [4]
proxyModel->sort(2, Qt::AscendingOrder); proxyModel->sort(2, Qt::AscendingOrder);
//! [4] //! [5] //! [4] //! [5]
proxyModel->setFilterRegExp(QRegExp(".png", Qt::CaseInsensitive, proxyModel->setFilterRegularExpression(QRegularExpression("\.png", QRegularExpression::CaseInsensitiveOption));
QRegExp::FixedString));
proxyModel->setFilterKeyColumn(1); proxyModel->setFilterKeyColumn(1);
//! [5] //! [5]
} }

236
src/corelib/itemmodels/qsortfilterproxymodel.cpp
View File

@ -142,133 +142,6 @@ private:
int end; int end;
}; };
class RegularExpressionData {
private:
enum class ExpressionType {
RegExp,
#if QT_CONFIG(regularexpression)
RegularExpression
#endif
};
public:
RegularExpressionData() :
m_type(ExpressionType::RegExp)
{}
#if QT_CONFIG(regularexpression)
QRegularExpression regularExpression() const
{
if (m_type == ExpressionType::RegularExpression)
return m_regularExpression;
return QRegularExpression();
}
void setRegularExpression(const QRegularExpression &rx)
{
m_type = ExpressionType::RegularExpression;
m_regularExpression = rx;
m_regExp = QRegExp();
}
#endif
QRegExp regExp() const
{
if (m_type == ExpressionType::RegExp)
return m_regExp;
return QRegExp();
}
void setRegExp(const QRegExp &rx)
{
m_type = ExpressionType::RegExp;
m_regExp = rx;
#if QT_CONFIG(regularexpression)
m_regularExpression = QRegularExpression();
#endif
}
bool isEmpty() const
{
bool result = true;
switch (m_type) {
case ExpressionType::RegExp:
result = m_regExp.isEmpty();
break;
#if QT_CONFIG(regularexpression)
case ExpressionType::RegularExpression:
result = m_regularExpression.pattern().isEmpty();
break;
#endif
}
return result;
}
Qt::CaseSensitivity caseSensitivity() const
{
Qt::CaseSensitivity sensitivity = Qt::CaseInsensitive;
switch (m_type) {
case ExpressionType::RegExp:
sensitivity = m_regExp.caseSensitivity();
break;
#if QT_CONFIG(regularexpression)
case ExpressionType::RegularExpression:
{
QRegularExpression::PatternOptions options = m_regularExpression.patternOptions();
if (!(options & QRegularExpression::CaseInsensitiveOption))
sensitivity = Qt::CaseSensitive;
}
break;
#endif
}
return sensitivity;
}
void setCaseSensitivity(Qt::CaseSensitivity cs)
{
switch (m_type) {
case ExpressionType::RegExp:
m_regExp.setCaseSensitivity(cs);
break;
#if QT_CONFIG(regularexpression)
case ExpressionType::RegularExpression:
{
QRegularExpression::PatternOptions options = m_regularExpression.patternOptions();
options.setFlag(QRegularExpression::CaseInsensitiveOption, cs == Qt::CaseSensitive);
m_regularExpression.setPatternOptions(options);
}
break;
#endif
}
}
bool hasMatch(const QString &str) const
{
bool result = false;
switch (m_type) {
case ExpressionType::RegExp:
result = str.contains(m_regExp);
break;
#if QT_CONFIG(regularexpression)
case ExpressionType::RegularExpression:
result = str.contains(m_regularExpression);
break;
#endif
}
return result;
}
private:
ExpressionType m_type;
QRegExp m_regExp;
#if QT_CONFIG(regularexpression)
QRegularExpression m_regularExpression;
#endif
};
class QSortFilterProxyModelPrivate : public QAbstractProxyModelPrivate class QSortFilterProxyModelPrivate : public QAbstractProxyModelPrivate
{ {
Q_DECLARE_PUBLIC(QSortFilterProxyModel) Q_DECLARE_PUBLIC(QSortFilterProxyModel)
@ -300,7 +173,7 @@ public:
int filter_column; int filter_column;
int filter_role; int filter_role;
RegularExpressionData filter_data; QRegularExpression filter_data;
QModelIndex last_top_source; QModelIndex last_top_source;
bool filter_recursive; bool filter_recursive;
@ -1271,7 +1144,7 @@ void QSortFilterProxyModelPrivate::update_persistent_indexes(
*/ */
void QSortFilterProxyModelPrivate::filter_about_to_be_changed(const QModelIndex &source_parent) void QSortFilterProxyModelPrivate::filter_about_to_be_changed(const QModelIndex &source_parent)
{ {
if (!filter_data.isEmpty() && if (!filter_data.pattern().isEmpty() &&
source_index_mapping.constFind(source_parent) == source_index_mapping.constEnd()) source_index_mapping.constFind(source_parent) == source_index_mapping.constEnd())
create_mapping(source_parent); create_mapping(source_parent);
} }
@ -1934,9 +1807,9 @@ void QSortFilterProxyModelPrivate::_q_sourceColumnsMoved(
\section1 Filtering \section1 Filtering
In addition to sorting, QSortFilterProxyModel can be used to hide items In addition to sorting, QSortFilterProxyModel can be used to hide items
that do not match a certain filter. The filter is specified using a QRegExp that do not match a certain filter. The filter is specified using a QRegularExpression
object and is applied to the filterRole() (Qt::DisplayRole by default) of object and is applied to the filterRole() (Qt::DisplayRole by default) of
each item, for a given column. The QRegExp object can be used to match a each item, for a given column. The QRegularExpression object can be used to match a
regular expression, a wildcard pattern, or a fixed string. For example: regular expression, a wildcard pattern, or a fixed string. For example:
\snippet qsortfilterproxymodel-details/main.cpp 5 \snippet qsortfilterproxymodel-details/main.cpp 5
@ -1985,21 +1858,6 @@ void QSortFilterProxyModelPrivate::_q_sourceColumnsMoved(
\note Some general guidelines for subclassing models are available in the \note Some general guidelines for subclassing models are available in the
\l{Model Subclassing Reference}. \l{Model Subclassing Reference}.
\note With Qt 5, regular expression support has been improved through the
QRegularExpression class. QSortFilterProxyModel dating back prior to that
class creation, it originally supported only QRegExp. Since Qt 5.12,
QRegularExpression APIs have been added. Therefore, QRegExp APIs should be
considered deprecated and the QRegularExpression version should be used in
place.
\warning Don't mix calls to the getters and setters of different regexp types
as this will lead to unexpected results. For maximum compatibility, the original
implementation has been kept. Therefore, if, for example, a call to
setFilterRegularExpression is made followed by another one to
setFilterFixedString, the first call will setup a QRegularExpression object
to use as filter while the second will setup a QRegExp in FixedString mode.
However, this is an implementation detail that might change in the future.
\sa QAbstractProxyModel, QAbstractItemModel, {Model/View Programming}, \sa QAbstractProxyModel, QAbstractItemModel, {Model/View Programming},
{Basic Sort/Filter Model Example}, {Custom Sort/Filter Model Example}, QIdentityProxyModel {Basic Sort/Filter Model Example}, {Custom Sort/Filter Model Example}, QIdentityProxyModel
*/ */
@ -2595,33 +2453,6 @@ Qt::SortOrder QSortFilterProxyModel::sortOrder() const
return d->sort_order; return d->sort_order;
} }
/*!
\property QSortFilterProxyModel::filterRegExp
\brief the QRegExp used to filter the contents of the source model
Setting this property overwrites the current
\l{QSortFilterProxyModel::filterCaseSensitivity}{filterCaseSensitivity}.
By default, the QRegExp is an empty string matching all contents.
If no QRegExp or an empty string is set, everything in the source model
will be accepted.
\sa filterCaseSensitivity, setFilterWildcard(), setFilterFixedString()
*/
QRegExp QSortFilterProxyModel::filterRegExp() const
{
Q_D(const QSortFilterProxyModel);
return d->filter_data.regExp();
}
void QSortFilterProxyModel::setFilterRegExp(const QRegExp &regExp)
{
Q_D(QSortFilterProxyModel);
d->filter_about_to_be_changed();
d->filter_data.setRegExp(regExp);
d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows);
}
#if QT_CONFIG(regularexpression) #if QT_CONFIG(regularexpression)
/*! /*!
\since 5.12 \since 5.12
@ -2640,14 +2471,14 @@ void QSortFilterProxyModel::setFilterRegExp(const QRegExp &regExp)
QRegularExpression QSortFilterProxyModel::filterRegularExpression() const QRegularExpression QSortFilterProxyModel::filterRegularExpression() const
{ {
Q_D(const QSortFilterProxyModel); Q_D(const QSortFilterProxyModel);
return d->filter_data.regularExpression(); return d->filter_data;
} }
void QSortFilterProxyModel::setFilterRegularExpression(const QRegularExpression &regularExpression) void QSortFilterProxyModel::setFilterRegularExpression(const QRegularExpression &regularExpression)
{ {
Q_D(QSortFilterProxyModel); Q_D(QSortFilterProxyModel);
d->filter_about_to_be_changed(); d->filter_about_to_be_changed();
d->filter_data.setRegularExpression(regularExpression); d->filter_data = regularExpression;
d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows); d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows);
} }
#endif #endif
@ -2677,12 +2508,12 @@ void QSortFilterProxyModel::setFilterKeyColumn(int column)
/*! /*!
\property QSortFilterProxyModel::filterCaseSensitivity \property QSortFilterProxyModel::filterCaseSensitivity
\brief the case sensitivity of the QRegExp pattern used to filter the \brief the case sensitivity of the QRegularExpression pattern used to filter the
contents of the source model. contents of the source model.
By default, the filter is case sensitive. By default, the filter is case sensitive.
\sa filterRegExp, sortCaseSensitivity \sa filterRegularExpression, sortCaseSensitivity
*/ */
/*! /*!
@ -2694,16 +2525,20 @@ void QSortFilterProxyModel::setFilterKeyColumn(int column)
Qt::CaseSensitivity QSortFilterProxyModel::filterCaseSensitivity() const Qt::CaseSensitivity QSortFilterProxyModel::filterCaseSensitivity() const
{ {
Q_D(const QSortFilterProxyModel); Q_D(const QSortFilterProxyModel);
return d->filter_data.caseSensitivity(); return d->filter_data.patternOptions() & QRegularExpression::CaseInsensitiveOption ?
Qt::CaseInsensitive : Qt::CaseSensitive;
} }
void QSortFilterProxyModel::setFilterCaseSensitivity(Qt::CaseSensitivity cs) void QSortFilterProxyModel::setFilterCaseSensitivity(Qt::CaseSensitivity cs)
{ {
Q_D(QSortFilterProxyModel); Q_D(QSortFilterProxyModel);
if (cs == d->filter_data.caseSensitivity()) QRegularExpression::PatternOptions o = QRegularExpression::NoPatternOption;
if (cs == Qt::CaseInsensitive)
o = QRegularExpression::CaseInsensitiveOption;
if (o == d->filter_data.patternOptions())
return; return;
d->filter_about_to_be_changed(); d->filter_about_to_be_changed();
d->filter_data.setCaseSensitivity(cs); d->filter_data.setPatternOptions(o);
d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows); d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows);
emit filterCaseSensitivityChanged(cs); emit filterCaseSensitivityChanged(cs);
} }
@ -2774,24 +2609,6 @@ void QSortFilterProxyModel::setSortLocaleAware(bool on)
emit sortLocaleAwareChanged(on); emit sortLocaleAwareChanged(on);
} }
/*!
\overload
Sets the regular expression used to filter the contents
of the source model to \a pattern.
\sa setFilterCaseSensitivity(), setFilterWildcard(), setFilterFixedString(), filterRegExp()
*/
void QSortFilterProxyModel::setFilterRegExp(const QString &pattern)
{
Q_D(QSortFilterProxyModel);
d->filter_about_to_be_changed();
QRegExp rx(pattern);
rx.setCaseSensitivity(d->filter_data.caseSensitivity());
d->filter_data.setRegExp(rx);
d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows);
}
#if QT_CONFIG(regularexpression) #if QT_CONFIG(regularexpression)
/*! /*!
\since 5.12 \since 5.12
@ -2809,7 +2626,7 @@ void QSortFilterProxyModel::setFilterRegularExpression(const QString &pattern)
Q_D(QSortFilterProxyModel); Q_D(QSortFilterProxyModel);
d->filter_about_to_be_changed(); d->filter_about_to_be_changed();
QRegularExpression rx(pattern); QRegularExpression rx(pattern);
d->filter_data.setRegularExpression(rx); d->filter_data.setPattern(pattern);
d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows); d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows);
} }
#endif #endif
@ -2818,14 +2635,14 @@ void QSortFilterProxyModel::setFilterRegularExpression(const QString &pattern)
Sets the wildcard expression used to filter the contents Sets the wildcard expression used to filter the contents
of the source model to the given \a pattern. of the source model to the given \a pattern.
\sa setFilterCaseSensitivity(), setFilterRegExp(), setFilterFixedString(), filterRegExp() \sa setFilterCaseSensitivity(), setFilterRegularExpression(), setFilterFixedString(), filterRegularExpression()
*/ */
void QSortFilterProxyModel::setFilterWildcard(const QString &pattern) void QSortFilterProxyModel::setFilterWildcard(const QString &pattern)
{ {
Q_D(QSortFilterProxyModel); Q_D(QSortFilterProxyModel);
d->filter_about_to_be_changed(); d->filter_about_to_be_changed();
QRegExp rx(pattern, d->filter_data.caseSensitivity(), QRegExp::Wildcard); QString p = QRegularExpression::wildcardToRegularExpression(pattern, QRegularExpression::UnanchoredWildcardConversion);
d->filter_data.setRegExp(rx); d->filter_data.setPattern(p);
d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows); d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows);
} }
@ -2833,14 +2650,13 @@ void QSortFilterProxyModel::setFilterWildcard(const QString &pattern)
Sets the fixed string used to filter the contents Sets the fixed string used to filter the contents
of the source model to the given \a pattern. of the source model to the given \a pattern.
\sa setFilterCaseSensitivity(), setFilterRegExp(), setFilterWildcard(), filterRegExp() \sa setFilterCaseSensitivity(), setFilterRegularExpression(), setFilterWildcard(), filterRegularExpression()
*/ */
void QSortFilterProxyModel::setFilterFixedString(const QString &pattern) void QSortFilterProxyModel::setFilterFixedString(const QString &pattern)
{ {
Q_D(QSortFilterProxyModel); Q_D(QSortFilterProxyModel);
d->filter_about_to_be_changed(); d->filter_about_to_be_changed();
QRegExp rx(pattern, d->filter_data.caseSensitivity(), QRegExp::FixedString); d->filter_data.setPattern(QRegularExpression::escape(pattern));
d->filter_data.setRegExp(rx);
d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows); d->filter_changed(QSortFilterProxyModelPrivate::Direction::Rows);
} }
@ -3130,20 +2946,20 @@ bool QSortFilterProxyModel::lessThan(const QModelIndex &source_left, const QMode
should be accepted or not. This can be changed by setting the should be accepted or not. This can be changed by setting the
\l{QSortFilterProxyModel::filterRole}{filterRole} property. \l{QSortFilterProxyModel::filterRole}{filterRole} property.
\sa filterAcceptsColumn(), setFilterFixedString(), setFilterRegExp(), setFilterWildcard() \sa filterAcceptsColumn(), setFilterFixedString(), setFilterRegularExpression(), setFilterWildcard()
*/ */
bool QSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const bool QSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{ {
Q_D(const QSortFilterProxyModel); Q_D(const QSortFilterProxyModel);
if (d->filter_data.isEmpty()) if (d->filter_data.pattern().isEmpty())
return true; return true;
if (d->filter_column == -1) { if (d->filter_column == -1) {
int column_count = d->model->columnCount(source_parent); int column_count = d->model->columnCount(source_parent);
for (int column = 0; column < column_count; ++column) { for (int column = 0; column < column_count; ++column) {
QModelIndex source_index = d->model->index(source_row, column, source_parent); QModelIndex source_index = d->model->index(source_row, column, source_parent);
QString key = d->model->data(source_index, d->filter_role).toString(); QString key = d->model->data(source_index, d->filter_role).toString();
if (d->filter_data.hasMatch(key)) if (d->filter_data.match(key).hasMatch())
return true; return true;
} }
return false; return false;
@ -3152,7 +2968,7 @@ bool QSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &
if (!source_index.isValid()) // the column may not exist if (!source_index.isValid()) // the column may not exist
return true; return true;
QString key = d->model->data(source_index, d->filter_role).toString(); QString key = d->model->data(source_index, d->filter_role).toString();
return d->filter_data.hasMatch(key); return d->filter_data.match(key).hasMatch();
} }
/*! /*!
@ -3162,7 +2978,7 @@ bool QSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &
\note The default implementation always returns \c true. You must reimplement this \note The default implementation always returns \c true. You must reimplement this
method to get the described behavior. method to get the described behavior.
\sa filterAcceptsRow(), setFilterFixedString(), setFilterRegExp(), setFilterWildcard() \sa filterAcceptsRow(), setFilterFixedString(), setFilterRegularExpression(), setFilterWildcard()
*/ */
bool QSortFilterProxyModel::filterAcceptsColumn(int source_column, const QModelIndex &source_parent) const bool QSortFilterProxyModel::filterAcceptsColumn(int source_column, const QModelIndex &source_parent) const
{ {

6
src/corelib/itemmodels/qsortfilterproxymodel.h
View File

@ -41,7 +41,6 @@
#define QSORTFILTERPROXYMODEL_H #define QSORTFILTERPROXYMODEL_H
#include <QtCore/qabstractproxymodel.h> #include <QtCore/qabstractproxymodel.h>
#include <QtCore/qregexp.h>
#if QT_CONFIG(regularexpression) #if QT_CONFIG(regularexpression)
# include <QtCore/qregularexpression.h> # include <QtCore/qregularexpression.h>
@ -62,7 +61,6 @@ class Q_CORE_EXPORT QSortFilterProxyModel : public QAbstractProxyModel
friend class QSortFilterProxyModelGreaterThan; friend class QSortFilterProxyModelGreaterThan;
Q_OBJECT Q_OBJECT
Q_PROPERTY(QRegExp filterRegExp READ filterRegExp WRITE setFilterRegExp)
#if QT_CONFIG(regularexpression) #if QT_CONFIG(regularexpression)
Q_PROPERTY(QRegularExpression filterRegularExpression READ filterRegularExpression WRITE setFilterRegularExpression) Q_PROPERTY(QRegularExpression filterRegularExpression READ filterRegularExpression WRITE setFilterRegularExpression)
#endif #endif
@ -87,8 +85,6 @@ public:
QItemSelection mapSelectionToSource(const QItemSelection &proxySelection) const override; QItemSelection mapSelectionToSource(const QItemSelection &proxySelection) const override;
QItemSelection mapSelectionFromSource(const QItemSelection &sourceSelection) const override; QItemSelection mapSelectionFromSource(const QItemSelection &sourceSelection) const override;
QRegExp filterRegExp() const;
#if QT_CONFIG(regularexpression) #if QT_CONFIG(regularexpression)
QRegularExpression filterRegularExpression() const; QRegularExpression filterRegularExpression() const;
#endif #endif
@ -121,8 +117,6 @@ public:
void setRecursiveFilteringEnabled(bool recursive); void setRecursiveFilteringEnabled(bool recursive);
public Q_SLOTS: public Q_SLOTS:
void setFilterRegExp(const QString &pattern);
void setFilterRegExp(const QRegExp &regExp);
#if QT_CONFIG(regularexpression) #if QT_CONFIG(regularexpression)
void setFilterRegularExpression(const QString &pattern); void setFilterRegularExpression(const QString &pattern);
void setFilterRegularExpression(const QRegularExpression &regularExpression); void setFilterRegularExpression(const QRegularExpression &regularExpression);

1
tests/auto/corelib/itemmodels/CMakeLists.txt
View File

@ -11,7 +11,6 @@ if(TARGET Qt::Gui)
add_subdirectory(qtransposeproxymodel) add_subdirectory(qtransposeproxymodel)
endif() endif()
if(TARGET Qt::Widgets) if(TARGET Qt::Widgets)
add_subdirectory(qsortfilterproxymodel_regexp)
add_subdirectory(qsortfilterproxymodel_regularexpression) add_subdirectory(qsortfilterproxymodel_regularexpression)
endif() endif()
if(TARGET Qt::Sql AND TARGET Qt::Widgets) if(TARGET Qt::Sql AND TARGET Qt::Widgets)

1
tests/auto/corelib/itemmodels/itemmodels.pro
View File

@ -13,7 +13,6 @@ qtHaveModule(gui): SUBDIRS += \
qtHaveModule(widgets) { qtHaveModule(widgets) {
SUBDIRS += \ SUBDIRS += \
qsortfilterproxymodel_regexp \
qsortfilterproxymodel_regularexpression qsortfilterproxymodel_regularexpression
qtHaveModule(sql): SUBDIRS += \ qtHaveModule(sql): SUBDIRS += \

44
tests/auto/corelib/itemmodels/qsortfilterproxymodel_common/tst_qsortfilterproxymodel.cpp
View File

@ -78,15 +78,7 @@ void tst_QSortFilterProxyModel::cleanupTestCase()
void tst_QSortFilterProxyModel::cleanup() void tst_QSortFilterProxyModel::cleanup()
{ {
switch (m_filterType) { m_proxy->setFilterRegularExpression(QRegularExpression());
case FilterType::RegExp:
m_proxy->setFilterRegExp(QRegExp());
break;
case FilterType::RegularExpression:
m_proxy->setFilterRegularExpression(QRegularExpression());
break;
}
m_proxy->sort(-1, Qt::AscendingOrder); m_proxy->sort(-1, Qt::AscendingOrder);
m_model->clear(); m_model->clear();
m_model->insertColumns(0, 1); m_model->insertColumns(0, 1);
@ -553,7 +545,7 @@ void tst_QSortFilterProxyModel::appendRowFromCombobox()
QSortFilterProxyModel proxy; QSortFilterProxyModel proxy;
proxy.setSourceModel(&model); proxy.setSourceModel(&model);
proxy.setFilterRegExp(pattern); proxy.setFilterRegularExpression(pattern);
QComboBox comboBox; QComboBox comboBox;
comboBox.setModel(&proxy); comboBox.setModel(&proxy);
@ -873,29 +865,16 @@ class MyFilteredColumnProxyModel : public QSortFilterProxyModel
{ {
Q_OBJECT Q_OBJECT
public: public:
MyFilteredColumnProxyModel(FilterType filterType, QObject *parent = nullptr) : MyFilteredColumnProxyModel(QObject *parent = nullptr) :
QSortFilterProxyModel(parent), QSortFilterProxyModel(parent)
m_filterType(filterType)
{ } { }
protected: protected:
bool filterAcceptsColumn(int sourceColumn, const QModelIndex &) const override bool filterAcceptsColumn(int sourceColumn, const QModelIndex &) const override
{ {
QString key = sourceModel()->headerData(sourceColumn, Qt::Horizontal).toString(); QString key = sourceModel()->headerData(sourceColumn, Qt::Horizontal).toString();
bool result = false; return key.contains(filterRegularExpression());
switch (m_filterType) {
case FilterType::RegExp:
result = key.contains(filterRegExp());
break;
case FilterType::RegularExpression:
result = key.contains(filterRegularExpression());
break;
}
return result;
} }
private:
FilterType m_filterType;
}; };
void tst_QSortFilterProxyModel::removeColumns_data() void tst_QSortFilterProxyModel::removeColumns_data()
@ -1104,7 +1083,7 @@ void tst_QSortFilterProxyModel::removeColumns()
QFETCH(QStringList, expectedSource); QFETCH(QStringList, expectedSource);
QStandardItemModel model; QStandardItemModel model;
MyFilteredColumnProxyModel proxy(m_filterType); MyFilteredColumnProxyModel proxy;
proxy.setSourceModel(&model); proxy.setSourceModel(&model);
if (!filter.isEmpty()) if (!filter.isEmpty())
setupFilter(&proxy, filter); setupFilter(&proxy, filter);
@ -1358,14 +1337,7 @@ void tst_QSortFilterProxyModel::checkHierarchy(const QStringList &l, const QAbst
void tst_QSortFilterProxyModel::setupFilter(QSortFilterProxyModel *model, const QString& pattern) void tst_QSortFilterProxyModel::setupFilter(QSortFilterProxyModel *model, const QString& pattern)
{ {
switch (m_filterType) { model->setFilterRegularExpression(pattern);
case FilterType::RegExp:
model->setFilterRegExp(pattern);
break;
case FilterType::RegularExpression:
model->setFilterRegularExpression(pattern);
break;
}
} }
class TestModel: public QAbstractTableModel class TestModel: public QAbstractTableModel
@ -4928,7 +4900,7 @@ void tst_QSortFilterProxyModel::filterAndInsertRow()
model.setStringList(initialModelList); model.setStringList(initialModelList);
proxyModel.setSourceModel(&model); proxyModel.setSourceModel(&model);
proxyModel.setDynamicSortFilter(true); proxyModel.setDynamicSortFilter(true);
proxyModel.setFilterRegExp(filterRegExp); proxyModel.setFilterRegularExpression(filterRegExp);
QVERIFY(proxyModel.insertRow(row)); QVERIFY(proxyModel.insertRow(row));
QCOMPARE(model.stringList(), expectedModelList); QCOMPARE(model.stringList(), expectedModelList);

1
tests/auto/corelib/itemmodels/qsortfilterproxymodel_regexp/.gitignore vendored
View File

@ -1 +0,0 @@
tst_qsortfilterproxymodel_regexp

18
tests/auto/corelib/itemmodels/qsortfilterproxymodel_regexp/CMakeLists.txt
View File

@ -1,18 +0,0 @@
# Generated from qsortfilterproxymodel_regexp.pro.
#####################################################################
## tst_qsortfilterproxymodel_regexp Test:
#####################################################################
add_qt_test(tst_qsortfilterproxymodel_regexp
SOURCES
../../../other/qabstractitemmodelutils/dynamictreemodel.cpp ../../../other/qabstractitemmodelutils/dynamictreemodel.h
../qsortfilterproxymodel_common/tst_qsortfilterproxymodel.cpp ../qsortfilterproxymodel_common/tst_qsortfilterproxymodel.h
tst_qsortfilterproxymodel_regexp.cpp
INCLUDE_DIRECTORIES
../../../other/qabstractitemmodelutils
../qsortfilterproxymodel_common
PUBLIC_LIBRARIES
Qt::Gui
Qt::Widgets
)

16
tests/auto/corelib/itemmodels/qsortfilterproxymodel_regexp/qsortfilterproxymodel_regexp.pro
View File

@ -1,16 +0,0 @@
CONFIG += testcase
TARGET = tst_qsortfilterproxymodel_regexp
QT += widgets testlib
mtdir = ../../../other/qabstractitemmodelutils
qsfpmdir = ../qsortfilterproxymodel_common
INCLUDEPATH += $$PWD/$${mtdir} $$PWD/$${qsfpmdir}
SOURCES += \
tst_qsortfilterproxymodel_regexp.cpp \
$${qsfpmdir}/tst_qsortfilterproxymodel.cpp \
$${mtdir}/dynamictreemodel.cpp
HEADERS += \
$${qsfpmdir}/tst_qsortfilterproxymodel.h \
$${mtdir}/dynamictreemodel.h

69
tests/auto/corelib/itemmodels/qsortfilterproxymodel_regexp/tst_qsortfilterproxymodel_regexp.cpp
View File

@ -1,69 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include "tst_qsortfilterproxymodel.h"
class tst_QSortFilterProxyModelRegExp : public tst_QSortFilterProxyModel
{
Q_OBJECT
public:
tst_QSortFilterProxyModelRegExp();
private slots:
void tst_invalid();
void tst_caseSensitivity();
};
tst_QSortFilterProxyModelRegExp::tst_QSortFilterProxyModelRegExp() :
tst_QSortFilterProxyModel()
{
m_filterType = FilterType::RegExp;
}
void tst_QSortFilterProxyModelRegExp::tst_invalid()
{
const QLatin1String pattern("test");
QSortFilterProxyModel model;
model.setFilterRegExp(pattern);
QCOMPARE(model.filterRegExp(), QRegExp(pattern));
model.setFilterRegularExpression(pattern);
QCOMPARE(model.filterRegExp(), QRegExp());
}
void tst_QSortFilterProxyModelRegExp::tst_caseSensitivity()
{
const QLatin1String pattern("test");
QSortFilterProxyModel model;
model.setFilterCaseSensitivity(Qt::CaseInsensitive);
model.setFilterRegExp(pattern);
QCOMPARE(model.filterCaseSensitivity(), Qt::CaseInsensitive);
}
QTEST_MAIN(tst_QSortFilterProxyModelRegExp)
#include "tst_qsortfilterproxymodel_regexp.moc"

3
tests/auto/corelib/itemmodels/qsortfilterproxymodel_regularexpression/tst_qsortfilterproxymodel_regularexpression.cpp
View File

@ -42,7 +42,6 @@ private slots:
tst_QSortFilterProxyModelRegularExpression::tst_QSortFilterProxyModelRegularExpression() : tst_QSortFilterProxyModelRegularExpression::tst_QSortFilterProxyModelRegularExpression() :
tst_QSortFilterProxyModel() tst_QSortFilterProxyModel()
{ {
m_filterType = FilterType::RegularExpression;
} }
void tst_QSortFilterProxyModelRegularExpression::tst_invalid() void tst_QSortFilterProxyModelRegularExpression::tst_invalid()
@ -51,8 +50,6 @@ void tst_QSortFilterProxyModelRegularExpression::tst_invalid()
QSortFilterProxyModel model; QSortFilterProxyModel model;
model.setFilterRegularExpression(pattern); model.setFilterRegularExpression(pattern);
QCOMPARE(model.filterRegularExpression(), QRegularExpression(pattern)); QCOMPARE(model.filterRegularExpression(), QRegularExpression(pattern));
model.setFilterRegExp(pattern);
QCOMPARE(model.filterRegularExpression(), QRegularExpression());
} }
QTEST_MAIN(tst_QSortFilterProxyModelRegularExpression) QTEST_MAIN(tst_QSortFilterProxyModelRegularExpression)