Qt6 & Qt5 version

.github/workflows/cmake-qt5.yml

@@ -0,0 +1,44 @@
+name: CMake-Qt5
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install Qt
+      uses: jurplel/[email protected]
+      with:
+        cache: 'true'
+        cache-key-prefix: 'install-qt-action'
+        version: '5.15.2'
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Test
+      working-directory: ${{github.workspace}}/build
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest -C ${{env.BUILD_TYPE}}
+

.github/workflows/cmake-qt6.yml

@@ -0,0 +1,44 @@
+name: CMake-Qt6
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install Qt
+      uses: jurplel/[email protected]
+      with:
+        cache: 'true'
+        cache-key-prefix: 'install-qt-action6'
+        version: '6.5.0'
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DQT_VERSION_MAJOR=6
+
+    - name: Build
+      # Build your program with the given configuration
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+
+    - name: Test
+      working-directory: ${{github.workspace}}/build
+      # Execute tests defined by the CMake configuration.
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest -C ${{env.BUILD_TYPE}}
+

CMakeLists.txt

@@ -1,17 +1,22 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.14)
 
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 
-find_package(Qt5 REQUIRED
+if (NOT QT_VERSION_MAJOR)
+    set(QT_VERSION_MAJOR 5)
+endif()
+
+find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS
     Core
     Qml
-    )
+)
 
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_INCLUDE_CURRENT_DIR ON) # This is to find generated *.moc and *.h files in build dir
 
 add_library(SortFilterProxyModel OBJECT
     qqmlsortfilterproxymodel.cpp
+    qvariantlessthan.cpp
     filters/filter.cpp
     filters/filtercontainer.cpp
     filters/rolefilter.cpp
@@ -40,10 +45,22 @@ add_library(SortFilterProxyModel OBJECT
     proxyroles/regexprole.cpp
     sorters/filtersorter.cpp
     proxyroles/filterrole.cpp
-    )
+    utils/utils.cpp
+    utils/utils.h
+)
+
+target_link_libraries(SortFilterProxyModel
+    PRIVATE
+        Qt::Core
+        Qt::Qml
+)
+
+if ((MSVC) AND (MSVC_VERSION GREATER_EQUAL 1914))
+    target_compile_options(SortFilterProxyModel PUBLIC "/Zc:__cplusplus")
+endif()
 
 target_include_directories(SortFilterProxyModel PUBLIC
     ${CMAKE_CURRENT_LIST_DIR}
-    $<TARGET_PROPERTY:Qt5::Core,INTERFACE_INCLUDE_DIRECTORIES>
-    $<TARGET_PROPERTY:Qt5::Qml,INTERFACE_INCLUDE_DIRECTORIES>
-    )
+    $<TARGET_PROPERTY:Qt::Core,INTERFACE_INCLUDE_DIRECTORIES>
+    $<TARGET_PROPERTY:Qt::Qml,INTERFACE_INCLUDE_DIRECTORIES>
+)

README.md

@@ -3,6 +3,9 @@ SortFilterProxyModel
 
 SortFilterProxyModel is an implementation of `QSortFilterProxyModel` conveniently exposed for QML.
 
+This is a fork that combines the Qt6 port of [MenloSystems/SortFilterProxyModel](https://github.com/MenloSystems/SortFilterProxyModel) with a few of my own fixes to compile and run under both Qt 5.15 and 6.5. 
+A github actions workflow compiles the code to make sure it keeps compiling on both versions.
+
 Install
 -------
 ##### With [qpm](https://qpm.io) :

SortFilterProxyModel.pri

@@ -1,8 +1,9 @@
-!contains( CONFIG, c\+\+1[14] ): warning("SortFilterProxyModel needs at least c++11, add CONFIG += c++11 to your .pro")
+!contains( CONFIG, c\+\+1[147] ): warning("SortFilterProxyModel needs at least c++11, add CONFIG += c++11 to your .pro")
 
 INCLUDEPATH += $$PWD
 
 HEADERS += $$PWD/qqmlsortfilterproxymodel.h \
+    $$PWD/qvariantlessthan.h \
     $$PWD/filters/filter.h \
     $$PWD/filters/filtercontainer.h \
     $$PWD/filters/rolefilter.h \
@@ -27,9 +28,11 @@ HEADERS += $$PWD/qqmlsortfilterproxymodel.h \
     $$PWD/proxyroles/singlerole.h \
     $$PWD/proxyroles/regexprole.h \
     $$PWD/sorters/filtersorter.h \
-    $$PWD/proxyroles/filterrole.h
+    $$PWD/proxyroles/filterrole.h \
+    $$PWD/utils/utils.h
 
 SOURCES += $$PWD/qqmlsortfilterproxymodel.cpp \
+    $$PWD/qvariantlessthan.cpp \
     $$PWD/filters/filter.cpp \
     $$PWD/filters/filtercontainer.cpp \
     $$PWD/filters/rolefilter.cpp \
@@ -57,4 +60,5 @@ SOURCES += $$PWD/qqmlsortfilterproxymodel.cpp \
     $$PWD/proxyroles/singlerole.cpp \
     $$PWD/proxyroles/regexprole.cpp \
     $$PWD/sorters/filtersorter.cpp \
-    $$PWD/proxyroles/filterrole.cpp
+    $$PWD/proxyroles/filterrole.cpp \
+    $$PWD/utils/utils.cpp

SortFilterProxyModel.qbs

@@ -57,6 +57,8 @@ Group {
         "sorters/sortersqmltypes.cpp",
         "sorters/stringsorter.cpp",
         "sorters/stringsorter.h",
+        "utils/utils.cpp",
+        "utils/utils.h",
         "qqmlsortfilterproxymodel.cpp",
         "qqmlsortfilterproxymodel.h"
     ]

filters/filtercontainer.cpp

@@ -56,13 +56,13 @@ void FilterContainer::append_filter(QQmlListProperty<Filter>* list, Filter* filt
     that->appendFilter(filter);
 }
 
-int FilterContainer::count_filter(QQmlListProperty<Filter>* list)
+qqsfpm::FilterContainer::sizetype FilterContainer::count_filter(QQmlListProperty<Filter>* list)
 {
     QList<Filter*>* filters = static_cast<QList<Filter*>*>(list->data);
     return filters->count();
 }
 
-Filter* FilterContainer::at_filter(QQmlListProperty<Filter>* list, int index)
+Filter* FilterContainer::at_filter(QQmlListProperty<Filter>* list, qqsfpm::FilterContainer::sizetype index)
 {
     QList<Filter*>* filters = static_cast<QList<Filter*>*>(list->data);
     return filters->at(index);

filters/filtercontainer.h

@@ -30,9 +30,15 @@ class FilterContainer {
     virtual void onFilterRemoved(Filter* filter) = 0;
     virtual void onFiltersCleared() = 0;
 
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+    using sizetype = int;
+#else
+    using sizetype = qsizetype;
+#endif
+
     static void append_filter(QQmlListProperty<Filter>* list, Filter* filter);
-    static int count_filter(QQmlListProperty<Filter>* list);
-    static Filter* at_filter(QQmlListProperty<Filter>* list, int index);
+    static sizetype count_filter(QQmlListProperty<Filter>* list);
+    static Filter* at_filter(QQmlListProperty<Filter>* list, sizetype index);
     static void clear_filters(QQmlListProperty<Filter>* list);
 };
 

filters/rangefilter.cpp

@@ -1,5 +1,10 @@
 #include "rangefilter.h"
 
+#include "qvariantlessthan.h"
+
+
+
+
 namespace qqsfpm {
 
 /*!
@@ -128,11 +133,13 @@ void RangeFilter::setMaximumInclusive(bool maximumInclusive)
 
 bool RangeFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
 {
-    QVariant value = sourceData(sourceIndex, proxyModel);
+    const QVariant value = sourceData(sourceIndex, proxyModel);
     bool lessThanMin = m_minimumValue.isValid() &&
-            (m_minimumInclusive ? value < m_minimumValue : value <= m_minimumValue);
+            (m_minimumInclusive ? qqsfpm::lessThan(value, m_minimumValue)
+                                : !qqsfpm::lessThan(m_minimumValue, value));
     bool moreThanMax = m_maximumValue.isValid() &&
-            (m_maximumInclusive ? value > m_maximumValue : value >= m_maximumValue);
+            (m_maximumInclusive ? qqsfpm::lessThan(m_maximumValue, value)
+                                : !qqsfpm::lessThan(value, m_maximumValue));
     return !(lessThanMin || moreThanMax);
 }
 

filters/regexpfilter.cpp

@@ -35,6 +35,12 @@ namespace qqsfpm {
 
     \sa syntax
 */
+RegExpFilter::RegExpFilter() :
+    m_caseSensitivity(m_regExp.patternOptions().testFlag(
+        QRegularExpression::CaseInsensitiveOption) ? Qt::CaseInsensitive : Qt::CaseSensitive)
+{
+}
+
 QString RegExpFilter::pattern() const
 {
     return m_pattern;
@@ -51,38 +57,6 @@ void RegExpFilter::setPattern(const QString& pattern)
     invalidate();
 }
 
-/*!
-    \qmlproperty enum RegExpFilter::syntax
-
-    The pattern used to filter the contents of the source model.
-
-    Only the source model's value having their \l RoleFilter::roleName data matching this \l pattern with the specified \l syntax will be kept.
-
-    \value RegExpFilter.RegExp A rich Perl-like pattern matching syntax. This is the default.
-    \value RegExpFilter.Wildcard This provides a simple pattern matching syntax similar to that used by shells (command interpreters) for "file globbing".
-    \value RegExpFilter.FixedString The pattern is a fixed string. This is equivalent to using the RegExp pattern on a string in which all metacharacters are escaped.
-    \value RegExpFilter.RegExp2 Like RegExp, but with greedy quantifiers.
-    \value RegExpFilter.WildcardUnix This is similar to Wildcard but with the behavior of a Unix shell. The wildcard characters can be escaped with the character "\".
-    \value RegExpFilter.W3CXmlSchema11 The pattern is a regular expression as defined by the W3C XML Schema 1.1 specification.
-
-    \sa pattern
-*/
-RegExpFilter::PatternSyntax RegExpFilter::syntax() const
-{
-    return m_syntax;
-}
-
-void RegExpFilter::setSyntax(RegExpFilter::PatternSyntax syntax)
-{
-    if (m_syntax == syntax)
-        return;
-
-    m_syntax = syntax;
-    m_regExp.setPatternSyntax(static_cast<QRegExp::PatternSyntax>(syntax));
-    Q_EMIT syntaxChanged();
-    invalidate();
-}
-
 /*!
     \qmlproperty Qt::CaseSensitivity RegExpFilter::caseSensitivity
 
@@ -99,15 +73,18 @@ void RegExpFilter::setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)
         return;
 
     m_caseSensitivity = caseSensitivity;
-    m_regExp.setCaseSensitivity(caseSensitivity);
+    QRegularExpression::PatternOptions patternOptions = m_regExp.patternOptions();
+    if (caseSensitivity == Qt::CaseInsensitive)
+        patternOptions.setFlag(QRegularExpression::CaseInsensitiveOption);
+    m_regExp.setPatternOptions(patternOptions);
     Q_EMIT caseSensitivityChanged();
     invalidate();
 }
 
 bool RegExpFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
 {
-    QString string = sourceData(sourceIndex, proxyModel).toString();
-    return m_regExp.indexIn(string) != -1;
+    const QString string = sourceData(sourceIndex, proxyModel).toString();
+    return m_regExp.match(string).hasMatch();
 }
 
 }

filters/regexpfilter.h

@@ -3,32 +3,23 @@
 
 #include "rolefilter.h"
 
+#include <QRegularExpression>
+
 namespace qqsfpm {
 
 class RegExpFilter : public RoleFilter {
     Q_OBJECT
     Q_PROPERTY(QString pattern READ pattern WRITE setPattern NOTIFY patternChanged)
-    Q_PROPERTY(PatternSyntax syntax READ syntax WRITE setSyntax NOTIFY syntaxChanged)
     Q_PROPERTY(Qt::CaseSensitivity caseSensitivity READ caseSensitivity WRITE setCaseSensitivity NOTIFY caseSensitivityChanged)
 
 public:
-    enum PatternSyntax {
-        RegExp = QRegExp::RegExp,
-        Wildcard = QRegExp::Wildcard,
-        FixedString = QRegExp::FixedString,
-        RegExp2 = QRegExp::RegExp2,
-        WildcardUnix = QRegExp::WildcardUnix,
-        W3CXmlSchema11 = QRegExp::W3CXmlSchema11 };
-    Q_ENUMS(PatternSyntax)
-
     using RoleFilter::RoleFilter;
 
+    RegExpFilter();
+
     QString pattern() const;
     void setPattern(const QString& pattern);
 
-    PatternSyntax syntax() const;
-    void setSyntax(PatternSyntax syntax);
-
     Qt::CaseSensitivity caseSensitivity() const;
     void setCaseSensitivity(Qt::CaseSensitivity caseSensitivity);
 
@@ -37,13 +28,11 @@ class RegExpFilter : public RoleFilter {
 
 Q_SIGNALS:
     void patternChanged();
-    void syntaxChanged();
     void caseSensitivityChanged();
 
 private:
-    QRegExp m_regExp;
-    Qt::CaseSensitivity m_caseSensitivity = m_regExp.caseSensitivity();
-    PatternSyntax m_syntax = static_cast<PatternSyntax>(m_regExp.patternSyntax());
+    QRegularExpression m_regExp;
+    Qt::CaseSensitivity m_caseSensitivity;
     QString m_pattern = m_regExp.pattern();
 };