QML ServerContainers page refact

client/3rd/SortFilterProxyModel/.gitignore

@@ -0,0 +1,77 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+*.qmlc
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# qtcreator shadow builds
+build-SortFilterProxyModel-*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+

client/3rd/SortFilterProxyModel/CMakeLists.txt

@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 3.1)
+
+set(CMAKE_CXX_STANDARD 11)
+
+find_package(Qt5 REQUIRED
+    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
+    filters/filter.cpp
+    filters/filtercontainer.cpp
+    filters/rolefilter.cpp
+    filters/valuefilter.cpp
+    filters/indexfilter.cpp
+    filters/regexpfilter.cpp
+    filters/rangefilter.cpp
+    filters/expressionfilter.cpp
+    filters/filtercontainerfilter.cpp
+    filters/anyoffilter.cpp
+    filters/alloffilter.cpp
+    filters/filtersqmltypes.cpp
+    sorters/sorter.cpp
+    sorters/sortercontainer.cpp
+    sorters/rolesorter.cpp
+    sorters/stringsorter.cpp
+    sorters/expressionsorter.cpp
+    sorters/sortersqmltypes.cpp
+    proxyroles/proxyrole.cpp
+    proxyroles/proxyrolecontainer.cpp
+    proxyroles/joinrole.cpp
+    proxyroles/switchrole.cpp
+    proxyroles/expressionrole.cpp
+    proxyroles/proxyrolesqmltypes.cpp   
+    proxyroles/singlerole.cpp   
+    proxyroles/regexprole.cpp
+    sorters/filtersorter.cpp
+    proxyroles/filterrole.cpp
+    )
+
+target_include_directories(SortFilterProxyModel PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+    $<TARGET_PROPERTY:Qt5::Core,INTERFACE_INCLUDE_DIRECTORIES>
+    $<TARGET_PROPERTY:Qt5::Qml,INTERFACE_INCLUDE_DIRECTORIES>
+    )

client/3rd/SortFilterProxyModel/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2016 Pierre-Yves Siret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

client/3rd/SortFilterProxyModel/README.md

@@ -0,0 +1,126 @@
+SortFilterProxyModel
+====================
+
+SortFilterProxyModel is an implementation of `QSortFilterProxyModel` conveniently exposed for QML.
+
+Install
+-------
+##### With [qpm](https://qpm.io) :
+1. `qpm install fr.grecko.sortfilterproxymodel`
+2. add `include(vendor/vendor.pri)` in your .pro if it is not already done
+3. `import SortFilterProxyModel 0.2` to use this library in your QML files
+
+##### Without qpm :
+1. clone or download this repository
+2. * `qmake` add `include  (<path/to/SortFilterProxyModel>/SortFilterProxyModel.pri)` in your `.pro`
+   * `CMake` add $<TARGET_OBJECTS:SortFilterProxyModel> to the sources of your executable target in your cmake project
+3. `import SortFilterProxyModel 0.2` to use this library in your QML files
+
+Sample Usage
+------------
+
+- You can do simple filtering and sorting with SortFilterProxyModel:
+```qml
+import QtQuick 2.2
+import QtQuick.Controls 1.2
+import SortFilterProxyModel 0.2
+
+ApplicationWindow {
+    visible: true
+    width: 640
+    height: 480
+
+    ListModel {
+        id: personModel
+        ListElement {
+            firstName: "Erwan"
+            lastName: "Castex"
+            favorite: true
+        }
+        // ...
+    }
+
+    TextField {
+        id: textField
+        anchors { top: parent.top; left: parent.left; right: parent.right }
+        height: implicitHeight
+    }
+
+    SortFilterProxyModel {
+        id: personProxyModel
+        sourceModel: personModel
+        filters: RegExpFilter {
+            roleName: "lastName"
+            pattern: textField.text
+            caseSensitivity: Qt.CaseInsensitive
+        }
+        sorters: StringSorter { roleName: "firstName" }
+    }
+
+    ListView {
+        anchors { top: textField.bottom; bottom: parent.bottom; left: parent.left; right: parent.right }
+        model: personProxyModel
+        delegate: Text { text: model.firstName + " " + model.lastName}
+    }
+}
+```
+Here the `ListView` will only show elements that contains the content of the `TextField` in their `lastName` role.
+
+- But you can also achieve more complex filtering or sorting with multiple `filters` and `sorters`:
+```qml
+    SortFilterProxyModel {
+        id: personProxyModel
+        sourceModel: personModel
+        filters: [
+            ValueFilter {
+                enabled: onlyShowFavoritesCheckbox.checked
+                roleName: "favorite"
+                value: true
+            },
+            AnyOf {
+                RegExpFilter {
+                    roleName: "lastName"
+                    pattern: textField.text
+                    caseSensitivity: Qt.CaseInsensitive
+                }
+                RegExpFilter {
+                    roleName: "firstName"
+                    pattern: textField.text
+                    caseSensitivity: Qt.CaseInsensitive
+                }
+            }
+        ]
+        sorters: [
+            RoleSorter { roleName: "favorite"; sortOrder: Qt.DescendingOrder },
+            StringSorter { roleName: "firstName" },
+            StringSorter { roleName: "lastName" }
+        ]
+    }
+
+    CheckBox {
+        id:onlyShowFavoritesCheckbox
+    }
+```
+This will show in the corresponding `ListView` only the elements where the `firstName` or the `lastName` match the text entered in the `textField`, and if the `onlyShowFavoritesCheckbox` is checked it will aditionnally filter the elements where `favorite` is `true`.
+The favorited elements will be shown first and all the elements are sorted by `firstName` and then `lastName`.
+
+Showcase Application
+--------------------
+You can find an application showcasing this library here: https://github.com/oKcerG/SFPMShowcase
+
+License
+-------
+This library is licensed under the MIT License.
+
+Documentation
+-------------
+This component is a subclass of [`QSortFilterProxyModel`](http://doc.qt.io/qt-5/qsortfilterproxymodel.html), to use it, you need to set the `sourceModel` property to a [`QAbstractItemModel*`](http://doc.qt.io/qt-5/qabstractitemmodel.html) with correct role names.
+This means you can use it with custom c++ models or `ListModel`, but not with JavaScript models like arrays, integers or object instances.
+
+The complete documentation reference is available here: https://okcerg.github.io/SortFilterProxyModel/
+
+Contributing
+------------
+Don't hesitate to open an issue about a suggestion, a bug, a lack of clarity in the documentation, etc.
+
+Pull requests are also welcome, if it's a important change you should open an issue first though.

client/3rd/SortFilterProxyModel/SortFilterProxyModel.pri

@@ -0,0 +1,60 @@
+!contains( CONFIG, c\+\+1[14] ): warning("SortFilterProxyModel needs at least c++11, add CONFIG += c++11 to your .pro")
+
+INCLUDEPATH += $$PWD
+
+HEADERS += $$PWD/qqmlsortfilterproxymodel.h \
+    $$PWD/filters/filter.h \
+    $$PWD/filters/filtercontainer.h \
+    $$PWD/filters/rolefilter.h \
+    $$PWD/filters/valuefilter.h \
+    $$PWD/filters/indexfilter.h \
+    $$PWD/filters/regexpfilter.h \
+    $$PWD/filters/rangefilter.h \
+    $$PWD/filters/expressionfilter.h \
+    $$PWD/filters/filtercontainerfilter.h \
+    $$PWD/filters/anyoffilter.h \
+    $$PWD/filters/alloffilter.h \
+    $$PWD/sorters/sorter.h \
+    $$PWD/sorters/sortercontainer.h \
+    $$PWD/sorters/rolesorter.h \
+    $$PWD/sorters/stringsorter.h \
+    $$PWD/sorters/expressionsorter.h \
+    $$PWD/proxyroles/proxyrole.h \
+    $$PWD/proxyroles/proxyrolecontainer.h \
+    $$PWD/proxyroles/joinrole.h \
+    $$PWD/proxyroles/switchrole.h \
+    $$PWD/proxyroles/expressionrole.h \
+    $$PWD/proxyroles/singlerole.h \
+    $$PWD/proxyroles/regexprole.h \
+    $$PWD/sorters/filtersorter.h \
+    $$PWD/proxyroles/filterrole.h
+
+SOURCES += $$PWD/qqmlsortfilterproxymodel.cpp \
+    $$PWD/filters/filter.cpp \
+    $$PWD/filters/filtercontainer.cpp \
+    $$PWD/filters/rolefilter.cpp \
+    $$PWD/filters/valuefilter.cpp \
+    $$PWD/filters/indexfilter.cpp \
+    $$PWD/filters/regexpfilter.cpp \
+    $$PWD/filters/rangefilter.cpp \
+    $$PWD/filters/expressionfilter.cpp \
+    $$PWD/filters/filtercontainerfilter.cpp \
+    $$PWD/filters/anyoffilter.cpp \
+    $$PWD/filters/alloffilter.cpp \
+    $$PWD/filters/filtersqmltypes.cpp \
+    $$PWD/sorters/sorter.cpp \
+    $$PWD/sorters/sortercontainer.cpp \
+    $$PWD/sorters/rolesorter.cpp \
+    $$PWD/sorters/stringsorter.cpp \
+    $$PWD/sorters/expressionsorter.cpp \
+    $$PWD/sorters/sortersqmltypes.cpp \
+    $$PWD/proxyroles/proxyrole.cpp \
+    $$PWD/proxyroles/proxyrolecontainer.cpp \
+    $$PWD/proxyroles/joinrole.cpp \
+    $$PWD/proxyroles/switchrole.cpp \
+    $$PWD/proxyroles/expressionrole.cpp \
+    $$PWD/proxyroles/proxyrolesqmltypes.cpp \
+    $$PWD/proxyroles/singlerole.cpp \
+    $$PWD/proxyroles/regexprole.cpp \
+    $$PWD/sorters/filtersorter.cpp \
+    $$PWD/proxyroles/filterrole.cpp

client/3rd/SortFilterProxyModel/filters/alloffilter.cpp

@@ -0,0 +1,28 @@
+#include "alloffilter.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype AllOf
+    \inherits Filter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \ingroup FilterContainer
+    \brief Filter container accepting rows accepted by all its child filters.
+
+    The AllOf type is a \l Filter container that accepts rows if all of its contained (and enabled) filters accept them, or if it has no filter.
+
+    Using it as a top level filter has the same effect as putting all its child filters as top level filters. It can however be usefull to use an AllOf filter when nested in an AnyOf filter.
+    \sa FilterContainer
+*/
+bool AllOfFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    //return true if all filters return false, or if there is no filter.
+    return std::all_of(m_filters.begin(), m_filters.end(),
+        [&sourceIndex, &proxyModel] (Filter* filter) {
+            return filter->filterAcceptsRow(sourceIndex, proxyModel);
+        }
+    );
+}
+
+}

client/3rd/SortFilterProxyModel/filters/alloffilter.h

@@ -0,0 +1,20 @@
+#ifndef ALLOFFILTER_H
+#define ALLOFFILTER_H
+
+#include "filtercontainerfilter.h"
+
+namespace qqsfpm {
+
+class AllOfFilter : public FilterContainerFilter {
+    Q_OBJECT
+
+public:
+    using FilterContainerFilter::FilterContainerFilter;
+
+protected:
+    bool filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const override;
+};
+
+}
+
+#endif // ALLOFFILTER_H

client/3rd/SortFilterProxyModel/filters/anyoffilter.cpp

@@ -0,0 +1,49 @@
+#include "anyoffilter.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype AnyOf
+    \inherits Filter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \ingroup FilterContainer
+    \brief Filter container accepting rows accepted by at least one of its child filters.
+
+    The AnyOf type is a \l Filter container that accepts rows if any of its contained (and enabled) filters accept them.
+
+    In the following example, only the rows where the \c firstName role or the \c lastName role match the text entered in the \c nameTextField will be accepted :
+    \code
+    TextField {
+      id: nameTextField
+    }
+
+    SortFilterProxyModel {
+      sourceModel: contactModel
+      filters: AnyOf {
+          RegExpFilter {
+              roleName: "lastName"
+              pattern: nameTextField.text
+              caseSensitivity: Qt.CaseInsensitive
+          }
+          RegExpFilter {
+              roleName: "firstName"
+              pattern: nameTextField.text
+              caseSensitivity: Qt.CaseInsensitive
+          }
+      }
+    }
+    \endcode
+    \sa FilterContainer
+*/
+bool AnyOfFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    //return true if any of the enabled filters return true
+    return std::any_of(m_filters.begin(), m_filters.end(),
+        [&sourceIndex, &proxyModel] (Filter* filter) {
+            return filter->enabled() && filter->filterAcceptsRow(sourceIndex, proxyModel);
+        }
+    );
+}
+
+}

client/3rd/SortFilterProxyModel/filters/anyoffilter.h

@@ -0,0 +1,20 @@
+#ifndef ANYOFFILTER_H
+#define ANYOFFILTER_H
+
+#include "filtercontainerfilter.h"
+
+namespace qqsfpm {
+
+class AnyOfFilter : public FilterContainerFilter {
+    Q_OBJECT
+
+public:
+    using FilterContainerFilter::FilterContainerFilter;
+
+protected:
+    bool filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const override;
+};
+
+}
+
+#endif // ANYOFFILTER_H

client/3rd/SortFilterProxyModel/filters/expressionfilter.cpp

@@ -0,0 +1,125 @@
+#include "expressionfilter.h"
+#include "qqmlsortfilterproxymodel.h"
+#include <QtQml>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype ExpressionFilter
+    \inherits Filter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \brief Filters row with a custom filtering.
+
+    An ExpressionFilter is a \l Filter allowing to implement custom filtering based on a javascript expression.
+*/
+
+/*!
+    \qmlproperty expression ExpressionFilter::expression
+
+    An expression to implement custom filtering, it must evaluate to a boolean.
+    It has the same syntax has a \l {http://doc.qt.io/qt-5/qtqml-syntax-propertybinding.html} {Property Binding} except it will be evaluated for each of the source model's rows.
+    Rows that have their expression evaluating to \c true will be accepted by the model.
+    Data for each row is exposed like for a delegate of a QML View.
+
+    This expression is reevaluated for a row every time its model data changes.
+    When an external property (not \c index or in \c model) the expression depends on changes, the expression is reevaluated for every row of the source model.
+    To capture the properties the expression depends on, the expression is first executed with invalid data and each property access is detected by the QML engine.
+    This means that if a property is not accessed because of a conditional, it won't be captured and the expression won't be reevaluted when this property changes.
+
+    A workaround to this problem is to access all the properties the expressions depends unconditionally at the beggining of the expression.
+*/
+const QQmlScriptString& ExpressionFilter::expression() const
+{
+    return m_scriptString;
+}
+
+void ExpressionFilter::setExpression(const QQmlScriptString& scriptString)
+{
+    if (m_scriptString == scriptString)
+        return;
+
+    m_scriptString = scriptString;
+    updateExpression();
+
+    Q_EMIT expressionChanged();
+    invalidate();
+}
+
+void ExpressionFilter::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    updateContext(proxyModel);
+}
+
+bool ExpressionFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    if (!m_scriptString.isEmpty()) {
+        QVariantMap modelMap;
+        QHash<int, QByteArray> roles = proxyModel.roleNames();
+
+        QQmlContext context(qmlContext(this));
+        auto addToContext = [&] (const QString &name, const QVariant& value) {
+            context.setContextProperty(name, value);
+            modelMap.insert(name, value);
+        };
+
+        for (auto it = roles.cbegin(); it != roles.cend(); ++it)
+            addToContext(it.value(), proxyModel.sourceData(sourceIndex, it.key()));
+        addToContext("index", sourceIndex.row());
+
+        context.setContextProperty("model", modelMap);
+
+        QQmlExpression expression(m_scriptString, &context);
+        QVariant variantResult = expression.evaluate();
+
+        if (expression.hasError()) {
+            qWarning() << expression.error();
+            return true;
+        }
+        if (variantResult.canConvert<bool>()) {
+            return variantResult.toBool();
+        } else {
+            qWarning("%s:%i:%i : Can't convert result to bool",
+                     expression.sourceFile().toUtf8().data(),
+                     expression.lineNumber(),
+                     expression.columnNumber());
+            return true;
+        }
+    }
+    return true;
+}
+
+void ExpressionFilter::updateContext(const QQmlSortFilterProxyModel& proxyModel)
+{
+    delete m_context;
+    m_context = new QQmlContext(qmlContext(this), this);
+    // what about roles changes ?
+    QVariantMap modelMap;
+
+    auto addToContext = [&] (const QString &name, const QVariant& value) {
+        m_context->setContextProperty(name, value);
+        modelMap.insert(name, value);
+    };
+
+    for (const QByteArray& roleName : proxyModel.roleNames().values())
+        addToContext(roleName, QVariant());
+
+    addToContext("index", -1);
+
+    m_context->setContextProperty("model", modelMap);
+    updateExpression();
+}
+
+void ExpressionFilter::updateExpression()
+{
+    if (!m_context)
+        return;
+
+    delete m_expression;
+    m_expression = new QQmlExpression(m_scriptString, m_context, 0, this);
+    connect(m_expression, &QQmlExpression::valueChanged, this, &ExpressionFilter::invalidate);
+    m_expression->setNotifyOnValueChanged(true);
+    m_expression->evaluate();
+}
+
+}

client/3rd/SortFilterProxyModel/filters/expressionfilter.h

@@ -0,0 +1,41 @@
+#ifndef EXPRESSIONFILTER_H
+#define EXPRESSIONFILTER_H
+
+#include "filter.h"
+#include <QQmlScriptString>
+
+class QQmlExpression;
+
+namespace qqsfpm {
+
+class ExpressionFilter : public Filter
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlScriptString expression READ expression WRITE setExpression NOTIFY expressionChanged)
+
+public:
+    using Filter::Filter;
+
+    const QQmlScriptString& expression() const;
+    void setExpression(const QQmlScriptString& scriptString);
+
+    void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel) override;
+
+protected:
+    bool filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+Q_SIGNALS:
+    void expressionChanged();
+
+private:
+    void updateContext(const QQmlSortFilterProxyModel& proxyModel);
+    void updateExpression();
+
+    QQmlScriptString m_scriptString;
+    QQmlExpression* m_expression = nullptr;
+    QQmlContext* m_context = nullptr;
+};
+
+}
+
+#endif // EXPRESSIONFILTER_H

client/3rd/SortFilterProxyModel/filters/filter.cpp

@@ -0,0 +1,85 @@
+#include "filter.h"
+#include "qqmlsortfilterproxymodel.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype Filter
+    \qmlabstract
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \brief Base type for the \l SortFilterProxyModel filters.
+
+    The Filter type cannot be used directly in a QML file.
+    It exists to provide a set of common properties and methods,
+    available across all the other filter types that inherit from it.
+    Attempting to use the Filter type directly will result in an error.
+*/
+
+Filter::Filter(QObject *parent) : QObject(parent)
+{
+}
+
+/*!
+    \qmlproperty bool Filter::enabled
+
+    This property holds whether the filter is enabled.
+    A disabled filter will accept every rows unconditionally (even if it's inverted).
+
+    By default, filters are enabled.
+*/
+bool Filter::enabled() const
+{
+    return m_enabled;
+}
+
+void Filter::setEnabled(bool enabled)
+{
+    if (m_enabled == enabled)
+        return;
+
+    m_enabled = enabled;
+    Q_EMIT enabledChanged();
+    Q_EMIT invalidated();
+}
+
+/*!
+    \qmlproperty bool Filter::inverted
+
+    This property holds whether the filter is inverted.
+    When a filter is inverted, a row normally accepted would be rejected, and vice-versa.
+
+    By default, filters are not inverted.
+*/
+bool Filter::inverted() const
+{
+    return m_inverted;
+}
+
+void Filter::setInverted(bool inverted)
+{
+    if (m_inverted == inverted)
+        return;
+
+    m_inverted = inverted;
+    Q_EMIT invertedChanged();
+    invalidate();
+}
+
+bool Filter::filterAcceptsRow(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    return !m_enabled || filterRow(sourceIndex, proxyModel) ^ m_inverted;
+}
+
+void Filter::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    Q_UNUSED(proxyModel)
+}
+
+void Filter::invalidate()
+{
+    if (m_enabled)
+        Q_EMIT invalidated();
+}
+
+}

client/3rd/SortFilterProxyModel/filters/filter.h

@@ -0,0 +1,46 @@
+#ifndef FILTER_H
+#define FILTER_H
+
+#include <QObject>
+
+namespace qqsfpm {
+
+class QQmlSortFilterProxyModel;
+
+class Filter : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(bool inverted READ inverted WRITE setInverted NOTIFY invertedChanged)
+
+public:
+    explicit Filter(QObject *parent = nullptr);
+    virtual ~Filter() = default;
+
+    bool enabled() const;
+    void setEnabled(bool enabled);
+
+    bool inverted() const;
+    void setInverted(bool inverted);
+
+    bool filterAcceptsRow(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const;
+
+    virtual void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel);
+
+Q_SIGNALS:
+    void enabledChanged();
+    void invertedChanged();
+    void invalidated();
+
+protected:
+    virtual bool filterRow(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const = 0;
+    void invalidate();
+
+private:
+    bool m_enabled = true;
+    bool m_inverted = false;
+};
+
+}
+
+#endif // FILTER_H

client/3rd/SortFilterProxyModel/filters/filtercontainer.cpp

@@ -0,0 +1,126 @@
+#include "filtercontainer.h"
+#include "filter.h"
+#include <QtQml>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype FilterContainer
+    \qmlabstract
+    \inqmlmodule SortFilterProxyModel
+    \ingroup FilterAttached
+    \brief Abstract interface for types containing \l {Filter}{Filters}.
+
+    \section2 Types implementing this interface:
+    \annotatedlist FilterContainer
+*/
+
+QList<Filter*> FilterContainer::filters() const
+{
+    return m_filters;
+}
+
+void FilterContainer::appendFilter(Filter* filter)
+{
+    m_filters.append(filter);
+    onFilterAppended(filter);
+}
+
+void FilterContainer::removeFilter(Filter* filter)
+{
+    m_filters.removeOne(filter);
+    onFilterRemoved(filter);
+}
+
+void FilterContainer::clearFilters()
+{
+    m_filters.clear();
+    onFiltersCleared();
+}
+
+QQmlListProperty<Filter> FilterContainer::filtersListProperty()
+{
+    return QQmlListProperty<Filter>(reinterpret_cast<QObject*>(this), &m_filters,
+                                    &FilterContainer::append_filter,
+                                    &FilterContainer::count_filter,
+                                    &FilterContainer::at_filter,
+                                    &FilterContainer::clear_filters);
+}
+
+void FilterContainer::append_filter(QQmlListProperty<Filter>* list, Filter* filter)
+{
+    if (!filter)
+        return;
+
+    FilterContainer* that = reinterpret_cast<FilterContainer*>(list->object);
+    that->appendFilter(filter);
+}
+
+int 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)
+{
+    QList<Filter*>* filters = static_cast<QList<Filter*>*>(list->data);
+    return filters->at(index);
+}
+
+void FilterContainer::clear_filters(QQmlListProperty<Filter> *list)
+{
+    FilterContainer* that = reinterpret_cast<FilterContainer*>(list->object);
+    that->clearFilters();
+}
+
+FilterContainerAttached::FilterContainerAttached(QObject* object) : QObject(object),
+    m_filter(qobject_cast<Filter*>(object))
+{
+    if (!m_filter)
+        qmlWarning(object) << "FilterContainer must be attached to a Filter";
+}
+
+FilterContainerAttached::~FilterContainerAttached()
+{
+    if (m_filter && m_container) {
+        FilterContainer* container = qobject_cast<FilterContainer*>(m_container.data());
+        container->removeFilter(m_filter);
+    }
+}
+
+/*!
+    \qmlattachedproperty bool FilterContainer::container
+    This attached property allows you to include in a \l FilterContainer a \l Filter that
+    has been instantiated outside of the \l FilterContainer, for example in an Instantiator.
+*/
+QObject* FilterContainerAttached::container() const
+{
+    return m_container;
+}
+
+void FilterContainerAttached::setContainer(QObject* object)
+{
+    if (m_container == object)
+        return;
+
+    FilterContainer* container = qobject_cast<FilterContainer*>(object);
+    if (object && !container)
+        qmlWarning(parent()) << "container must inherits from FilterContainer, " << object->metaObject()->className() << " provided";
+
+    if (m_container && m_filter)
+        qobject_cast<FilterContainer*>(m_container.data())->removeFilter(m_filter);
+
+    m_container = container ? object : nullptr;
+    if (container && m_filter)
+        container->appendFilter(m_filter);
+
+    Q_EMIT containerChanged();
+}
+
+FilterContainerAttached* FilterContainerAttached::qmlAttachedProperties(QObject* object)
+{
+    return new FilterContainerAttached(object);
+}
+
+}

client/3rd/SortFilterProxyModel/filters/filtercontainer.h

@@ -0,0 +1,68 @@
+#ifndef FILTERCONTAINER_H
+#define FILTERCONTAINER_H
+
+#include <QList>
+#include <QQmlListProperty>
+#include <qqml.h>
+#include <QPointer>
+
+namespace qqsfpm {
+
+class Filter;
+class QQmlSortFilterProxyModel;
+
+class FilterContainer {
+public:
+    virtual ~FilterContainer() = default;
+
+    QList<Filter*> filters() const;
+    void appendFilter(Filter* filter);
+    void removeFilter(Filter* filter);
+    void clearFilters();
+
+    QQmlListProperty<Filter> filtersListProperty();
+
+protected:
+    QList<Filter*> m_filters;
+
+private:
+    virtual void onFilterAppended(Filter* filter) = 0;
+    virtual void onFilterRemoved(Filter* filter) = 0;
+    virtual void onFiltersCleared() = 0;
+
+    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 void clear_filters(QQmlListProperty<Filter>* list);
+};
+
+class FilterContainerAttached : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* container READ container WRITE setContainer NOTIFY containerChanged)
+
+public:
+    FilterContainerAttached(QObject* object);
+    ~FilterContainerAttached();
+
+    QObject* container() const;
+    void setContainer(QObject* object);
+
+    static FilterContainerAttached* qmlAttachedProperties(QObject* object);
+
+Q_SIGNALS:
+    void containerChanged();
+
+private:
+    QPointer<QObject> m_container = nullptr;
+    Filter* m_filter = nullptr;
+};
+
+}
+
+#define FilterContainer_iid "fr.grecko.SortFilterProxyModel.FilterContainer"
+Q_DECLARE_INTERFACE(qqsfpm::FilterContainer, FilterContainer_iid)
+
+QML_DECLARE_TYPEINFO(qqsfpm::FilterContainerAttached, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // FILTERCONTAINER_H

client/3rd/SortFilterProxyModel/filters/filtercontainerfilter.cpp

@@ -0,0 +1,28 @@
+#include "filtercontainerfilter.h"
+
+namespace qqsfpm {
+
+void FilterContainerFilter::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    for (Filter* filter : m_filters)
+        filter->proxyModelCompleted(proxyModel);
+}
+
+void FilterContainerFilter::onFilterAppended(Filter* filter)
+{
+    connect(filter, &Filter::invalidated, this, &FilterContainerFilter::invalidate);
+    invalidate();
+}
+
+void FilterContainerFilter::onFilterRemoved(Filter* filter)
+{
+    Q_UNUSED(filter)
+    invalidate();
+}
+
+void qqsfpm::FilterContainerFilter::onFiltersCleared()
+{
+    invalidate();
+}
+
+}

client/3rd/SortFilterProxyModel/filters/filtercontainerfilter.h

@@ -0,0 +1,31 @@
+#ifndef FILTERCONTAINERFILTER_H
+#define FILTERCONTAINERFILTER_H
+
+#include "filter.h"
+#include "filtercontainer.h"
+
+namespace qqsfpm {
+
+class FilterContainerFilter : public Filter, public FilterContainer {
+    Q_OBJECT
+    Q_INTERFACES(qqsfpm::FilterContainer)
+    Q_PROPERTY(QQmlListProperty<qqsfpm::Filter> filters READ filtersListProperty NOTIFY filtersChanged)
+    Q_CLASSINFO("DefaultProperty", "filters")
+
+public:
+    using Filter::Filter;
+
+    void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel) override;
+
+Q_SIGNALS:
+    void filtersChanged();
+
+private:
+    void onFilterAppended(Filter* filter) override;
+    void onFilterRemoved(Filter* filter) override;
+    void onFiltersCleared() override;
+};
+
+}
+
+#endif // FILTERCONTAINERFILTER_H

client/3rd/SortFilterProxyModel/filters/filtersqmltypes.cpp

@@ -0,0 +1,28 @@
+#include "filter.h"
+#include "valuefilter.h"
+#include "indexfilter.h"
+#include "regexpfilter.h"
+#include "rangefilter.h"
+#include "expressionfilter.h"
+#include "anyoffilter.h"
+#include "alloffilter.h"
+#include <QQmlEngine>
+#include <QCoreApplication>
+
+namespace qqsfpm {
+
+void registerFiltersTypes() {
+    qmlRegisterUncreatableType<Filter>("SortFilterProxyModel", 0, 2, "Filter", "Filter is an abstract class");
+    qmlRegisterType<ValueFilter>("SortFilterProxyModel", 0, 2, "ValueFilter");
+    qmlRegisterType<IndexFilter>("SortFilterProxyModel", 0, 2, "IndexFilter");
+    qmlRegisterType<RegExpFilter>("SortFilterProxyModel", 0, 2, "RegExpFilter");
+    qmlRegisterType<RangeFilter>("SortFilterProxyModel", 0, 2, "RangeFilter");
+    qmlRegisterType<ExpressionFilter>("SortFilterProxyModel", 0, 2, "ExpressionFilter");
+    qmlRegisterType<AnyOfFilter>("SortFilterProxyModel", 0, 2, "AnyOf");
+    qmlRegisterType<AllOfFilter>("SortFilterProxyModel", 0, 2, "AllOf");
+    qmlRegisterUncreatableType<FilterContainerAttached>("SortFilterProxyModel", 0, 2, "FilterContainer", "FilterContainer can only be used as an attaching type");
+}
+
+Q_COREAPP_STARTUP_FUNCTION(registerFiltersTypes)
+
+}

client/3rd/SortFilterProxyModel/filters/indexfilter.cpp

@@ -0,0 +1,112 @@
+#include "indexfilter.h"
+#include "qqmlsortfilterproxymodel.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype IndexFilter
+    \inherits Filter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \brief Filters rows based on their source index.
+
+    An IndexFilter is a filter allowing contents to be filtered based on their source model index.
+
+    In the following example, only the first row of the source model will be accepted:
+    \code
+    SortFilterProxyModel {
+       sourceModel: contactModel
+       filters: IndexFilter {
+           maximumIndex: 0
+       }
+    }
+    \endcode
+*/
+
+/*!
+    \qmlproperty int IndexFilter::minimumIndex
+
+    This property holds the minimumIndex of the filter.
+    Rows with a source index lower than \c minimumIndex will be rejected.
+
+    If \c minimumIndex is negative, it is counted from the end of the source model, meaning that :
+    \code
+    minimumIndex: -1
+    \endcode
+    is equivalent to :
+    \code
+    minimumIndex: sourceModel.count - 1
+    \endcode
+    By default, no value is set.
+*/
+const QVariant& IndexFilter::minimumIndex() const
+{
+    return m_minimumIndex;
+}
+
+void IndexFilter::setMinimumIndex(const QVariant& minimumIndex)
+{
+    if (m_minimumIndex == minimumIndex)
+        return;
+
+    m_minimumIndex = minimumIndex;
+    Q_EMIT minimumIndexChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty int IndexFilter::maximumIndex
+
+    This property holds the maximumIndex of the filter.
+    Rows with a source index higher than \c maximumIndex will be rejected.
+
+    If \c maximumIndex is negative, it is counted from the end of the source model, meaning that:
+    \code
+    maximumIndex: -1
+    \endcode
+    is equivalent to :
+    \code
+    maximumIndex: sourceModel.count - 1
+    \endcode
+    By default, no value is set.
+*/
+const QVariant& IndexFilter::maximumIndex() const
+{
+    return m_maximumIndex;
+}
+
+void IndexFilter::setMaximumIndex(const QVariant& maximumIndex)
+{
+    if (m_maximumIndex == maximumIndex)
+        return;
+
+    m_maximumIndex = maximumIndex;
+    Q_EMIT maximumIndexChanged();
+    invalidate();
+}
+
+bool IndexFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    int sourceRowCount = proxyModel.sourceModel()->rowCount();
+    int sourceRow = sourceIndex.row();
+
+    bool minimumIsValid;
+    int minimum = m_minimumIndex.toInt(&minimumIsValid);
+    if (minimumIsValid) {
+        int actualMinimum = minimum < 0 ? sourceRowCount + minimum : minimum;
+        if (sourceRow < actualMinimum)
+            return false;
+    }
+
+    bool maximumIsValid;
+    int maximum = m_maximumIndex.toInt(&maximumIsValid);
+    if (maximumIsValid) {
+        int actualMaximum = maximum < 0 ? sourceRowCount + maximum : maximum;
+        if (sourceRow > actualMaximum)
+            return false;
+    }
+
+    return true;
+}
+
+}

client/3rd/SortFilterProxyModel/filters/indexfilter.h

@@ -0,0 +1,37 @@
+#ifndef INDEXFILTER_H
+#define INDEXFILTER_H
+
+#include "filter.h"
+#include <QVariant>
+
+namespace qqsfpm {
+
+class IndexFilter: public Filter {
+    Q_OBJECT
+    Q_PROPERTY(QVariant minimumIndex READ minimumIndex WRITE setMinimumIndex NOTIFY minimumIndexChanged)
+    Q_PROPERTY(QVariant maximumIndex READ maximumIndex WRITE setMaximumIndex NOTIFY maximumIndexChanged)
+
+public:
+    using Filter::Filter;
+
+    const QVariant& minimumIndex() const;
+    void setMinimumIndex(const QVariant& minimumIndex);
+
+    const QVariant& maximumIndex() const;
+    void setMaximumIndex(const QVariant& maximumIndex);
+
+protected:
+    bool filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+Q_SIGNALS:
+    void minimumIndexChanged();
+    void maximumIndexChanged();
+
+private:
+    QVariant m_minimumIndex;
+    QVariant m_maximumIndex;
+};
+
+}
+
+#endif // INDEXFILTER_H

client/3rd/SortFilterProxyModel/filters/rangefilter.cpp

@@ -0,0 +1,139 @@
+#include "rangefilter.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype RangeFilter
+    \inherits RoleFilter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \brief Filters rows between boundary values.
+
+    A RangeFilter is a \l RoleFilter that accepts rows if their data is between the filter's minimum and maximum value.
+
+    In the following example, only rows with their \c price role set to a value between the tow boundary of the slider will be accepted :
+    \code
+    RangeSlider {
+       id: priceRangeSlider
+    }
+
+    SortFilterProxyModel {
+       sourceModel: priceModel
+       filters: RangeFilter {
+           roleName: "price"
+           minimumValue: priceRangeSlider.first.value
+           maximumValue: priceRangeSlider.second.value
+       }
+    }
+    \endcode
+*/
+
+/*!
+    \qmlproperty int RangeFilter::minimumValue
+
+    This property holds the minimumValue of the filter.
+    Rows with a value lower than \c minimumValue will be rejected.
+
+    By default, no value is set.
+
+    \sa minimumInclusive
+*/
+QVariant RangeFilter::minimumValue() const
+{
+    return m_minimumValue;
+}
+
+void RangeFilter::setMinimumValue(QVariant minimumValue)
+{
+    if (m_minimumValue == minimumValue)
+        return;
+
+    m_minimumValue = minimumValue;
+    Q_EMIT minimumValueChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty int RangeFilter::minimumInclusive
+
+    This property holds whether the \l minimumValue is inclusive.
+
+    By default, the \l minimumValue is inclusive.
+
+    \sa minimumValue
+*/
+bool RangeFilter::minimumInclusive() const
+{
+    return m_minimumInclusive;
+}
+
+void RangeFilter::setMinimumInclusive(bool minimumInclusive)
+{
+    if (m_minimumInclusive == minimumInclusive)
+        return;
+
+    m_minimumInclusive = minimumInclusive;
+    Q_EMIT minimumInclusiveChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty int RangeFilter::maximumValue
+
+    This property holds the maximumValue of the filter.
+    Rows with a value higher than \c maximumValue will be rejected.
+
+    By default, no value is set.
+
+    \sa maximumInclusive
+*/
+QVariant RangeFilter::maximumValue() const
+{
+    return m_maximumValue;
+}
+
+void RangeFilter::setMaximumValue(QVariant maximumValue)
+{
+    if (m_maximumValue == maximumValue)
+        return;
+
+    m_maximumValue = maximumValue;
+    Q_EMIT maximumValueChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty int RangeFilter::maximumInclusive
+
+    This property holds whether the \l minimumValue is inclusive.
+
+    By default, the \l minimumValue is inclusive.
+
+    \sa minimumValue
+*/
+bool RangeFilter::maximumInclusive() const
+{
+    return m_maximumInclusive;
+}
+
+void RangeFilter::setMaximumInclusive(bool maximumInclusive)
+{
+    if (m_maximumInclusive == maximumInclusive)
+        return;
+
+    m_maximumInclusive = maximumInclusive;
+    Q_EMIT maximumInclusiveChanged();
+    invalidate();
+}
+
+bool RangeFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    QVariant value = sourceData(sourceIndex, proxyModel);
+    bool lessThanMin = m_minimumValue.isValid() &&
+            (m_minimumInclusive ? value < m_minimumValue : value <= m_minimumValue);
+    bool moreThanMax = m_maximumValue.isValid() &&
+            (m_maximumInclusive ? value > m_maximumValue : value >= m_maximumValue);
+    return !(lessThanMin || moreThanMax);
+}
+
+}

client/3rd/SortFilterProxyModel/filters/rangefilter.h

@@ -0,0 +1,48 @@
+#ifndef RANGEFILTER_H
+#define RANGEFILTER_H
+
+#include "rolefilter.h"
+#include <QVariant>
+
+namespace qqsfpm {
+
+class RangeFilter : public RoleFilter
+{
+    Q_OBJECT
+    Q_PROPERTY(QVariant minimumValue READ minimumValue WRITE setMinimumValue NOTIFY minimumValueChanged)
+    Q_PROPERTY(bool minimumInclusive READ minimumInclusive WRITE setMinimumInclusive NOTIFY minimumInclusiveChanged)
+    Q_PROPERTY(QVariant maximumValue READ maximumValue WRITE setMaximumValue NOTIFY maximumValueChanged)
+    Q_PROPERTY(bool maximumInclusive READ maximumInclusive WRITE setMaximumInclusive NOTIFY maximumInclusiveChanged)
+
+public:
+    using RoleFilter::RoleFilter;
+
+    QVariant minimumValue() const;
+    void setMinimumValue(QVariant minimumValue);
+    bool minimumInclusive() const;
+    void setMinimumInclusive(bool minimumInclusive);
+
+    QVariant maximumValue() const;
+    void setMaximumValue(QVariant maximumValue);
+    bool maximumInclusive() const;
+    void setMaximumInclusive(bool maximumInclusive);
+
+protected:
+    bool filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+Q_SIGNALS:
+    void minimumValueChanged();
+    void minimumInclusiveChanged();
+    void maximumValueChanged();
+    void maximumInclusiveChanged();
+
+private:
+    QVariant m_minimumValue;
+    bool m_minimumInclusive = true;
+    QVariant m_maximumValue;
+    bool m_maximumInclusive = true;
+};
+
+}
+
+#endif // RANGEFILTER_H

client/3rd/SortFilterProxyModel/filters/regexpfilter.cpp

@@ -0,0 +1,113 @@
+#include "regexpfilter.h"
+#include <QVariant>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype RegExpFilter
+    \inherits RoleFilter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \brief  Filters rows matching a regular expression.
+
+    A RegExpFilter is a \l RoleFilter that accepts rows matching a regular rexpression.
+
+    In the following example, only rows with their \c lastName role beggining with the content of textfield the will be accepted:
+    \code
+    TextField {
+       id: nameTextField
+    }
+
+    SortFilterProxyModel {
+       sourceModel: contactModel
+       filters: RegExpFilter {
+           roleName: "lastName"
+           pattern: "^" + nameTextField.displayText
+       }
+    }
+    \endcode
+*/
+
+/*!
+    \qmlproperty bool RegExpFilter::pattern
+
+    The pattern used to filter the contents of the source model.
+
+    \sa syntax
+*/
+QString RegExpFilter::pattern() const
+{
+    return m_pattern;
+}
+
+void RegExpFilter::setPattern(const QString& pattern)
+{
+    if (m_pattern == pattern)
+        return;
+
+    m_pattern = pattern;
+    m_regExp.setPattern(pattern);
+    Q_EMIT patternChanged();
+    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
+
+    This property holds the caseSensitivity of the filter.
+*/
+Qt::CaseSensitivity RegExpFilter::caseSensitivity() const
+{
+    return m_caseSensitivity;
+}
+
+void RegExpFilter::setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)
+{
+    if (m_caseSensitivity == caseSensitivity)
+        return;
+
+    m_caseSensitivity = caseSensitivity;
+    m_regExp.setCaseSensitivity(caseSensitivity);
+    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;
+}
+
+}

client/3rd/SortFilterProxyModel/filters/regexpfilter.h

@@ -0,0 +1,52 @@
+#ifndef REGEXPFILTER_H
+#define REGEXPFILTER_H
+
+#include "rolefilter.h"
+
+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;
+
+    QString pattern() const;
+    void setPattern(const QString& pattern);
+
+    PatternSyntax syntax() const;
+    void setSyntax(PatternSyntax syntax);
+
+    Qt::CaseSensitivity caseSensitivity() const;
+    void setCaseSensitivity(Qt::CaseSensitivity caseSensitivity);
+
+protected:
+    bool filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+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());
+    QString m_pattern = m_regExp.pattern();
+};
+
+}
+
+#endif // REGEXPFILTER_H

client/3rd/SortFilterProxyModel/filters/rolefilter.cpp

@@ -0,0 +1,45 @@
+#include "rolefilter.h"
+#include "qqmlsortfilterproxymodel.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype RoleFilter
+    \qmlabstract
+    \inherits Filter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \brief Base type for filters based on a source model role.
+
+    The RoleFilter type cannot be used directly in a QML file.
+    It exists to provide a set of common properties and methods,
+    available across all the other filter types that inherit from it.
+    Attempting to use the RoleFilter type directly will result in an error.
+*/
+
+/*!
+    \qmlproperty string RoleFilter::roleName
+
+    This property holds the role name that the filter is using to query the source model's data when filtering items.
+*/
+const QString& RoleFilter::roleName() const
+{
+    return m_roleName;
+}
+
+void RoleFilter::setRoleName(const QString& roleName)
+{
+    if (m_roleName == roleName)
+        return;
+
+    m_roleName = roleName;
+    Q_EMIT roleNameChanged();
+    invalidate();
+}
+
+QVariant RoleFilter::sourceData(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    return proxyModel.sourceData(sourceIndex, m_roleName);
+}
+
+}

client/3rd/SortFilterProxyModel/filters/rolefilter.h

@@ -0,0 +1,31 @@
+#ifndef ROLEFILTER_H
+#define ROLEFILTER_H
+
+#include "filter.h"
+
+namespace qqsfpm {
+
+class RoleFilter : public Filter
+{
+    Q_OBJECT
+    Q_PROPERTY(QString roleName READ roleName WRITE setRoleName NOTIFY roleNameChanged)
+
+public:
+    using Filter::Filter;
+
+    const QString& roleName() const;
+    void setRoleName(const QString& roleName);
+
+Q_SIGNALS:
+    void roleNameChanged();
+
+protected:
+    QVariant sourceData(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const;
+
+private:
+    QString m_roleName;
+};
+
+}
+
+#endif // ROLEFILTER_H

client/3rd/SortFilterProxyModel/filters/valuefilter.cpp

@@ -0,0 +1,57 @@
+#include "valuefilter.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype ValueFilter
+    \inherits RoleFilter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Filters
+    \brief Filters rows matching exactly a value.
+
+    A ValueFilter is a simple \l RoleFilter that accepts rows matching exactly the filter's value
+
+    In the following example, only rows with their \c favorite role set to \c true will be accepted when the checkbox is checked :
+    \code
+    CheckBox {
+       id: showOnlyFavoriteCheckBox
+    }
+
+    SortFilterProxyModel {
+       sourceModel: contactModel
+       filters: ValueFilter {
+           roleName: "favorite"
+           value: true
+           enabled: showOnlyFavoriteCheckBox.checked
+       }
+    }
+    \endcode
+
+*/
+
+/*!
+    \qmlproperty variant ValueFilter::value
+
+    This property holds the value used to filter the contents of the source model.
+*/
+const QVariant &ValueFilter::value() const
+{
+    return m_value;
+}
+
+void ValueFilter::setValue(const QVariant& value)
+{
+    if (m_value == value)
+        return;
+
+    m_value = value;
+    Q_EMIT valueChanged();
+    invalidate();
+}
+
+bool ValueFilter::filterRow(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    return !m_value.isValid() || m_value == sourceData(sourceIndex, proxyModel);
+}
+
+}

client/3rd/SortFilterProxyModel/filters/valuefilter.h

@@ -0,0 +1,31 @@
+#ifndef VALUEFILTER_H
+#define VALUEFILTER_H
+
+#include "rolefilter.h"
+#include <QVariant>
+
+namespace qqsfpm {
+
+class ValueFilter : public RoleFilter {
+    Q_OBJECT
+    Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
+
+public:
+    using RoleFilter::RoleFilter;
+
+    const QVariant& value() const;
+    void setValue(const QVariant& value);
+
+protected:
+    bool filterRow(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+Q_SIGNALS:
+    void valueChanged();
+
+private:
+    QVariant m_value;
+};
+
+}
+
+#endif // VALUEFILTER_H

client/3rd/SortFilterProxyModel/index.qdoc

@@ -0,0 +1,27 @@
+/*!
+    \page index.html overview
+
+    \title SortFilterProxyModel QML Module
+
+    SortFilterProxyModel is an implementation of QSortFilterProxyModel conveniently exposed for QML.
+    \annotatedlist SortFilterProxyModel
+
+    \section1 Filters
+    \annotatedlist Filters
+
+    \section2 Related attached types
+    \annotatedlist FilterAttached
+
+    \section1 Sorters
+    \annotatedlist Sorters
+
+    \section2 Related attached types
+    \annotatedlist SorterAttached
+
+    \section1 ProxyRoles
+    \annotatedlist ProxyRoles
+*/
+
+/*!
+    \qmlmodule SortFilterProxyModel
+*/

client/3rd/SortFilterProxyModel/offline.css

@@ -0,0 +1,805 @@
+body {
+    font: normal 400 14px/1.2 Arial;
+    margin-top: 85px;
+    font-family: Arial, Helvetica;
+    text-align: left;
+    margin-left: 5px;
+    margin-right: 5px;
+    background-color: #fff;
+}
+
+p {
+    line-height: 20px
+}
+
+img {
+    margin-left: 0px;
+    max-width: 800px;
+    height: auto;
+}
+
+.content .border img {
+    box-shadow:3px 3px 8px 3px rgba(200,200,200,0.5)
+}
+
+.content .border .player {
+    box-shadow:3px 3px 8px 3px rgba(200,200,200,0.5)
+}
+
+.content .indexboxcont li {
+     font: normal bold 13px/1 Verdana
+ }
+
+.content .normallist li {
+     font: normal 13px/1 Verdana
+ }
+
+.descr {
+    margin-top: 35px;
+    margin-bottom: 45px;
+    margin-left: 5px;
+    text-align: left;
+    vertical-align: top;
+}
+
+.name {
+    max-width: 75%;
+    font-weight: 100;
+}
+
+tt {
+    text-align: left
+}
+
+/*
+-----------
+links
+-----------
+*/
+
+a:link {
+    color: #007330;
+    text-decoration: none;
+    text-align: left;
+}
+
+a.qa-mark:target:before {
+    content: "***";
+    color: #ff0000;
+}
+
+a:hover {
+    color: #44a51c;
+    text-align: left;
+}
+
+a:visited {
+    color: #007330;
+    text-align: left;
+}
+
+a:visited:hover {
+    color: #44a51c;
+    text-align: left;
+}
+
+/*
+-----------
+offline viewing: HTML links display an icon
+-----------
+*/
+
+a[href*="http://"], a[href*="ftp://"], a[href*="https://"] {
+    text-decoration: none;
+    background-image: url(../images/ico_out.png);
+    background-repeat: no-repeat;
+    background-position: left;
+    padding-left: 20px;
+    text-align: left;
+}
+
+.flags {
+    text-decoration: none;
+    text-height: 24px;
+}
+
+.flags:target {
+    background-color: #FFFFD6;
+}
+
+/*
+-------------------------------
+NOTE styles
+-------------------------------
+*/
+
+.notetitle, .tiptitle, .fastpathtitle {
+    font-weight: bold
+}
+
+.attentiontitle, .cautiontitle, .dangertitle, .importanttitle, .remembertitle, .restrictiontitle {
+    font-weight: bold
+}
+
+.note, .tip, .fastpath {
+    background: #F2F2F2 url(../images/ico_note.png);
+    background-repeat: no-repeat;
+    background-position: top left;
+    padding: 5px;
+    padding-left: 40px;
+    padding-bottom: 10px;
+    border: #999 1px dotted;
+    color: #666666;
+    margin: 5px;
+}
+
+.attention, .caution, .danger, .important, .remember, .restriction {
+    background: #F2F2F2 url(../images/ico_note_attention.png);
+    background-repeat: no-repeat;
+    background-position: top left;
+    padding: 5px;
+    padding-left: 40px;
+    padding-bottom: 10px;
+    border: #999 1px dotted;
+    color: #666666;
+    margin: 5px;
+}
+
+/*
+-------------------------------
+Top navigation
+-------------------------------
+*/
+
+.qtref {
+    display: block;
+    position: relative;
+    height: 15px;
+    z-index: 1;
+    font-size: 11px;
+    padding-right: 10px;
+    float: right;
+}
+
+.naviNextPrevious {
+    clear: both;
+    display: block;
+    position: relative;
+    text-align: right;
+    top: -47px;
+    float: right;
+    height: 20px;
+    z-index: 1;
+    padding-right: 10px;
+    padding-top: 2px;
+    vertical-align: top;
+    margin: 0px;
+}
+
+.naviNextPrevious > a:first-child {
+     background-image: url(../images/btn_prev.png);
+     background-repeat: no-repeat;
+     background-position: left;
+     padding-left: 20px;
+     height: 20px;
+     padding-left: 20px;
+ }
+
+.naviNextPrevious > a:last-child {
+     background-image: url(../images/btn_next.png);
+     background-repeat: no-repeat;
+     background-position: right;
+     padding-right: 20px;
+     height: 20px;
+     margin-left: 30px;
+ }
+
+.naviSeparator { display: none }
+/*
+-----------
+footer and license
+-----------
+*/
+
+.footer {
+    text-align: left;
+    padding-top: 45px;
+    padding-left: 5px;
+    margin-top: 45px;
+    margin-bottom: 45px;
+    font-size: 10px;
+    border-top: 1px solid #999;
+}
+
+.footer p {
+    line-height: 14px;
+    font-size: 11px;
+    padding: 0;
+    margin: 0;
+}
+
+.footer a[href*="http://"], a[href*="ftp://"], a[href*="https://"] {
+    font-weight: bold;
+}
+
+.footerNavi {
+    width: auto;
+    text-align: right;
+    margin-top: 50px;
+    z-index: 1;
+}
+
+.navigationbar {
+    display: block;
+    position: relative;
+    top: -20px;
+    border-top: 1px solid #cecece;
+    border-bottom: 1px solid #cecece;
+    background-color: #F2F2F2;
+    z-index: 1;
+    height: 20px;
+    padding-left: 7px;
+    margin: 0px;
+    padding-top: 2px;
+    margin-left: -5px;
+    margin-right: -5px;
+}
+
+.navigationbar .first {
+     background: url(../images/home.png);
+     background-position: left;
+     background-repeat: no-repeat;
+     padding-left: 20px;
+ }
+
+.navigationbar ul {
+     margin: 0px;
+     padding: 0px;
+ }
+
+  .navigationbar ul li {
+      list-style-type: none;
+      padding-top: 2px;
+      padding-left: 4px;
+      margin: 0;
+      height: 20px;
+  }
+
+.navigationbar li {
+     float: left
+ }
+
+  .navigationbar li a, .navigationbar td a {
+      display: block;
+      text-decoration: none;
+      background: url(../images/arrow_bc.png);
+      background-repeat: no-repeat;
+      background-position: right;
+      padding-right: 17px;
+  }
+
+table.buildversion {
+      float: right;
+      margin-top: -18px !important;
+}
+
+.navigationbar table {
+      border-radius: 0;
+      border: 0 none;
+      background-color: #F2F2F2;
+      margin: 0;
+}
+
+.navigationbar table td {
+    padding: 0;
+    border: 0 none;
+}
+
+#buildversion {
+    font-style: italic;
+    font-size: small;
+    float: right;
+    margin-right: 5px;
+}
+
+/*
+
+/* table of content
+no display
+*/
+
+/*
+-----------
+headers
+-----------
+*/
+
+@media screen {
+    .title {
+        color: #313131;
+        font-size: 24px;
+        font-weight: normal;
+        left: 0;
+        padding-bottom: 20px;
+        padding-left: 10px;
+        padding-top: 20px;
+        position: absolute;
+        right: 0;
+        top: 0;
+        background-color: #E6E6E6;
+        border-bottom: 1px #CCC solid;
+        border-top: 2px #CCC solid;
+        font-weight: bold;
+        margin-left: 0px;
+        margin-right: 0px;
+    }
+    .subtitle, .small-subtitle {
+        display: block;
+        clear: left;
+    }
+}
+
+h1 {
+    margin: 0
+}
+
+h2, p.h2 {
+    font: 500 16px/1.2 Arial;
+    font-weight: 100;
+    background-color: #F2F3F4;
+    padding: 4px;
+    margin-bottom: 30px;
+    margin-top: 30px;
+    border-top: #E0E0DE 1px solid;
+    border-bottom: #E0E0DE 1px solid;
+    max-width: 99%;
+}
+
+h2:target {
+    background-color: #F2F3D4;
+}
+
+h3 {
+    font: 500 14px/1.2 Arial;
+    font-weight: 100;
+    text-decoration: underline;
+    margin-bottom: 30px;
+    margin-top: 30px;
+}
+
+h3.fn, span.fn {
+    border-width: 1px;
+    border-style: solid;
+    border-color: #E6E6E6;
+    -moz-border-radius: 7px 7px 7px 7px;
+    -webkit-border-radius: 7px 7px 7px 7px;
+    border-radius: 7px 7px 7px 7px;
+    background-color: #F6F6F6;
+    word-spacing: 3px;
+    padding: 5px 5px;
+    text-decoration: none;
+    font-weight: bold;
+    max-width: 75%;
+    font-size: 14px;
+    margin: 0px;
+    margin-top: 45px;
+}
+.fngroup h3.fngroupitem {
+    margin-bottom: 5px;
+}
+h3.fn code {
+    float: right;
+}
+h3.fn:target {
+    background-color: #F6F6D6;
+}
+
+.name {
+    color: #1A1A1A
+}
+
+.type {
+    color: #808080
+}
+
+@media print {
+    .title {
+        color: #0066CB;
+        font-family: Arial, Helvetica;
+        font-size: 32px;
+        font-weight: normal;
+        left: 0;
+        position: absolute;
+        right: 0;
+        top: 0;
+    }
+}
+
+/*
+-----------------
+table styles
+-----------------
+*/
+
+.table img {
+    border: none;
+    margin-left: 0px;
+    -moz-box-shadow: 0px 0px 0px #fff;
+    -webkit-box-shadow: 0px 0px 0px #fff;
+    box-shadow: 0px 0px 0px #fff;
+}
+
+/* table with border alternative colours*/
+
+table, pre, .LegaleseLeft {
+    -moz-border-radius: 7px 7px 7px 7px;
+    -webkit-border-radius: 7px 7px 7px 7px;
+    border-radius: 7px 7px 7px 7px;
+    background-color: #F6F6F6;
+    border: 1px solid #E6E6E6;
+    border-collapse: separate;
+    margin-bottom: 25px;
+    margin-left: 15px;
+    font-size: 12px;
+    line-height: 1.2;
+}
+
+ table tr.even {
+     background-color: white;
+     color: #66666E;
+ }
+
+ table tr.odd {
+     background-color: #F6F6F6;
+     color: #66666E;
+ }
+
+ table tr:target {
+     background-color: #F6F6D6;
+ }
+
+ table thead {
+     text-align: left;
+     padding-left: 20px;
+     background-color: #e1e0e0;
+     border-left: none;
+     border-right: none;
+ }
+
+  table thead th {
+      padding-top: 5px;
+      padding-left: 10px;
+      padding-bottom: 5px;
+      border-bottom: 2px solid #D1D1D1;
+      padding-right: 10px;
+  }
+
+ table th {
+     text-align: left;
+     padding-left: 20px;
+ }
+
+ table td {
+     padding: 3px 15px 3px 20px;
+     border-bottom: #CCC dotted 1px;
+ }
+
+ table p {
+     margin: 0px
+ }
+
+.LegaleseLeft {
+    font-family: monospace;
+    white-space: pre-wrap;
+}
+/* table bodless & white*/
+
+.borderless {
+    border-radius: 0px 0px 0px 0px;
+    background-color: #fff;
+    border: 1px solid #fff;
+}
+
+.borderless tr {
+     background-color: #FFF;
+     color: #66666E;
+ }
+
+.borderless td {
+     border: none;
+     border-bottom: #fff dotted 1px;
+ }
+
+/*
+-----------
+List
+-----------
+*/
+
+ul {
+    margin-top: 10px;
+}
+
+li {
+    margin-bottom: 10px;
+    padding-left: 8px;
+    list-style: outside;
+    text-align: left;
+}
+
+ ul > li {
+    list-style-type: square;
+ }
+
+ol {
+    margin: 10px;
+    padding: 0;
+}
+
+ol.A > li {
+    list-style-type: upper-alpha;
+}
+
+ol.a > li{
+    list-style-type: lower-alpha;
+}
+
+ ol > li {
+     margin-left: 30px;
+     padding-left: 8px;
+     list-style: decimal;
+ }
+
+.centerAlign {
+    text-align: left
+}
+
+.cpp, .LegaleseLeft {
+    display: block;
+    margin: 10px;
+    overflow: auto;
+    padding: 20px 20px 20px 20px;
+}
+
+.js {
+    display: block;
+    margin: 10px;
+    overflow: auto;
+    padding: 20px 20px 20px 20px;
+}
+
+.memItemLeft {
+    padding-right: 3px
+}
+
+.memItemRight {
+    padding: 3px 15px 3px 0
+}
+
+.qml {
+    display: block;
+    margin: 10px;
+    overflow: auto;
+    padding: 20px 20px 20px 20px;
+}
+
+.qmldefault {
+    padding-left: 5px;
+    float: right;
+    color: red;
+}
+
+.qmlreadonly {
+    padding-left: 5px;
+    float: right;
+    color: #254117;
+}
+
+.rightAlign {
+    padding: 3px 5px 3px 10px;
+    text-align: right;
+}
+
+.qmldoc {
+    margin-left: 15px
+}
+
+.flowList {
+  padding: 25px
+}
+.flowList dd {
+  display: inline-block;
+  margin-left: 10px;
+  width: 255px;
+  line-height: 1.15em;
+  overflow-x: hidden;
+  text-overflow: ellipsis
+}
+.alphaChar {
+  font-size: 2em;
+  position: relative
+}
+/*
+-----------
+Content table
+-----------
+*/
+
+@media print {
+    .toc {
+        float: right;
+        clear: right;
+        padding-bottom: 10px;
+        padding-top: 50px;
+        width: 100%;
+        background-image: url(../images/bgrContent.png);
+        background-position: top;
+        background-repeat: no-repeat;
+    }
+}
+
+@media screen {
+    .toc {
+        float: right;
+        clear: right;
+        vertical-align: top;
+        -moz-border-radius: 7px 7px 7px 7px;
+        -webkit-border-radius: 7px 7px 7px 7px;
+        border-radius: 7px 7px 7px 7px;
+        background: #FFF url('../images/bgrContent.png');
+        background-position: top;
+        background-repeat: repeat-x;
+        border: 1px solid #E6E6E6;
+        padding-left: 5px;
+        padding-bottom: 10px;
+        height: auto;
+        width: 200px;
+        text-align: left;
+        margin-left: 20px;
+    }
+}
+
+
+.toc h3 {
+    text-decoration: none
+}
+
+.toc h3 {
+    font: 500 14px/1.2 Arial;
+    font-weight: 100;
+    padding: 0px;
+    margin: 0px;
+    padding-top: 5px;
+    padding-left: 5px;
+}
+
+.toc ul {
+    padding-left: 10px;
+    padding-right: 5px;
+}
+
+.toc ul li {
+     margin-left: 15px;
+     list-style-image: url(../images/bullet_dn.png);
+     marker-offset: 0px;
+     margin-bottom: 8px;
+     padding-left: 0px;
+ }
+
+.toc .level1 {
+    border: none
+}
+
+.toc .level2 {
+    border: none;
+    margin-left: 25px;
+}
+
+.level3 {
+    border: none;
+    margin-left: 30px;
+}
+
+.clearfix {
+    clear: both
+}
+
+/*
+-----------
+Landing page
+-----------
+*/
+
+.col-group {
+    white-space: nowrap;
+    vertical-align: top;
+}
+
+
+.landing h2 {
+    background-color: transparent;
+    border: none;
+    margin-bottom: 0px;
+    font-size: 18px;
+}
+
+.landing a, .landing li {
+    font-size: 13px;
+    font-weight: bold !important;
+}
+
+.col-1 {
+    display: inline-block;
+    white-space: normal;
+    width: 70%;
+    height: 100%;
+    float: left;
+}
+
+.col-2 {
+    display: inline-block;
+    white-space: normal;
+    width: 20%;
+    margin-left: 5%;
+    position: relative;
+    top: -20px;
+}
+
+.col-1 h1 {
+     margin: 20px 0 0 0;
+ }
+
+.col-1 h2 {
+    font-size: 18px;
+    font-weight: bold !important;
+}
+
+.landingicons {
+    display: inline-block;
+    width: 100%;
+}
+
+.icons1of3 {
+    display: inline-block;
+    width: 33.3333%;
+    float: left;
+}
+
+.icons1of3 h2, .doc-column h2 {
+    font-size: 15px;
+    margin: 0px;
+    padding: 0px;
+}
+
+div.multi-column {
+    position: relative;
+}
+
+div.multi-column div {
+    display: -moz-inline-box;
+    display: inline-block;
+    vertical-align: top;
+    margin-top: 1em;
+    margin-right: 4em;
+    width: 24em;
+}
+
+.mainContent .video {
+  width:40%;
+  max-width:640px;
+  margin: 15px 0 0 15px;
+  position:relative;
+  display:table
+}
+
+.mainContent .video > .vspan {
+  padding-top:60%;
+  display:block
+}
+.mainContent .video iframe {
+  width:100%;
+  height:100%;
+  position:absolute;
+  top:0;
+  left:0
+}

client/3rd/SortFilterProxyModel/proxyroles/expressionrole.cpp

@@ -0,0 +1,128 @@
+#include "expressionrole.h"
+#include "qqmlsortfilterproxymodel.h"
+#include <QtQml>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype ExpressionRole
+    \inherits SingleRole
+    \inqmlmodule SortFilterProxyModel
+    \ingroup ProxyRoles
+    \brief A custom role computed from a javascript expression.
+
+    An ExpressionRole is a \l ProxyRole allowing to implement a custom role based on a javascript expression.
+
+    In the following example, the \c c role is computed by adding the \c a role and \c b role of the model :
+    \code
+    SortFilterProxyModel {
+       sourceModel: numberModel
+       proxyRoles: ExpressionRole {
+           name: "c"
+           expression: model.a + model.b
+      }
+    }
+    \endcode
+*/
+
+/*!
+    \qmlproperty expression ExpressionRole::expression
+
+    An expression to implement a custom role.
+    It has the same syntax has a \l {http://doc.qt.io/qt-5/qtqml-syntax-propertybinding.html} {Property Binding} except it will be evaluated for each of the source model's rows.
+    The data for this role will be the retuned valued of the expression.
+    Data for each row is exposed like for a delegate of a QML View.
+
+    This expression is reevaluated for a row every time its model data changes.
+    When an external property (not \c index or in \c model) the expression depends on changes, the expression is reevaluated for every row of the source model.
+    To capture the properties the expression depends on, the expression is first executed with invalid data and each property access is detected by the QML engine.
+    This means that if a property is not accessed because of a conditional, it won't be captured and the expression won't be reevaluted when this property changes.
+
+    A workaround to this problem is to access all the properties the expressions depends unconditionally at the beggining of the expression.
+*/
+const QQmlScriptString& ExpressionRole::expression() const
+{
+    return m_scriptString;
+}
+
+void ExpressionRole::setExpression(const QQmlScriptString& scriptString)
+{
+    if (m_scriptString == scriptString)
+        return;
+
+    m_scriptString = scriptString;
+    updateExpression();
+
+    Q_EMIT expressionChanged();
+    invalidate();
+}
+
+void ExpressionRole::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    updateContext(proxyModel);
+}
+
+QVariant ExpressionRole::data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel)
+{
+    if (!m_scriptString.isEmpty()) {
+        QVariantMap modelMap;
+        QHash<int, QByteArray> roles = proxyModel.roleNames();
+
+        QQmlContext context(qmlContext(this));
+        auto addToContext = [&] (const QString &name, const QVariant& value) {
+            context.setContextProperty(name, value);
+            modelMap.insert(name, value);
+        };
+
+        for (auto it = roles.cbegin(); it != roles.cend(); ++it)
+            addToContext(it.value(), proxyModel.sourceData(sourceIndex, it.key()));
+        addToContext("index", sourceIndex.row());
+
+        context.setContextProperty("model", modelMap);
+
+        QQmlExpression expression(m_scriptString, &context);
+        QVariant result = expression.evaluate();
+
+        if (expression.hasError()) {
+            qWarning() << expression.error();
+            return true;
+        }
+        return result;
+    }
+    return QVariant();
+}
+
+void ExpressionRole::updateContext(const QQmlSortFilterProxyModel& proxyModel)
+{
+    delete m_context;
+    m_context = new QQmlContext(qmlContext(this), this);
+    // what about roles changes ?
+    QVariantMap modelMap;
+
+    auto addToContext = [&] (const QString &name, const QVariant& value) {
+        m_context->setContextProperty(name, value);
+        modelMap.insert(name, value);
+    };
+
+    for (const QByteArray& roleName : proxyModel.roleNames().values())
+        addToContext(roleName, QVariant());
+
+    addToContext("index", -1);
+
+    m_context->setContextProperty("model", modelMap);
+    updateExpression();
+}
+
+void ExpressionRole::updateExpression()
+{
+    if (!m_context)
+        return;
+
+    delete m_expression;
+    m_expression = new QQmlExpression(m_scriptString, m_context, 0, this);
+    connect(m_expression, &QQmlExpression::valueChanged, this, &ExpressionRole::invalidate);
+    m_expression->setNotifyOnValueChanged(true);
+    m_expression->evaluate();
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/expressionrole.h

@@ -0,0 +1,39 @@
+#ifndef EXPRESSIONROLE_H
+#define EXPRESSIONROLE_H
+
+#include "singlerole.h"
+#include <QQmlScriptString>
+
+class QQmlExpression;
+
+namespace qqsfpm {
+
+class ExpressionRole : public SingleRole
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlScriptString expression READ expression WRITE setExpression NOTIFY expressionChanged)
+
+public:
+    using SingleRole::SingleRole;
+
+    const QQmlScriptString& expression() const;
+    void setExpression(const QQmlScriptString& scriptString);
+
+    void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel) override;
+
+Q_SIGNALS:
+    void expressionChanged();
+
+private:
+    QVariant data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) override;
+    void updateContext(const QQmlSortFilterProxyModel& proxyModel);
+    void updateExpression();
+
+    QQmlScriptString m_scriptString;
+    QQmlExpression* m_expression = nullptr;
+    QQmlContext* m_context = nullptr;
+};
+
+}
+
+#endif // EXPRESSIONROLE_H

client/3rd/SortFilterProxyModel/proxyroles/filterrole.cpp

@@ -0,0 +1,65 @@
+#include "filterrole.h"
+#include "filters/filter.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype FilterRole
+    \inherits SingleRole
+    \inqmlmodule SortFilterProxyModel
+    \ingroup ProxyRoles
+    \ingroup FilterContainer
+    \brief A role resolving to \c true for rows matching all its filters.
+
+    A FilterRole is a \l ProxyRole that returns \c true for rows matching all its filters.
+
+    In the following example, the \c isAdult role will be equal to \c true if the \c age role is superior or equal to 18.
+    \code
+    SortFilterProxyModel {
+        sourceModel: personModel
+        proxyRoles: FilterRole {
+            name: "isAdult"
+            RangeFilter { roleName: "age"; minimumValue: 18; minimumInclusive: true }
+        }
+    }
+    \endcode
+    \sa FilterContainer
+*/
+
+/*!
+    \qmlproperty list<Filter> FilterRole::filters
+    \default
+
+    This property holds the list of filters for this filter role.
+    The data of this role will be equal to the \c true if all its filters match the model row, \c false otherwise.
+
+    \sa Filter, FilterContainer
+*/
+
+void FilterRole::onFilterAppended(Filter* filter)
+{
+    connect(filter, &Filter::invalidated, this, &FilterRole::invalidate);
+    invalidate();
+}
+
+void FilterRole::onFilterRemoved(Filter* filter)
+{
+    disconnect(filter, &Filter::invalidated, this, &FilterRole::invalidate);
+    invalidate();
+}
+
+void FilterRole::onFiltersCleared()
+{
+    invalidate();
+}
+
+QVariant FilterRole::data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel)
+{
+    return std::all_of(m_filters.begin(), m_filters.end(),
+        [&] (Filter* filter) {
+            return filter->filterAcceptsRow(sourceIndex, proxyModel);
+        }
+    );
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/filterrole.h

@@ -0,0 +1,29 @@
+#ifndef FILTERROLE_H
+#define FILTERROLE_H
+
+#include "singlerole.h"
+#include "filters/filtercontainer.h"
+
+namespace qqsfpm {
+
+class FilterRole : public SingleRole, public FilterContainer
+{
+    Q_OBJECT
+    Q_INTERFACES(qqsfpm::FilterContainer)
+    Q_PROPERTY(QQmlListProperty<qqsfpm::Filter> filters READ filtersListProperty)
+    Q_CLASSINFO("DefaultProperty", "filters")
+
+public:
+    using SingleRole::SingleRole;
+
+private:
+    void onFilterAppended(Filter* filter) override;
+    void onFilterRemoved(Filter* filter) override;
+    void onFiltersCleared() override;
+
+    QVariant data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) override;
+};
+
+}
+
+#endif // FILTERROLE_H

client/3rd/SortFilterProxyModel/proxyroles/joinrole.cpp

@@ -0,0 +1,83 @@
+#include "joinrole.h"
+#include "qqmlsortfilterproxymodel.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype JoinRole
+    \inherits SingleRole
+    \inqmlmodule SortFilterProxyModel
+    \ingroup ProxyRoles
+    \brief a role made from concatenating other roles.
+
+    A JoinRole is a simple \l ProxyRole that concatenates other roles.
+
+    In the following example, the \c fullName role is computed by the concatenation of the \c firstName role and the \c lastName role separated by a space :
+    \code
+    SortFilterProxyModel {
+       sourceModel: contactModel
+       proxyRoles: JoinRole {
+           name: "fullName"
+           roleNames: ["firstName", "lastName"]
+      }
+    }
+    \endcode
+
+*/
+
+/*!
+    \qmlproperty list<string> JoinRole::roleNames
+
+    This property holds the role names that are joined by this role.
+*/
+QStringList JoinRole::roleNames() const
+{
+    return m_roleNames;
+}
+
+void JoinRole::setRoleNames(const QStringList& roleNames)
+{
+    if (m_roleNames == roleNames)
+        return;
+
+    m_roleNames = roleNames;
+    Q_EMIT roleNamesChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty string JoinRole::separator
+
+    This property holds the separator that is used to join the roles specified in \l roleNames.
+
+    By default, it's a space.
+*/
+QString JoinRole::separator() const
+{
+    return m_separator;
+}
+
+void JoinRole::setSeparator(const QString& separator)
+{
+    if (m_separator == separator)
+        return;
+
+    m_separator = separator;
+    Q_EMIT separatorChanged();
+    invalidate();
+}
+
+QVariant JoinRole::data(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel& proxyModel)
+{
+    QString result;
+
+    for (const QString& roleName : m_roleNames)
+        result += proxyModel.sourceData(sourceIndex, roleName).toString() + m_separator;
+
+    if (!m_roleNames.isEmpty())
+        result.chop(m_separator.length());
+
+    return result;
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/joinrole.h

@@ -0,0 +1,36 @@
+#ifndef JOINROLE_H
+#define JOINROLE_H
+
+#include "singlerole.h"
+
+namespace qqsfpm {
+
+class JoinRole : public SingleRole
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList roleNames READ roleNames WRITE setRoleNames NOTIFY roleNamesChanged)
+    Q_PROPERTY(QString separator READ separator WRITE setSeparator NOTIFY separatorChanged)
+
+public:
+    using SingleRole::SingleRole;
+
+    QStringList roleNames() const;
+    void setRoleNames(const QStringList& roleNames);
+
+    QString separator() const;
+    void setSeparator(const QString& separator);
+
+Q_SIGNALS:
+    void roleNamesChanged();
+
+    void separatorChanged();
+
+private:
+    QStringList m_roleNames;
+    QVariant data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) override;
+    QString m_separator = " ";
+};
+
+}
+
+#endif // JOINROLE_H

client/3rd/SortFilterProxyModel/proxyroles/proxyrole.cpp

@@ -0,0 +1,46 @@
+#include "proxyrole.h"
+#include <QQmlEngine>
+#include <QQmlContext>
+#include <QQmlExpression>
+#include <QCoreApplication>
+#include <QDebug>
+#include <QQmlInfo>
+#include "filters/filter.h"
+#include "qqmlsortfilterproxymodel.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype ProxyRole
+    \inqmlmodule SortFilterProxyModel
+    \ingroup ProxyRoles
+    \brief Base type for the \l SortFilterProxyModel proxy roles.
+
+    The ProxyRole type cannot be used directly in a QML file.
+    It exists to provide a set of common properties and methods,
+    available across all the other proxy role types that inherit from it.
+    Attempting to use the ProxyRole type directly will result in an error.
+*/
+
+QVariant ProxyRole::roleData(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel, const QString &name)
+{
+    if (m_mutex.tryLock()) {
+        QVariant result = data(sourceIndex, proxyModel, name);
+        m_mutex.unlock();
+        return result;
+    } else {
+        return {};
+    }
+}
+
+void ProxyRole::proxyModelCompleted(const QQmlSortFilterProxyModel &proxyModel)
+{
+    Q_UNUSED(proxyModel)
+}
+
+void ProxyRole::invalidate()
+{
+    Q_EMIT invalidated();
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/proxyrole.h

@@ -0,0 +1,40 @@
+#ifndef PROXYROLE_H
+#define PROXYROLE_H
+
+#include <QObject>
+#include <QMutex>
+
+namespace qqsfpm {
+
+class QQmlSortFilterProxyModel;
+
+class ProxyRole : public QObject
+{
+    Q_OBJECT
+
+public:
+    using QObject::QObject;
+    virtual ~ProxyRole() = default;
+
+    QVariant roleData(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel, const QString& name);
+    virtual void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel);
+
+    virtual QStringList names() = 0;
+
+protected:
+    void invalidate();
+
+Q_SIGNALS:
+    void invalidated();
+    void namesAboutToBeChanged();
+    void namesChanged();
+
+private:
+    virtual QVariant data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel, const QString& name) = 0;
+
+    QMutex m_mutex;
+};
+
+}
+
+#endif // PROXYROLE_H

client/3rd/SortFilterProxyModel/proxyroles/proxyrolecontainer.cpp

@@ -0,0 +1,64 @@
+#include "proxyrolecontainer.h"
+
+namespace qqsfpm {
+
+QList<ProxyRole*> ProxyRoleContainer::proxyRoles() const
+{
+    return m_proxyRoles;
+}
+
+void ProxyRoleContainer::appendProxyRole(ProxyRole* proxyRole)
+{
+    m_proxyRoles.append(proxyRole);
+    onProxyRoleAppended(proxyRole);
+}
+
+void ProxyRoleContainer::removeProxyRole(ProxyRole* proxyRole)
+{
+    m_proxyRoles.removeOne(proxyRole);
+    onProxyRoleRemoved(proxyRole);
+}
+
+void ProxyRoleContainer::clearProxyRoles()
+{
+    m_proxyRoles.clear();
+    onProxyRolesCleared();
+}
+
+QQmlListProperty<ProxyRole> ProxyRoleContainer::proxyRolesListProperty()
+{
+    return QQmlListProperty<ProxyRole>(reinterpret_cast<QObject*>(this), &m_proxyRoles,
+                                    &ProxyRoleContainer::append_proxyRole,
+                                    &ProxyRoleContainer::count_proxyRole,
+                                    &ProxyRoleContainer::at_proxyRole,
+                                    &ProxyRoleContainer::clear_proxyRoles);
+}
+
+void ProxyRoleContainer::append_proxyRole(QQmlListProperty<ProxyRole>* list, ProxyRole* proxyRole)
+{
+    if (!proxyRole)
+        return;
+
+    ProxyRoleContainer* that = reinterpret_cast<ProxyRoleContainer*>(list->object);
+    that->appendProxyRole(proxyRole);
+}
+
+int ProxyRoleContainer::count_proxyRole(QQmlListProperty<ProxyRole>* list)
+{
+    QList<ProxyRole*>* ProxyRoles = static_cast<QList<ProxyRole*>*>(list->data);
+    return ProxyRoles->count();
+}
+
+ProxyRole* ProxyRoleContainer::at_proxyRole(QQmlListProperty<ProxyRole>* list, int index)
+{
+    QList<ProxyRole*>* ProxyRoles = static_cast<QList<ProxyRole*>*>(list->data);
+    return ProxyRoles->at(index);
+}
+
+void ProxyRoleContainer::clear_proxyRoles(QQmlListProperty<ProxyRole> *list)
+{
+    ProxyRoleContainer* that = reinterpret_cast<ProxyRoleContainer*>(list->object);
+    that->clearProxyRoles();
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/proxyrolecontainer.h

@@ -0,0 +1,42 @@
+#ifndef PROXYROLECONTAINER_H
+#define PROXYROLECONTAINER_H
+
+#include <QList>
+#include <QQmlListProperty>
+
+namespace qqsfpm {
+
+class ProxyRole;
+class QQmlSortFilterProxyModel;
+
+class ProxyRoleContainer {
+public:
+    virtual ~ProxyRoleContainer() = default;
+
+    QList<ProxyRole*> proxyRoles() const;
+    void appendProxyRole(ProxyRole* proxyRole);
+    void removeProxyRole(ProxyRole* proxyRole);
+    void clearProxyRoles();
+
+    QQmlListProperty<ProxyRole> proxyRolesListProperty();
+
+protected:
+    QList<ProxyRole*> m_proxyRoles;
+
+private:
+    virtual void onProxyRoleAppended(ProxyRole* proxyRole) = 0;
+    virtual void onProxyRoleRemoved(ProxyRole* proxyRole) = 0;
+    virtual void onProxyRolesCleared() = 0;
+
+    static void append_proxyRole(QQmlListProperty<ProxyRole>* list, ProxyRole* proxyRole);
+    static int count_proxyRole(QQmlListProperty<ProxyRole>* list);
+    static ProxyRole* at_proxyRole(QQmlListProperty<ProxyRole>* list, int index);
+    static void clear_proxyRoles(QQmlListProperty<ProxyRole>* list);
+};
+
+}
+
+#define ProxyRoleContainer_iid "fr.grecko.SortFilterProxyModel.ProxyRoleContainer"
+Q_DECLARE_INTERFACE(qqsfpm::ProxyRoleContainer, ProxyRoleContainer_iid)
+
+#endif // PROXYROLECONTAINER_H

client/3rd/SortFilterProxyModel/proxyroles/proxyrolesqmltypes.cpp

@@ -0,0 +1,23 @@
+#include "proxyrole.h"
+#include "joinrole.h"
+#include "switchrole.h"
+#include "expressionrole.h"
+#include "regexprole.h"
+#include "filterrole.h"
+#include <QQmlEngine>
+#include <QCoreApplication>
+
+namespace qqsfpm {
+
+void registerProxyRoleTypes() {
+    qmlRegisterUncreatableType<ProxyRole>("SortFilterProxyModel", 0, 2, "ProxyRole", "ProxyRole is an abstract class");
+    qmlRegisterType<JoinRole>("SortFilterProxyModel", 0, 2, "JoinRole");
+    qmlRegisterType<SwitchRole>("SortFilterProxyModel", 0, 2, "SwitchRole");
+    qmlRegisterType<ExpressionRole>("SortFilterProxyModel", 0, 2, "ExpressionRole");
+    qmlRegisterType<RegExpRole>("SortFilterProxyModel", 0, 2, "RegExpRole");
+    qmlRegisterType<FilterRole>("SortFilterProxyModel", 0, 2, "FilterRole");
+}
+
+Q_COREAPP_STARTUP_FUNCTION(registerProxyRoleTypes)
+
+}

client/3rd/SortFilterProxyModel/proxyroles/regexprole.cpp

@@ -0,0 +1,104 @@
+#include "regexprole.h"
+#include "qqmlsortfilterproxymodel.h"
+#include <QDebug>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype RegExpRole
+    \inherits ProxyRole
+    \inqmlmodule SortFilterProxyModel
+    \ingroup ProxyRoles
+    \brief A ProxyRole extracting data from a source role via a regular expression.
+
+    A RegExpRole is a \l ProxyRole that provides a role for each named capture group of its regular expression \l pattern.
+
+    In the following example, the \c date role of the source model will be extracted in 3 roles in the proxy moodel: \c year, \c month and \c day.
+    \code
+    SortFilterProxyModel {
+        sourceModel: eventModel
+        proxyRoles: RegExpRole {
+            roleName: "date"
+            pattern: "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"
+        }
+    }
+    \endcode
+*/
+
+/*!
+    \qmlproperty QString RegExpRole::roleName
+
+    This property holds the role name that the RegExpRole is using to query the source model's data to extract new roles from.
+*/
+QString RegExpRole::roleName() const
+{
+    return m_roleName;
+}
+
+void RegExpRole::setRoleName(const QString& roleName)
+{
+    if (m_roleName == roleName)
+        return;
+
+    m_roleName = roleName;
+    Q_EMIT roleNameChanged();
+}
+
+/*!
+    \qmlproperty QString RegExpRole::pattern
+
+    This property holds the pattern of the regular expression of this RegExpRole.
+    The RegExpRole will expose a role for each of the named capture group of the pattern.
+*/
+QString RegExpRole::pattern() const
+{
+    return m_regularExpression.pattern();
+}
+
+void RegExpRole::setPattern(const QString& pattern)
+{
+    if (m_regularExpression.pattern() == pattern)
+        return;
+
+    Q_EMIT namesAboutToBeChanged();
+    m_regularExpression.setPattern(pattern);
+    invalidate();
+    Q_EMIT patternChanged();
+    Q_EMIT namesChanged();
+}
+
+/*!
+    \qmlproperty Qt::CaseSensitivity RegExpRole::caseSensitivity
+
+    This property holds the caseSensitivity of the regular expression.
+*/
+Qt::CaseSensitivity RegExpRole::caseSensitivity() const
+{
+    return m_regularExpression.patternOptions() & QRegularExpression::CaseInsensitiveOption ?
+                Qt::CaseInsensitive : Qt::CaseSensitive;
+}
+
+void RegExpRole::setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)
+{
+    if (this->caseSensitivity() == caseSensitivity)
+        return;
+
+    m_regularExpression.setPatternOptions(m_regularExpression.patternOptions() ^ QRegularExpression::CaseInsensitiveOption); //toggle the option
+    Q_EMIT caseSensitivityChanged();
+}
+
+QStringList RegExpRole::names()
+{
+    QStringList nameCaptureGroups = m_regularExpression.namedCaptureGroups();
+    nameCaptureGroups.removeAll("");
+    return nameCaptureGroups;
+}
+
+QVariant RegExpRole::data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel, const QString &name)
+{
+    QString text = proxyModel.sourceData(sourceIndex, m_roleName).toString();
+    QRegularExpressionMatch match = m_regularExpression.match(text);
+    return match.hasMatch() ? (match.captured(name)) : QVariant{};
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/regexprole.h

@@ -0,0 +1,43 @@
+#ifndef REGEXPROLE_H
+#define REGEXPROLE_H
+
+#include "proxyrole.h"
+#include <QRegularExpression>
+
+namespace qqsfpm {
+
+class RegExpRole : public ProxyRole
+{
+    Q_OBJECT
+    Q_PROPERTY(QString roleName READ roleName WRITE setRoleName NOTIFY roleNameChanged)
+    Q_PROPERTY(QString pattern READ pattern WRITE setPattern NOTIFY patternChanged)
+    Q_PROPERTY(Qt::CaseSensitivity caseSensitivity READ caseSensitivity WRITE setCaseSensitivity NOTIFY caseSensitivityChanged)
+
+public:
+    using ProxyRole::ProxyRole;
+
+    QString roleName() const;
+    void setRoleName(const QString& roleName);
+
+    QString pattern() const;
+    void setPattern(const QString& pattern);
+
+    Qt::CaseSensitivity caseSensitivity() const;
+    void setCaseSensitivity(Qt::CaseSensitivity caseSensitivity);
+
+    QStringList names() override;
+
+Q_SIGNALS:
+    void roleNameChanged();
+    void patternChanged();    
+    void caseSensitivityChanged();
+
+private:
+    QString m_roleName;
+    QRegularExpression m_regularExpression;
+    QVariant data(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel &proxyModel, const QString &name) override;
+};
+
+}
+
+#endif // REGEXPROLE_H

client/3rd/SortFilterProxyModel/proxyroles/singlerole.cpp

@@ -0,0 +1,52 @@
+#include "singlerole.h"
+#include <QVariant>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype SingleRole
+    \qmlabstract
+    \inherits ProxyRole
+    \inqmlmodule SortFilterProxyModel
+    \ingroup ProxyRoles
+    \brief Base type for the \l SortFilterProxyModel proxy roles defining a single role.
+
+    SingleRole is a convenience base class for proxy roles who define a single role.
+    It cannot be used directly in a QML file.
+    It exists to provide a set of common properties and methods,
+    available across all the other proxy role types that inherit from it.
+    Attempting to use the SingleRole type directly will result in an error.
+*/
+/*!
+    \qmlproperty string SingleRole::name
+
+    This property holds the role name of the proxy role.
+*/
+QString SingleRole::name() const
+{
+    return m_name;
+}
+
+void SingleRole::setName(const QString& name)
+{
+    if (m_name == name)
+        return;
+
+    Q_EMIT namesAboutToBeChanged();
+    m_name = name;
+    Q_EMIT nameChanged();
+    Q_EMIT namesChanged();
+}
+
+QStringList SingleRole::names()
+{
+    return QStringList { m_name };
+}
+
+QVariant SingleRole::data(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel &proxyModel, const QString &name)
+{
+    Q_UNUSED(name);
+    return data(sourceIndex, proxyModel);
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/singlerole.h

@@ -0,0 +1,34 @@
+#ifndef SINGLEROLE_H
+#define SINGLEROLE_H
+
+#include "proxyrole.h"
+
+namespace qqsfpm {
+
+class SingleRole : public ProxyRole
+{
+    Q_OBJECT
+    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
+
+public:
+    using ProxyRole::ProxyRole;
+
+    QString name() const;
+    void setName(const QString& name);
+
+    QStringList names() override;
+
+Q_SIGNALS:
+    void nameChanged();
+
+private:
+    QString m_name;
+
+private:
+    QVariant data(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel &proxyModel, const QString &name) final;
+    virtual QVariant data(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel &proxyModel) = 0;
+};
+
+}
+
+#endif // SINGLEROLE_H

client/3rd/SortFilterProxyModel/proxyroles/switchrole.cpp

@@ -0,0 +1,168 @@
+#include "switchrole.h"
+#include "qqmlsortfilterproxymodel.h"
+#include "filters/filter.h"
+#include <QtQml>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype SwitchRole
+    \inherits SingleRole
+    \inqmlmodule SortFilterProxyModel
+    \ingroup ProxyRoles
+    \ingroup FilterContainer
+    \brief A role using \l Filter to conditionnaly compute its data.
+
+    A SwitchRole is a \l ProxyRole that computes its data with the help of \l Filter.
+    Each top level filters specified in the \l SwitchRole is evaluated on the rows of the model, if a \l Filter evaluates to true, the data of the \l SwitchRole for this row will be the one of the attached \l {value} {SwitchRole.value} property.
+    If no top level filters evaluate to true, the data will default to the one of the \l defaultRoleName (or the \l defaultValue if no \l defaultRoleName is specified).
+
+    In the following example, the \c favoriteOrFirstNameSection role is equal to \c * if the \c favorite role of a row is true, otherwise it's the same as the \c firstName role :
+    \code
+    SortFilterProxyModel {
+       sourceModel: contactModel
+       proxyRoles: SwitchRole {
+           name: "favoriteOrFirstNameSection"
+           filters: ValueFilter {
+               roleName: "favorite"
+               value: true
+               SwitchRole.value: "*"
+           }
+           defaultRoleName: "firstName"
+        }
+    }
+    \endcode
+    \sa FilterContainer
+*/
+SwitchRoleAttached::SwitchRoleAttached(QObject* parent) : QObject (parent)
+{
+    if (!qobject_cast<Filter*>(parent))
+        qmlInfo(parent) << "SwitchRole must be attached to a Filter";
+}
+
+/*!
+    \qmlattachedproperty var SwitchRole::value
+
+    This property attaches a value to a \l Filter.
+*/
+QVariant SwitchRoleAttached::value() const
+{
+    return m_value;
+}
+
+void SwitchRoleAttached::setValue(QVariant value)
+{
+    if (m_value == value)
+        return;
+
+    m_value = value;
+    Q_EMIT valueChanged();
+}
+
+/*!
+    \qmlproperty string SwitchRole::defaultRoleName
+
+    This property holds the default role name of the role.
+    If no filter match a row, the data of this role will be the data of the role whose name is \c defaultRoleName.
+*/
+QString SwitchRole::defaultRoleName() const
+{
+    return m_defaultRoleName;
+}
+
+void SwitchRole::setDefaultRoleName(const QString& defaultRoleName)
+{
+    if (m_defaultRoleName == defaultRoleName)
+        return;
+
+    m_defaultRoleName = defaultRoleName;
+    Q_EMIT defaultRoleNameChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty var SwitchRole::defaultValue
+
+    This property holds the default value of the role.
+    If no filter match a row, and no \l defaultRoleName is set, the data of this role will be \c defaultValue.
+*/
+QVariant SwitchRole::defaultValue() const
+{
+    return m_defaultValue;
+}
+
+void SwitchRole::setDefaultValue(const QVariant& defaultValue)
+{
+    if (m_defaultValue == defaultValue)
+        return;
+
+    m_defaultValue = defaultValue;
+    Q_EMIT defaultValueChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty list<Filter> SwitchRole::filters
+    \default
+
+    This property holds the list of filters for this proxy role.
+    The data of this role will be equal to the attached \l {value} {SwitchRole.value} property of the first filter that matches the model row.
+
+    \sa Filter, FilterContainer
+*/
+
+void SwitchRole::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    for (Filter* filter : m_filters)
+        filter->proxyModelCompleted(proxyModel);
+}
+
+SwitchRoleAttached* SwitchRole::qmlAttachedProperties(QObject* object)
+{
+    return new SwitchRoleAttached(object);
+}
+
+QVariant SwitchRole::data(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel &proxyModel)
+{
+    for (auto filter: m_filters) {
+        if (!filter->enabled())
+            continue;
+        if (filter->filterAcceptsRow(sourceIndex, proxyModel)) {
+            auto attached = static_cast<SwitchRoleAttached*>(qmlAttachedPropertiesObject<SwitchRole>(filter, false));
+            if (!attached) {
+                qWarning() << "No SwitchRole.value provided for this filter" << filter;
+                continue;
+            }
+            QVariant value = attached->value();
+            if (!value.isValid()) {
+                qWarning() << "No SwitchRole.value provided for this filter" << filter;
+                continue;
+            }
+            return value;
+        }
+    }
+    if (!m_defaultRoleName.isEmpty())
+        return proxyModel.sourceData(sourceIndex, m_defaultRoleName);
+    return m_defaultValue;
+}
+
+void SwitchRole::onFilterAppended(Filter *filter)
+{
+    connect(filter, &Filter::invalidated, this, &SwitchRole::invalidate);
+    auto attached = static_cast<SwitchRoleAttached*>(qmlAttachedPropertiesObject<SwitchRole>(filter, true));
+    connect(attached, &SwitchRoleAttached::valueChanged, this, &SwitchRole::invalidate);
+    invalidate();
+}
+
+void SwitchRole::onFilterRemoved(Filter *filter)
+{
+    Q_UNUSED(filter)
+    invalidate();
+}
+
+void SwitchRole::onFiltersCleared()
+{
+    invalidate();
+}
+
+}

client/3rd/SortFilterProxyModel/proxyroles/switchrole.h

@@ -0,0 +1,68 @@
+#ifndef SWITCHROLE_H
+#define SWITCHROLE_H
+
+#include "singlerole.h"
+#include "filters/filtercontainer.h"
+#include <QtQml>
+
+namespace qqsfpm {
+
+class SwitchRoleAttached : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
+public:
+    SwitchRoleAttached(QObject* parent);
+
+    QVariant value() const;
+    void setValue(QVariant value);
+
+Q_SIGNALS:
+    void valueChanged();
+
+private:
+    QVariant m_value;
+};
+
+class SwitchRole : public SingleRole, public FilterContainer
+{
+    Q_OBJECT
+    Q_INTERFACES(qqsfpm::FilterContainer)
+    Q_PROPERTY(QString defaultRoleName READ defaultRoleName WRITE setDefaultRoleName NOTIFY defaultRoleNameChanged)
+    Q_PROPERTY(QVariant defaultValue READ defaultValue WRITE setDefaultValue NOTIFY defaultValueChanged)
+    Q_PROPERTY(QQmlListProperty<qqsfpm::Filter> filters READ filtersListProperty)
+    Q_CLASSINFO("DefaultProperty", "filters")
+
+public:
+    using SingleRole::SingleRole;
+
+    QString defaultRoleName() const;
+    void setDefaultRoleName(const QString& defaultRoleName);
+
+    QVariant defaultValue() const;
+    void setDefaultValue(const QVariant& defaultValue);
+
+    void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel) override;
+
+    static SwitchRoleAttached* qmlAttachedProperties(QObject* object);
+
+Q_SIGNALS:
+    void defaultRoleNameChanged();
+    void defaultValueChanged();
+
+private:
+    QVariant data(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) override;
+
+    void onFilterAppended(Filter *filter) override;
+    void onFilterRemoved(Filter *filter) override;
+    void onFiltersCleared() override;
+
+    QString m_defaultRoleName;
+    QVariant m_defaultValue;
+};
+
+}
+
+QML_DECLARE_TYPEINFO(qqsfpm::SwitchRole, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // SWITCHROLE_H

client/3rd/SortFilterProxyModel/qqmlsortfilterproxymodel.cpp

@@ -0,0 +1,579 @@
+#include "qqmlsortfilterproxymodel.h"
+#include <QtQml>
+#include <algorithm>
+#include "filters/filter.h"
+#include "sorters/sorter.h"
+#include "proxyroles/proxyrole.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype SortFilterProxyModel
+    \inqmlmodule SortFilterProxyModel
+    \ingroup SortFilterProxyModel
+    \ingroup FilterContainer
+    \ingroup SorterContainer
+    \brief Filters and sorts data coming from a source \l {http://doc.qt.io/qt-5/qabstractitemmodel.html} {QAbstractItemModel}.
+
+    The SortFilterProxyModel type provides support for filtering and sorting data coming from a source model.
+    \sa FilterContainer, SorterContainer
+*/
+QQmlSortFilterProxyModel::QQmlSortFilterProxyModel(QObject *parent) :
+    QSortFilterProxyModel(parent),
+#ifdef SFPM_DELAYED
+    m_delayed(true)
+#else
+    m_delayed(false)
+#endif
+{
+    connect(this, &QAbstractProxyModel::sourceModelChanged, this, &QQmlSortFilterProxyModel::updateRoles);
+    connect(this, &QAbstractItemModel::modelReset, this, &QQmlSortFilterProxyModel::updateRoles);
+    connect(this, &QAbstractItemModel::rowsInserted, this, &QQmlSortFilterProxyModel::countChanged);
+    connect(this, &QAbstractItemModel::rowsRemoved, this, &QQmlSortFilterProxyModel::countChanged);
+    connect(this, &QAbstractItemModel::modelReset, this, &QQmlSortFilterProxyModel::countChanged);
+    connect(this, &QAbstractItemModel::layoutChanged, this, &QQmlSortFilterProxyModel::countChanged);
+    connect(this, &QAbstractItemModel::dataChanged, this, &QQmlSortFilterProxyModel::onDataChanged);
+    setDynamicSortFilter(true);
+}
+
+/*!
+    \qmlproperty QAbstractItemModel* SortFilterProxyModel::sourceModel
+
+    The source model of this proxy model
+*/
+
+/*!
+    \qmlproperty int SortFilterProxyModel::count
+
+    The number of rows in the proxy model (not filtered out the source model)
+*/
+int QQmlSortFilterProxyModel::count() const
+{
+    return rowCount();
+}
+
+/*!
+    \qmlproperty bool SortFilterProxyModel::delayed
+
+    Delay the execution of filters, sorters and proxyRoles until the next event loop.
+    This can be used as an optimization when multiple filters, sorters or proxyRoles are changed in a single event loop.
+    They will be executed once in a single batch at the next event loop instead of being executed in multiple sequential batches.
+
+    By default, the SortFilterProxyModel is not delayed, unless the \c SFPM_DELAYED environment variable is defined at compile time.
+*/
+bool QQmlSortFilterProxyModel::delayed() const
+{
+    return m_delayed;
+}
+
+void QQmlSortFilterProxyModel::setDelayed(bool delayed)
+{
+    if (m_delayed == delayed)
+        return;
+
+    m_delayed = delayed;
+    Q_EMIT delayedChanged();
+}
+
+const QString& QQmlSortFilterProxyModel::filterRoleName() const
+{
+    return m_filterRoleName;
+}
+
+void QQmlSortFilterProxyModel::setFilterRoleName(const QString& filterRoleName)
+{
+    if (m_filterRoleName == filterRoleName)
+        return;
+
+    m_filterRoleName = filterRoleName;
+    updateFilterRole();
+    Q_EMIT filterRoleNameChanged();
+}
+
+QString QQmlSortFilterProxyModel::filterPattern() const
+{
+    return filterRegExp().pattern();
+}
+
+void QQmlSortFilterProxyModel::setFilterPattern(const QString& filterPattern)
+{
+    QRegExp regExp = filterRegExp();
+    if (regExp.pattern() == filterPattern)
+        return;
+
+    regExp.setPattern(filterPattern);
+    QSortFilterProxyModel::setFilterRegExp(regExp);
+    Q_EMIT filterPatternChanged();
+}
+
+QQmlSortFilterProxyModel::PatternSyntax QQmlSortFilterProxyModel::filterPatternSyntax() const
+{
+    return static_cast<PatternSyntax>(filterRegExp().patternSyntax());
+}
+
+void QQmlSortFilterProxyModel::setFilterPatternSyntax(QQmlSortFilterProxyModel::PatternSyntax patternSyntax)
+{
+    QRegExp regExp = filterRegExp();
+    QRegExp::PatternSyntax patternSyntaxTmp = static_cast<QRegExp::PatternSyntax>(patternSyntax);
+    if (regExp.patternSyntax() == patternSyntaxTmp)
+        return;
+
+    regExp.setPatternSyntax(patternSyntaxTmp);
+    QSortFilterProxyModel::setFilterRegExp(regExp);
+    Q_EMIT filterPatternSyntaxChanged();
+}
+
+const QVariant& QQmlSortFilterProxyModel::filterValue() const
+{
+    return m_filterValue;
+}
+
+void QQmlSortFilterProxyModel::setFilterValue(const QVariant& filterValue)
+{
+    if (m_filterValue == filterValue)
+        return;
+
+    m_filterValue = filterValue;
+    queueInvalidateFilter();
+    Q_EMIT filterValueChanged();
+}
+
+/*!
+    \qmlproperty string SortFilterProxyModel::sortRoleName
+
+    The role name of the source model's data used for the sorting.
+
+    \sa {http://doc.qt.io/qt-5/qsortfilterproxymodel.html#sortRole-prop} {sortRole}, roleForName
+*/
+const QString& QQmlSortFilterProxyModel::sortRoleName() const
+{
+    return m_sortRoleName;
+}
+
+void QQmlSortFilterProxyModel::setSortRoleName(const QString& sortRoleName)
+{
+    if (m_sortRoleName == sortRoleName)
+        return;
+
+    m_sortRoleName = sortRoleName;
+    updateSortRole();
+    Q_EMIT sortRoleNameChanged();
+}
+
+bool QQmlSortFilterProxyModel::ascendingSortOrder() const
+{
+    return m_ascendingSortOrder;
+}
+
+void QQmlSortFilterProxyModel::setAscendingSortOrder(bool ascendingSortOrder)
+{
+    if (m_ascendingSortOrder == ascendingSortOrder)
+        return;
+
+    m_ascendingSortOrder = ascendingSortOrder;
+    Q_EMIT ascendingSortOrderChanged();
+    queueInvalidate();
+}
+
+/*!
+    \qmlproperty list<Filter> SortFilterProxyModel::filters
+
+    This property holds the list of filters for this proxy model. To be included in the model, a row of the source model has to be accepted by all the top level filters of this list.
+
+    \sa Filter, FilterContainer
+*/
+
+/*!
+    \qmlproperty list<Sorter> SortFilterProxyModel::sorters
+
+    This property holds the list of sorters for this proxy model. The rows of the source model are sorted by the sorters of this list, in their order of insertion.
+
+    \sa Sorter, SorterContainer
+*/
+
+/*!
+    \qmlproperty list<ProxyRole> SortFilterProxyModel::proxyRoles
+
+    This property holds the list of proxy roles for this proxy model. Each proxy role adds a new custom role to the model.
+
+    \sa ProxyRole
+*/
+
+void QQmlSortFilterProxyModel::classBegin()
+{
+
+}
+
+void QQmlSortFilterProxyModel::componentComplete()
+{
+    m_completed = true;
+
+    for (const auto& filter : m_filters)
+        filter->proxyModelCompleted(*this);
+    for (const auto& sorter : m_sorters)
+        sorter->proxyModelCompleted(*this);
+    for (const auto& proxyRole : m_proxyRoles)
+        proxyRole->proxyModelCompleted(*this);
+
+    invalidate();
+    sort(0);
+}
+
+QVariant QQmlSortFilterProxyModel::sourceData(const QModelIndex& sourceIndex, const QString& roleName) const
+{
+    int role = roleNames().key(roleName.toUtf8());
+    return sourceData(sourceIndex, role);
+}
+
+QVariant QQmlSortFilterProxyModel::sourceData(const QModelIndex &sourceIndex, int role) const
+{
+    QPair<ProxyRole*, QString> proxyRolePair = m_proxyRoleMap[role];
+    if (ProxyRole* proxyRole = proxyRolePair.first)
+        return proxyRole->roleData(sourceIndex, *this, proxyRolePair.second);
+    else
+        return sourceModel()->data(sourceIndex, role);
+}
+
+QVariant QQmlSortFilterProxyModel::data(const QModelIndex &index, int role) const
+{
+    return sourceData(mapToSource(index), role);
+}
+
+QHash<int, QByteArray> QQmlSortFilterProxyModel::roleNames() const
+{
+    return m_roleNames.isEmpty() && sourceModel() ? sourceModel()->roleNames() : m_roleNames;
+}
+
+/*!
+    \qmlmethod int SortFilterProxyModel::roleForName(string roleName)
+
+    Returns the role number for the given \a roleName.
+    If no role is found for this \a roleName, \c -1 is returned.
+*/
+
+int QQmlSortFilterProxyModel::roleForName(const QString& roleName) const
+{
+    return m_roleNames.key(roleName.toUtf8(), -1);
+}
+
+/*!
+    \qmlmethod object SortFilterProxyModel::get(int row)
+
+    Return the item at \a row in the proxy model as a map of all its roles. This allows the item data to be read (not modified) from JavaScript.
+*/
+QVariantMap QQmlSortFilterProxyModel::get(int row) const
+{
+    QVariantMap map;
+    QModelIndex modelIndex = index(row, 0);
+    QHash<int, QByteArray> roles = roleNames();
+    for (QHash<int, QByteArray>::const_iterator it = roles.begin(); it != roles.end(); ++it)
+        map.insert(it.value(), data(modelIndex, it.key()));
+    return map;
+}
+
+/*!
+    \qmlmethod variant SortFilterProxyModel::get(int row, string roleName)
+
+    Return the data for the given \a roleName of the item at \a row in the proxy model. This allows the role data to be read (not modified) from JavaScript.
+    This equivalent to calling \c {data(index(row, 0), roleForName(roleName))}.
+*/
+QVariant QQmlSortFilterProxyModel::get(int row, const QString& roleName) const
+{
+    return data(index(row, 0), roleForName(roleName));
+}
+
+/*!
+    \qmlmethod index SortFilterProxyModel::mapToSource(index proxyIndex)
+
+    Returns the source model index corresponding to the given \a proxyIndex from the SortFilterProxyModel.
+*/
+QModelIndex QQmlSortFilterProxyModel::mapToSource(const QModelIndex& proxyIndex) const
+{
+    return QSortFilterProxyModel::mapToSource(proxyIndex);
+}
+
+/*!
+    \qmlmethod int SortFilterProxyModel::mapToSource(int proxyRow)
+
+    Returns the source model row corresponding to the given \a proxyRow from the SortFilterProxyModel.
+    Returns -1 if there is no corresponding row.
+*/
+int QQmlSortFilterProxyModel::mapToSource(int proxyRow) const
+{
+    QModelIndex proxyIndex = index(proxyRow, 0);
+    QModelIndex sourceIndex = mapToSource(proxyIndex);
+    return sourceIndex.isValid() ? sourceIndex.row() : -1;
+}
+
+/*!
+    \qmlmethod QModelIndex SortFilterProxyModel::mapFromSource(QModelIndex sourceIndex)
+
+    Returns the model index in the SortFilterProxyModel given the \a sourceIndex from the source model.
+*/
+QModelIndex QQmlSortFilterProxyModel::mapFromSource(const QModelIndex& sourceIndex) const
+{
+    return QSortFilterProxyModel::mapFromSource(sourceIndex);
+}
+
+/*!
+    \qmlmethod int SortFilterProxyModel::mapFromSource(int sourceRow)
+
+    Returns the row in the SortFilterProxyModel given the \a sourceRow from the source model.
+    Returns -1 if there is no corresponding row.
+*/
+int QQmlSortFilterProxyModel::mapFromSource(int sourceRow) const
+{
+    QModelIndex proxyIndex;
+    if (QAbstractItemModel* source = sourceModel()) {
+        QModelIndex sourceIndex = source->index(sourceRow, 0);
+        proxyIndex = mapFromSource(sourceIndex);
+    }
+    return proxyIndex.isValid() ? proxyIndex.row() : -1;
+}
+
+bool QQmlSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
+{
+    if (!m_completed)
+        return true;
+    QModelIndex sourceIndex = sourceModel()->index(source_row, 0, source_parent);
+    bool valueAccepted = !m_filterValue.isValid() || ( m_filterValue == sourceModel()->data(sourceIndex, filterRole()) );
+    bool baseAcceptsRow = valueAccepted && QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
+    baseAcceptsRow = baseAcceptsRow && std::all_of(m_filters.begin(), m_filters.end(),
+        [=, &source_parent] (Filter* filter) {
+            return filter->filterAcceptsRow(sourceIndex, *this);
+        }
+    );
+    return baseAcceptsRow;
+}
+
+bool QQmlSortFilterProxyModel::lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const
+{
+    if (m_completed) {
+        if (!m_sortRoleName.isEmpty()) {
+            if (QSortFilterProxyModel::lessThan(source_left, source_right))
+                return m_ascendingSortOrder;
+            if (QSortFilterProxyModel::lessThan(source_right, source_left))
+                return !m_ascendingSortOrder;
+        }
+        auto sortedSorters = m_sorters;
+        std::stable_sort(sortedSorters.begin(),
+                         sortedSorters.end(),
+                         [] (Sorter* a, Sorter* b) {
+                             return a->priority() > b->priority();
+                         });
+        for(auto sorter : sortedSorters) {
+            if (sorter->enabled()) {
+                int comparison = sorter->compareRows(source_left, source_right, *this);
+                if (comparison != 0)
+                    return comparison < 0;
+            }
+        }
+    }
+    return source_left.row() < source_right.row();
+}
+
+void QQmlSortFilterProxyModel::resetInternalData()
+{
+    QSortFilterProxyModel::resetInternalData();
+    updateRoleNames();
+}
+
+void QQmlSortFilterProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
+{
+    if (sourceModel && sourceModel->roleNames().isEmpty()) { // workaround for when a model has no roles and roles are added when the model is populated (ListModel)
+        // QTBUG-57971
+        connect(sourceModel, &QAbstractItemModel::rowsInserted, this, &QQmlSortFilterProxyModel::initRoles);
+    }
+    QSortFilterProxyModel::setSourceModel(sourceModel);
+}
+
+void QQmlSortFilterProxyModel::queueInvalidateFilter()
+{
+    if (m_delayed) {
+        if (!m_invalidateFilterQueued && !m_invalidateQueued) {
+            m_invalidateFilterQueued = true;
+            QMetaObject::invokeMethod(this, "invalidateFilter", Qt::QueuedConnection);
+        }
+    } else {
+        invalidateFilter();
+    }
+}
+
+void QQmlSortFilterProxyModel::invalidateFilter()
+{
+    m_invalidateFilterQueued = false;
+    if (m_completed && !m_invalidateQueued)
+        QSortFilterProxyModel::invalidateFilter();
+}
+
+void QQmlSortFilterProxyModel::queueInvalidate()
+{
+    if (m_delayed) {
+        if (!m_invalidateQueued) {
+            m_invalidateQueued = true;
+            QMetaObject::invokeMethod(this, "invalidate", Qt::QueuedConnection);
+        }
+    } else {
+        invalidate();
+    }
+}
+
+void QQmlSortFilterProxyModel::invalidate()
+{
+    m_invalidateQueued = false;
+    if (m_completed)
+        QSortFilterProxyModel::invalidate();
+}
+
+void QQmlSortFilterProxyModel::updateRoleNames()
+{
+    if (!sourceModel())
+        return;
+    m_roleNames = sourceModel()->roleNames();
+    m_proxyRoleMap.clear();
+    m_proxyRoleNumbers.clear();
+
+    auto roles = m_roleNames.keys();
+    auto maxIt = std::max_element(roles.cbegin(), roles.cend());
+    int maxRole = maxIt != roles.cend() ? *maxIt : -1;
+    for (auto proxyRole : m_proxyRoles) {
+        for (auto roleName : proxyRole->names()) {
+            ++maxRole;
+            m_roleNames[maxRole] = roleName.toUtf8();
+            m_proxyRoleMap[maxRole] = {proxyRole, roleName};
+            m_proxyRoleNumbers.append(maxRole);
+        }
+    }
+}
+
+void QQmlSortFilterProxyModel::updateFilterRole()
+{
+    QList<int> filterRoles = roleNames().keys(m_filterRoleName.toUtf8());
+    if (!filterRoles.empty())
+    {
+        setFilterRole(filterRoles.first());
+    }
+}
+
+void QQmlSortFilterProxyModel::updateSortRole()
+{
+    QList<int> sortRoles = roleNames().keys(m_sortRoleName.toUtf8());
+    if (!sortRoles.empty())
+    {
+        setSortRole(sortRoles.first());
+        queueInvalidate();
+    }
+}
+
+void QQmlSortFilterProxyModel::updateRoles()
+{
+    updateFilterRole();
+    updateSortRole();
+}
+
+void QQmlSortFilterProxyModel::initRoles()
+{
+    disconnect(sourceModel(), &QAbstractItemModel::rowsInserted, this, &QQmlSortFilterProxyModel::initRoles);
+    resetInternalData();
+    updateRoles();
+}
+
+void QQmlSortFilterProxyModel::onDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles)
+{
+    Q_UNUSED(roles);
+    if (!roles.isEmpty() && !m_proxyRoleNumbers.empty() && roles != m_proxyRoleNumbers)
+        Q_EMIT dataChanged(topLeft, bottomRight, m_proxyRoleNumbers);
+}
+
+void QQmlSortFilterProxyModel::queueInvalidateProxyRoles()
+{
+    queueInvalidate();
+    if (m_delayed) {
+        if (!m_invalidateProxyRolesQueued) {
+            m_invalidateProxyRolesQueued = true;
+            QMetaObject::invokeMethod(this, "invalidateProxyRoles", Qt::QueuedConnection);
+        }
+    } else {
+        invalidateProxyRoles();
+    }
+}
+
+void QQmlSortFilterProxyModel::invalidateProxyRoles()
+{
+    m_invalidateProxyRolesQueued = false;
+    if (m_completed)
+        Q_EMIT dataChanged(index(0,0), index(rowCount() - 1, columnCount() - 1), m_proxyRoleNumbers);
+}
+
+QVariantMap QQmlSortFilterProxyModel::modelDataMap(const QModelIndex& modelIndex) const
+{
+    QVariantMap map;
+    QHash<int, QByteArray> roles = roleNames();
+    for (QHash<int, QByteArray>::const_iterator it = roles.begin(); it != roles.end(); ++it)
+        map.insert(it.value(), sourceModel()->data(modelIndex, it.key()));
+    return map;
+}
+
+void QQmlSortFilterProxyModel::onFilterAppended(Filter* filter)
+{
+    connect(filter, &Filter::invalidated, this, &QQmlSortFilterProxyModel::queueInvalidateFilter);
+    queueInvalidateFilter();
+}
+
+void QQmlSortFilterProxyModel::onFilterRemoved(Filter* filter)
+{
+    Q_UNUSED(filter)
+    queueInvalidateFilter();
+}
+
+void QQmlSortFilterProxyModel::onFiltersCleared()
+{
+    queueInvalidateFilter();
+}
+
+void QQmlSortFilterProxyModel::onSorterAppended(Sorter* sorter)
+{
+    connect(sorter, &Sorter::invalidated, this, &QQmlSortFilterProxyModel::queueInvalidate);
+    queueInvalidate();
+}
+
+void QQmlSortFilterProxyModel::onSorterRemoved(Sorter* sorter)
+{
+    Q_UNUSED(sorter)
+    queueInvalidate();
+}
+
+void QQmlSortFilterProxyModel::onSortersCleared()
+{
+    queueInvalidate();
+}
+
+void QQmlSortFilterProxyModel::onProxyRoleAppended(ProxyRole *proxyRole)
+{
+    beginResetModel();
+    connect(proxyRole, &ProxyRole::invalidated, this, &QQmlSortFilterProxyModel::queueInvalidateProxyRoles);
+    connect(proxyRole, &ProxyRole::namesAboutToBeChanged, this, &QQmlSortFilterProxyModel::beginResetModel);
+    connect(proxyRole, &ProxyRole::namesChanged, this, &QQmlSortFilterProxyModel::endResetModel);
+    endResetModel();
+}
+
+void QQmlSortFilterProxyModel::onProxyRoleRemoved(ProxyRole *proxyRole)
+{
+    Q_UNUSED(proxyRole)
+    beginResetModel();
+    endResetModel();
+}
+
+void QQmlSortFilterProxyModel::onProxyRolesCleared()
+{
+    beginResetModel();
+    endResetModel();
+}
+
+void registerQQmlSortFilterProxyModelTypes() {
+    qmlRegisterType<QQmlSortFilterProxyModel>("SortFilterProxyModel", 0, 2, "SortFilterProxyModel");
+}
+
+Q_COREAPP_STARTUP_FUNCTION(registerQQmlSortFilterProxyModelTypes)
+
+}

client/3rd/SortFilterProxyModel/qqmlsortfilterproxymodel.h

@@ -0,0 +1,160 @@
+#ifndef QQMLSORTFILTERPROXYMODEL_H
+#define QQMLSORTFILTERPROXYMODEL_H
+
+#include <QSortFilterProxyModel>
+#include <QQmlParserStatus>
+#include "filters/filtercontainer.h"
+#include "sorters/sortercontainer.h"
+#include "proxyroles/proxyrolecontainer.h"
+
+namespace qqsfpm {
+
+class QQmlSortFilterProxyModel : public QSortFilterProxyModel,
+                                 public QQmlParserStatus,
+                                 public FilterContainer,
+                                 public SorterContainer,
+                                 public ProxyRoleContainer
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+    Q_INTERFACES(qqsfpm::FilterContainer)
+    Q_INTERFACES(qqsfpm::SorterContainer)
+    Q_INTERFACES(qqsfpm::ProxyRoleContainer)
+
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(bool delayed READ delayed WRITE setDelayed NOTIFY delayedChanged)
+
+    Q_PROPERTY(QString filterRoleName READ filterRoleName WRITE setFilterRoleName NOTIFY filterRoleNameChanged)
+    Q_PROPERTY(QString filterPattern READ filterPattern WRITE setFilterPattern NOTIFY filterPatternChanged)
+    Q_PROPERTY(PatternSyntax filterPatternSyntax READ filterPatternSyntax WRITE setFilterPatternSyntax NOTIFY filterPatternSyntaxChanged)
+    Q_PROPERTY(QVariant filterValue READ filterValue WRITE setFilterValue NOTIFY filterValueChanged)
+
+    Q_PROPERTY(QString sortRoleName READ sortRoleName WRITE setSortRoleName NOTIFY sortRoleNameChanged)
+    Q_PROPERTY(bool ascendingSortOrder READ ascendingSortOrder WRITE setAscendingSortOrder NOTIFY ascendingSortOrderChanged)
+
+    Q_PROPERTY(QQmlListProperty<qqsfpm::Filter> filters READ filtersListProperty)
+    Q_PROPERTY(QQmlListProperty<qqsfpm::Sorter> sorters READ sortersListProperty)
+    Q_PROPERTY(QQmlListProperty<qqsfpm::ProxyRole> proxyRoles READ proxyRolesListProperty)
+
+public:
+    enum PatternSyntax {
+        RegExp = QRegExp::RegExp,
+        Wildcard = QRegExp::Wildcard,
+        FixedString = QRegExp::FixedString,
+        RegExp2 = QRegExp::RegExp2,
+        WildcardUnix = QRegExp::WildcardUnix,
+        W3CXmlSchema11 = QRegExp::W3CXmlSchema11 };
+    Q_ENUMS(PatternSyntax)
+
+    QQmlSortFilterProxyModel(QObject* parent = 0);
+
+    int count() const;
+
+    bool delayed() const;
+    void setDelayed(bool delayed);
+
+    const QString& filterRoleName() const;
+    void setFilterRoleName(const QString& filterRoleName);
+
+    QString filterPattern() const;
+    void setFilterPattern(const QString& filterPattern);
+
+    PatternSyntax filterPatternSyntax() const;
+    void setFilterPatternSyntax(PatternSyntax patternSyntax);
+
+    const QVariant& filterValue() const;
+    void setFilterValue(const QVariant& filterValue);
+
+    const QString& sortRoleName() const;
+    void setSortRoleName(const QString& sortRoleName);
+
+    bool ascendingSortOrder() const;
+    void setAscendingSortOrder(bool ascendingSortOrder);
+
+    void classBegin() override;
+    void componentComplete() override;
+
+    QVariant sourceData(const QModelIndex& sourceIndex, const QString& roleName) const;
+    QVariant sourceData(const QModelIndex& sourceIndex, int role) const;
+
+    QVariant data(const QModelIndex& index, int role) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE int roleForName(const QString& roleName) const;
+
+    Q_INVOKABLE QVariantMap get(int row) const;
+    Q_INVOKABLE QVariant get(int row, const QString& roleName) const;
+
+    Q_INVOKABLE QModelIndex mapToSource(const QModelIndex& proxyIndex) const override;
+    Q_INVOKABLE int mapToSource(int proxyRow) const;
+    Q_INVOKABLE QModelIndex mapFromSource(const QModelIndex& sourceIndex) const override;
+    Q_INVOKABLE int mapFromSource(int sourceRow) const;
+
+    void setSourceModel(QAbstractItemModel *sourceModel) override;
+
+Q_SIGNALS:
+    void countChanged();
+    void delayedChanged();
+
+    void filterRoleNameChanged();
+    void filterPatternSyntaxChanged();
+    void filterPatternChanged();
+    void filterValueChanged();
+
+    void sortRoleNameChanged();
+    void ascendingSortOrderChanged();
+
+protected:
+    bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const override;
+    bool lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const override;
+
+protected Q_SLOTS:
+    void resetInternalData();
+
+private Q_SLOTS:
+    void queueInvalidateFilter();
+    void invalidateFilter();
+    void queueInvalidate();
+    void invalidate();
+    void updateRoleNames();
+    void updateFilterRole();
+    void updateSortRole();
+    void updateRoles();
+    void initRoles();
+    void onDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight, const QVector<int>& roles);
+    void queueInvalidateProxyRoles();
+    void invalidateProxyRoles();
+
+private:
+    QVariantMap modelDataMap(const QModelIndex& modelIndex) const;
+
+    void onFilterAppended(Filter* filter) override;
+    void onFilterRemoved(Filter* filter) override;
+    void onFiltersCleared() override;
+
+    void onSorterAppended(Sorter* sorter) override;
+    void onSorterRemoved(Sorter* sorter) override;
+    void onSortersCleared() override;
+
+    void onProxyRoleAppended(ProxyRole *proxyRole) override;
+    void onProxyRoleRemoved(ProxyRole *proxyRole) override;
+    void onProxyRolesCleared() override;
+
+    bool m_delayed;
+    QString m_filterRoleName;
+    QVariant m_filterValue;
+    QString m_sortRoleName;
+    bool m_ascendingSortOrder = true;
+    bool m_completed = false;
+    QHash<int, QByteArray> m_roleNames;
+    QHash<int, QPair<ProxyRole*, QString>> m_proxyRoleMap;
+    QVector<int> m_proxyRoleNumbers;
+
+    bool m_invalidateFilterQueued = false;
+    bool m_invalidateQueued = false;
+    bool m_invalidateProxyRolesQueued = false;
+};
+
+}
+
+#endif // QQMLSORTFILTERPROXYMODEL_H

client/3rd/SortFilterProxyModel/sorters/expressionsorter.cpp

@@ -0,0 +1,146 @@
+#include "expressionsorter.h"
+#include "qqmlsortfilterproxymodel.h"
+#include <QtQml>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype ExpressionSorter
+    \inherits Sorter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Sorters
+    \brief Sorts row with a custom javascript expression.
+
+    An ExpressionSorter is a \l Sorter allowing to implement custom sorting based on a javascript expression.
+*/
+
+/*!
+    \qmlproperty expression ExpressionSorter::expression
+
+    An expression to implement custom sorting. It must evaluate to a bool.
+    It has the same syntax has a \l {http://doc.qt.io/qt-5/qtqml-syntax-propertybinding.html} {Property Binding}, except that it will be evaluated for each of the source model's rows.
+    Model data is accessible for both rows with the \c modelLeft, and \c modelRight properties:
+
+    \code
+    sorters: ExpressionSorter {
+        expression: {
+            return modelLeft.someRole < modelRight.someRole;
+        }
+    }
+    \endcode
+
+    The \c index of the row is also available through \c modelLeft and \c modelRight.
+
+    The expression should return \c true if the value of the left item is less than the value of the right item, otherwise returns false.
+
+    This expression is reevaluated for a row every time its model data changes.
+    When an external property (not \c index* or in \c model*) the expression depends on changes, the expression is reevaluated for every row of the source model.
+    To capture the properties the expression depends on, the expression is first executed with invalid data and each property access is detected by the QML engine.
+    This means that if a property is not accessed because of a conditional, it won't be captured and the expression won't be reevaluted when this property changes.
+
+    A workaround to this problem is to access all the properties the expressions depends unconditionally at the beggining of the expression.
+*/
+const QQmlScriptString& ExpressionSorter::expression() const
+{
+    return m_scriptString;
+}
+
+void ExpressionSorter::setExpression(const QQmlScriptString& scriptString)
+{
+    if (m_scriptString == scriptString)
+        return;
+
+    m_scriptString = scriptString;
+    updateExpression();
+
+    Q_EMIT expressionChanged();
+    invalidate();
+}
+
+void ExpressionSorter::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    updateContext(proxyModel);
+}
+
+bool evaluateBoolExpression(QQmlExpression& expression)
+{
+    QVariant variantResult = expression.evaluate();
+    if (expression.hasError()) {
+        qWarning() << expression.error();
+        return false;
+    }
+    if (variantResult.canConvert<bool>()) {
+        return variantResult.toBool();
+    } else {
+        qWarning("%s:%i:%i : Can't convert result to bool",
+                 expression.sourceFile().toUtf8().data(),
+                 expression.lineNumber(),
+                 expression.columnNumber());
+        return false;
+    }
+}
+
+int ExpressionSorter::compare(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    if (!m_scriptString.isEmpty()) {
+        QVariantMap modelLeftMap, modelRightMap;
+        QHash<int, QByteArray> roles = proxyModel.roleNames();
+
+        QQmlContext context(qmlContext(this));
+
+        for (auto it = roles.cbegin(); it != roles.cend(); ++it) {
+            modelLeftMap.insert(it.value(), proxyModel.sourceData(sourceLeft, it.key()));
+            modelRightMap.insert(it.value(), proxyModel.sourceData(sourceRight, it.key()));
+        }
+        modelLeftMap.insert("index", sourceLeft.row());
+        modelRightMap.insert("index", sourceRight.row());
+
+        QQmlExpression expression(m_scriptString, &context);
+
+        context.setContextProperty("modelLeft", modelLeftMap);
+        context.setContextProperty("modelRight", modelRightMap);
+        if (evaluateBoolExpression(expression))
+                return -1;
+
+        context.setContextProperty("modelLeft", modelRightMap);
+        context.setContextProperty("modelRight", modelLeftMap);
+        if (evaluateBoolExpression(expression))
+                return 1;
+    }
+    return 0;
+}
+
+void ExpressionSorter::updateContext(const QQmlSortFilterProxyModel& proxyModel)
+{
+    delete m_context;
+    m_context = new QQmlContext(qmlContext(this), this);
+
+    QVariantMap modelLeftMap, modelRightMap;
+    // what about roles changes ?
+
+    for (const QByteArray& roleName : proxyModel.roleNames().values()) {
+        modelLeftMap.insert(roleName, QVariant());
+        modelRightMap.insert(roleName, QVariant());
+    }
+    modelLeftMap.insert("index", -1);
+    modelRightMap.insert("index", -1);
+
+    m_context->setContextProperty("modelLeft", modelLeftMap);
+    m_context->setContextProperty("modelRight", modelRightMap);
+
+    updateExpression();
+}
+
+void ExpressionSorter::updateExpression()
+{
+    if (!m_context)
+        return;
+
+    delete m_expression;
+    m_expression = new QQmlExpression(m_scriptString, m_context, 0, this);
+    connect(m_expression, &QQmlExpression::valueChanged, this, &ExpressionSorter::invalidate);
+    m_expression->setNotifyOnValueChanged(true);
+    m_expression->evaluate();
+}
+
+}

client/3rd/SortFilterProxyModel/sorters/expressionsorter.h

@@ -0,0 +1,43 @@
+#ifndef EXPRESSIONSORTER_H
+#define EXPRESSIONSORTER_H
+
+#include "sorter.h"
+#include <QQmlScriptString>
+
+class QQmlExpression;
+
+namespace qqsfpm {
+
+class QQmlSortFilterProxyModel;
+
+class ExpressionSorter : public Sorter
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlScriptString expression READ expression WRITE setExpression NOTIFY expressionChanged)
+
+public:
+    using Sorter::Sorter;
+
+    const QQmlScriptString& expression() const;
+    void setExpression(const QQmlScriptString& scriptString);
+
+    void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel) override;
+
+Q_SIGNALS:
+    void expressionChanged();
+
+protected:
+    int compare(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+private:
+    void updateContext(const QQmlSortFilterProxyModel& proxyModel);
+    void updateExpression();
+
+    QQmlScriptString m_scriptString;
+    QQmlExpression* m_expression = nullptr;
+    QQmlContext* m_context = nullptr;
+};
+
+}
+
+#endif // EXPRESSIONSORTER_H

client/3rd/SortFilterProxyModel/sorters/filtersorter.cpp

@@ -0,0 +1,81 @@
+#include "filtersorter.h"
+#include "filters/filter.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype FilterSorter
+    \inherits Sorter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Sorters
+    \ingroup FilterContainer
+    \brief Sorts rows based on if they match filters.
+
+    A FilterSorter is a \l Sorter that orders row matching its filters before the rows not matching the filters.
+
+    In the following example, rows with their \c favorite role set to \c true will be ordered at the beginning :
+    \code
+    SortFilterProxyModel {
+        sourceModel: contactModel
+        sorters: FilterSorter {
+            ValueFilter { roleName: "favorite"; value: true }
+        }
+    }
+    \endcode
+    \sa FilterContainer
+*/
+
+/*!
+    \qmlproperty list<Filter> FilterSorter::filters
+    \default
+
+    This property holds the list of filters for this filter sorter.
+    If a row match all this FilterSorter's filters, it will be ordered before rows not matching all the filters.
+
+    \sa Filter, FilterContainer
+*/
+
+int FilterSorter::compare(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel &proxyModel) const
+{
+    bool leftIsAccepted = indexIsAccepted(sourceLeft, proxyModel);
+    bool rightIsAccepted = indexIsAccepted(sourceRight, proxyModel);
+
+    if (leftIsAccepted == rightIsAccepted)
+        return 0;
+
+    return leftIsAccepted ? -1 : 1;
+}
+
+void FilterSorter::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    for (Filter* filter : m_filters)
+        filter->proxyModelCompleted(proxyModel);
+}
+
+void FilterSorter::onFilterAppended(Filter* filter)
+{
+    connect(filter, &Filter::invalidated, this, &FilterSorter::invalidate);
+    invalidate();
+}
+
+void FilterSorter::onFilterRemoved(Filter* filter)
+{
+    disconnect(filter, &Filter::invalidated, this, &FilterSorter::invalidate);
+    invalidate();
+}
+
+void FilterSorter::onFiltersCleared()
+{
+    invalidate();
+}
+
+bool FilterSorter::indexIsAccepted(const QModelIndex& sourceIndex, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    return std::all_of(m_filters.begin(), m_filters.end(),
+        [&] (Filter* filter) {
+            return filter->filterAcceptsRow(sourceIndex, proxyModel);
+        }
+    );
+}
+
+}

client/3rd/SortFilterProxyModel/sorters/filtersorter.h

@@ -0,0 +1,33 @@
+#ifndef FILTERSORTER_H
+#define FILTERSORTER_H
+
+#include "sorter.h"
+#include "filters/filtercontainer.h"
+
+namespace qqsfpm {
+
+class FilterSorter : public Sorter, public FilterContainer
+{
+    Q_OBJECT
+    Q_INTERFACES(qqsfpm::FilterContainer)
+    Q_PROPERTY(QQmlListProperty<qqsfpm::Filter> filters READ filtersListProperty)
+    Q_CLASSINFO("DefaultProperty", "filters")
+
+public:
+    using Sorter::Sorter;
+
+protected:
+    int compare(const QModelIndex &sourceLeft, const QModelIndex &sourceRight, const QQmlSortFilterProxyModel &proxyModel) const override;
+
+private:
+    void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel) override;
+    void onFilterAppended(Filter *filter) override;
+    void onFilterRemoved(Filter *filter) override;
+    void onFiltersCleared() override;
+
+    bool indexIsAccepted(const QModelIndex &sourceIndex, const QQmlSortFilterProxyModel &proxyModel) const;
+};
+
+}
+
+#endif // FILTERSORTER_H

client/3rd/SortFilterProxyModel/sorters/rolesorter.cpp

@@ -0,0 +1,69 @@
+#include "rolesorter.h"
+#include "qqmlsortfilterproxymodel.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype RoleSorter
+    \inherits Sorter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Sorters
+    \brief Sorts rows based on a source model role.
+
+    A RoleSorter is a simple \l Sorter that sorts rows based on a source model role.
+
+    In the following example, rows with be sorted by their \c lastName role :
+    \code
+    SortFilterProxyModel {
+       sourceModel: contactModel
+       sorters: RoleSorter { roleName: "lastName" }
+    }
+    \endcode
+*/
+
+/*!
+    \qmlproperty string RoleSorter::roleName
+
+    This property holds the role name that the sorter is using to query the source model's data when sorting items.
+*/
+const QString& RoleSorter::roleName() const
+{
+    return m_roleName;
+}
+
+void RoleSorter::setRoleName(const QString& roleName)
+{
+    if (m_roleName == roleName)
+        return;
+
+    m_roleName = roleName;
+    Q_EMIT roleNameChanged();
+    invalidate();
+}
+
+QPair<QVariant, QVariant> RoleSorter::sourceData(const QModelIndex &sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    QPair<QVariant, QVariant> pair;
+    int role = proxyModel.roleForName(m_roleName);
+
+    if (role == -1)
+        return pair;
+
+    pair.first = proxyModel.sourceData(sourceLeft, role);
+    pair.second = proxyModel.sourceData(sourceRight, role);
+    return pair;
+}
+
+int RoleSorter::compare(const QModelIndex &sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    QPair<QVariant, QVariant> pair = sourceData(sourceLeft, sourceRight, proxyModel);
+    QVariant leftValue = pair.first;
+    QVariant rightValue = pair.second;
+    if (leftValue < rightValue)
+        return -1;
+    if (leftValue > rightValue)
+        return 1;
+    return 0;
+}
+
+}

client/3rd/SortFilterProxyModel/sorters/rolesorter.h

@@ -0,0 +1,32 @@
+#ifndef ROLESORTER_H
+#define ROLESORTER_H
+
+#include "sorter.h"
+
+namespace qqsfpm {
+
+class RoleSorter : public Sorter
+{
+    Q_OBJECT
+    Q_PROPERTY(QString roleName READ roleName WRITE setRoleName NOTIFY roleNameChanged)
+
+public:
+    using Sorter::Sorter;
+
+    const QString& roleName() const;
+    void setRoleName(const QString& roleName);
+
+Q_SIGNALS:
+    void roleNameChanged();
+
+protected:
+    QPair<QVariant, QVariant> sourceData(const QModelIndex &sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const;
+    int compare(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+private:
+    QString m_roleName;
+};
+
+}
+
+#endif // ROLESORTER_H

client/3rd/SortFilterProxyModel/sorters/sorter.cpp

@@ -0,0 +1,142 @@
+#include "sorter.h"
+#include "qqmlsortfilterproxymodel.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype Sorter
+    \qmlabstract
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Sorters
+    \brief Base type for the \l SortFilterProxyModel sorters.
+
+    The Sorter type cannot be used directly in a QML file.
+    It exists to provide a set of common properties and methods,
+    available across all the other sorters types that inherit from it.
+    Attempting to use the Sorter type directly will result in an error.
+*/
+
+Sorter::Sorter(QObject *parent) : QObject(parent)
+{
+}
+
+Sorter::~Sorter() = default;
+
+/*!
+    \qmlproperty bool Sorter::enabled
+
+    This property holds whether the sorter is enabled.
+    A disabled sorter will not change the order of the rows.
+
+    By default, sorters are enabled.
+*/
+bool Sorter::enabled() const
+{
+    return m_enabled;
+}
+
+void Sorter::setEnabled(bool enabled)
+{
+    if (m_enabled == enabled)
+        return;
+
+    m_enabled = enabled;
+    Q_EMIT enabledChanged();
+    Q_EMIT invalidated();
+}
+
+bool Sorter::ascendingOrder() const
+{
+    return sortOrder() == Qt::AscendingOrder;
+}
+
+void Sorter::setAscendingOrder(bool ascendingOrder)
+{
+    setSortOrder(ascendingOrder ? Qt::AscendingOrder : Qt::DescendingOrder);
+}
+
+
+/*!
+    \qmlproperty Qt::SortOrder Sorter::sortOrder
+
+    This property holds the sort order of this sorter.
+
+    \value Qt.AscendingOrder The items are sorted ascending e.g. starts with 'AAA' ends with 'ZZZ' in Latin-1 locales
+    \value Qt.DescendingOrder The items are sorted descending e.g. starts with 'ZZZ' ends with 'AAA' in Latin-1 locales
+
+    By default, sorting is in ascending order.
+*/
+Qt::SortOrder Sorter::sortOrder() const
+{
+    return m_sortOrder;
+}
+
+void Sorter::setSortOrder(Qt::SortOrder sortOrder)
+{
+    if (m_sortOrder == sortOrder)
+        return;
+
+    m_sortOrder = sortOrder;
+    Q_EMIT sortOrderChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty int Sorter::priority
+
+    This property holds the sort priority of this sorter.
+    Sorters with a higher priority are applied first.
+    In case of equal priority, Sorters are ordered by their insertion order.
+
+    By default, the priority is 0.
+*/
+int Sorter::priority() const
+{
+    return m_priority;
+}
+
+void Sorter::setPriority(int priority)
+{
+    if (m_priority == priority)
+        return;
+
+    m_priority = priority;
+    Q_EMIT priorityChanged();
+    invalidate();
+}
+
+int Sorter::compareRows(const QModelIndex &source_left, const QModelIndex &source_right, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    int comparison = compare(source_left, source_right, proxyModel);
+    return (m_sortOrder == Qt::AscendingOrder) ? comparison : -comparison;
+}
+
+int Sorter::compare(const QModelIndex &sourceLeft, const QModelIndex &sourceRight, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    if (lessThan(sourceLeft, sourceRight, proxyModel))
+        return -1;
+    if (lessThan(sourceRight, sourceLeft, proxyModel))
+        return 1;
+    return 0;
+}
+
+void Sorter::proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel)
+{
+    Q_UNUSED(proxyModel)
+}
+
+bool Sorter::lessThan(const QModelIndex &sourceLeft, const QModelIndex &sourceRight, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    Q_UNUSED(sourceLeft)
+    Q_UNUSED(sourceRight)
+    Q_UNUSED(proxyModel)
+    return false;
+}
+
+void Sorter::invalidate()
+{
+    if (m_enabled)
+        Q_EMIT invalidated();
+}
+
+}

client/3rd/SortFilterProxyModel/sorters/sorter.h

@@ -0,0 +1,58 @@
+#ifndef SORTER_H
+#define SORTER_H
+
+#include <QObject>
+
+namespace qqsfpm {
+
+class QQmlSortFilterProxyModel;
+
+class Sorter : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(bool ascendingOrder READ ascendingOrder WRITE setAscendingOrder NOTIFY sortOrderChanged)
+    Q_PROPERTY(Qt::SortOrder sortOrder READ sortOrder WRITE setSortOrder NOTIFY sortOrderChanged)
+    Q_PROPERTY(int priority READ priority WRITE setPriority NOTIFY priorityChanged)
+
+public:
+    Sorter(QObject* parent = nullptr);
+    virtual ~Sorter() = 0;
+
+    bool enabled() const;
+    void setEnabled(bool enabled);
+
+    bool ascendingOrder() const;
+    void setAscendingOrder(bool ascendingOrder);
+
+    Qt::SortOrder sortOrder() const;
+    void setSortOrder(Qt::SortOrder sortOrder);
+
+    int priority() const;
+    void setPriority(int priority);
+
+    int compareRows(const QModelIndex& source_left, const QModelIndex& source_right, const QQmlSortFilterProxyModel& proxyModel) const;
+
+    virtual void proxyModelCompleted(const QQmlSortFilterProxyModel& proxyModel);
+
+Q_SIGNALS:
+    void enabledChanged();
+    void sortOrderChanged();
+    void priorityChanged();
+
+    void invalidated();
+
+protected:
+    virtual int compare(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const;
+    virtual bool lessThan(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const;
+    void invalidate();
+
+private:
+    bool m_enabled = true;
+    Qt::SortOrder m_sortOrder = Qt::AscendingOrder;
+    int m_priority = 0;
+};
+
+}
+
+#endif // SORTER_H

client/3rd/SortFilterProxyModel/sorters/sortercontainer.cpp

@@ -0,0 +1,126 @@
+#include "sortercontainer.h"
+#include "sorter.h"
+#include <QtQml>
+
+namespace qqsfpm {
+
+/*!
+    \qmltype SorterContainer
+    \qmlabstract
+    \inqmlmodule SortFilterProxyModel
+    \ingroup SorterAttached
+    \brief Abstract interface for types containing \l {Sorter}{Sorters}.
+
+    \section2 Types implementing this interface:
+    \annotatedlist SorterContainer
+*/
+
+QList<Sorter*> SorterContainer::sorters() const
+{
+    return m_sorters;
+}
+
+void SorterContainer::appendSorter(Sorter* sorter)
+{
+    m_sorters.append(sorter);
+    onSorterAppended(sorter);
+}
+
+void SorterContainer::removeSorter(Sorter *sorter)
+{
+    m_sorters.removeOne(sorter);
+    onSorterRemoved(sorter);
+}
+
+void SorterContainer::clearSorters()
+{
+    m_sorters.clear();
+    onSortersCleared();
+}
+
+QQmlListProperty<Sorter> SorterContainer::sortersListProperty()
+{
+    return QQmlListProperty<Sorter>(reinterpret_cast<QObject*>(this), &m_sorters,
+                                    &SorterContainer::append_sorter,
+                                    &SorterContainer::count_sorter,
+                                    &SorterContainer::at_sorter,
+                                    &SorterContainer::clear_sorters);
+}
+
+void SorterContainer::append_sorter(QQmlListProperty<Sorter>* list, Sorter* sorter)
+{
+    if (!sorter)
+        return;
+
+    SorterContainer* that = reinterpret_cast<SorterContainer*>(list->object);
+    that->appendSorter(sorter);
+}
+
+int SorterContainer::count_sorter(QQmlListProperty<Sorter>* list)
+{
+    QList<Sorter*>* sorters = static_cast<QList<Sorter*>*>(list->data);
+    return sorters->count();
+}
+
+Sorter* SorterContainer::at_sorter(QQmlListProperty<Sorter>* list, int index)
+{
+    QList<Sorter*>* sorters = static_cast<QList<Sorter*>*>(list->data);
+    return sorters->at(index);
+}
+
+void SorterContainer::clear_sorters(QQmlListProperty<Sorter> *list)
+{
+    SorterContainer* that = reinterpret_cast<SorterContainer*>(list->object);
+    that->clearSorters();
+}
+
+SorterContainerAttached::SorterContainerAttached(QObject* object) : QObject(object),
+    m_sorter(qobject_cast<Sorter*>(object))
+{
+    if (!m_sorter)
+        qmlWarning(object) << "SorterContainerAttached must be attached to a Sorter";
+}
+
+SorterContainerAttached::~SorterContainerAttached()
+{
+    if (m_sorter && m_container) {
+        SorterContainer* container = qobject_cast<SorterContainer*>(m_container.data());
+        container->removeSorter(m_sorter);
+    }
+}
+
+/*!
+    \qmlattachedproperty bool SorterContainer::container
+    This attached property allows you to include in a \l SorterContainer a \l Sorter that
+    has been instantiated outside of the \l SorterContainer, for example in an Instantiator.
+*/
+QObject* SorterContainerAttached::container() const
+{
+    return m_container;
+}
+
+void SorterContainerAttached::setContainer(QObject* object)
+{
+    if (m_container == object)
+        return;
+
+    SorterContainer* container = qobject_cast<SorterContainer*>(object);
+    if (object && !container)
+        qmlWarning(parent()) << "container must inherits from SorterContainer, " << object->metaObject()->className() << " provided";
+
+    if (m_container && m_sorter)
+        qobject_cast<SorterContainer*>(m_container.data())->removeSorter(m_sorter);
+
+    m_container = container ? object : nullptr;
+    if (container && m_sorter)
+        container->appendSorter(m_sorter);
+
+    Q_EMIT containerChanged();
+}
+
+SorterContainerAttached* SorterContainerAttached::qmlAttachedProperties(QObject* object)
+{
+    return new SorterContainerAttached(object);
+}
+
+}

client/3rd/SortFilterProxyModel/sorters/sortercontainer.h

@@ -0,0 +1,68 @@
+#ifndef SORTERSSORTERCONTAINER_H
+#define SORTERSSORTERCONTAINER_H
+
+#include <QList>
+#include <QQmlListProperty>
+#include <qqml.h>
+#include <QPointer>
+
+namespace qqsfpm {
+
+class Sorter;
+class QQmlSortFilterProxyModel;
+
+class SorterContainer {
+public:
+    virtual ~SorterContainer() = default;
+
+    QList<Sorter*> sorters() const;
+    void appendSorter(Sorter* sorter);
+    void removeSorter(Sorter* sorter);
+    void clearSorters();
+
+    QQmlListProperty<Sorter> sortersListProperty();
+
+protected:
+    QList<Sorter*> m_sorters;
+
+private:
+    virtual void onSorterAppended(Sorter* sorter) = 0;
+    virtual void onSorterRemoved(Sorter* sorter) = 0;
+    virtual void onSortersCleared() = 0;
+
+    static void append_sorter(QQmlListProperty<Sorter>* list, Sorter* sorter);
+    static int count_sorter(QQmlListProperty<Sorter>* list);
+    static Sorter* at_sorter(QQmlListProperty<Sorter>* list, int index);
+    static void clear_sorters(QQmlListProperty<Sorter>* list);
+};
+
+class SorterContainerAttached : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* container READ container WRITE setContainer NOTIFY containerChanged)
+
+public:
+    SorterContainerAttached(QObject* object);
+    ~SorterContainerAttached();
+
+    QObject* container() const;
+    void setContainer(QObject* object);
+
+    static SorterContainerAttached* qmlAttachedProperties(QObject* object);
+
+Q_SIGNALS:
+    void containerChanged();
+
+private:
+    QPointer<QObject> m_container = nullptr;
+    Sorter* m_sorter = nullptr;
+};
+
+}
+
+#define SorterContainer_iid "fr.grecko.SortFilterProxyModel.SorterContainer"
+Q_DECLARE_INTERFACE(qqsfpm::SorterContainer, SorterContainer_iid)
+
+QML_DECLARE_TYPEINFO(qqsfpm::SorterContainerAttached, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // SORTERSSORTERCONTAINER_H

client/3rd/SortFilterProxyModel/sorters/sortersqmltypes.cpp

@@ -0,0 +1,23 @@
+#include "sorter.h"
+#include "rolesorter.h"
+#include "stringsorter.h"
+#include "filtersorter.h"
+#include "expressionsorter.h"
+#include "sortercontainer.h"
+#include <QQmlEngine>
+#include <QCoreApplication>
+
+namespace qqsfpm {
+
+void registerSorterTypes() {
+    qmlRegisterUncreatableType<Sorter>("SortFilterProxyModel", 0, 2, "Sorter", "Sorter is an abstract class");
+    qmlRegisterType<RoleSorter>("SortFilterProxyModel", 0, 2, "RoleSorter");
+    qmlRegisterType<StringSorter>("SortFilterProxyModel", 0, 2, "StringSorter");
+    qmlRegisterType<FilterSorter>("SortFilterProxyModel", 0, 2, "FilterSorter");
+    qmlRegisterType<ExpressionSorter>("SortFilterProxyModel", 0, 2, "ExpressionSorter");
+    qmlRegisterUncreatableType<SorterContainerAttached>("SortFilterProxyModel", 0, 2, "SorterContainer", "SorterContainer can only be used as an attaching type");
+}
+
+Q_COREAPP_STARTUP_FUNCTION(registerSorterTypes)
+
+}

client/3rd/SortFilterProxyModel/sorters/stringsorter.cpp

@@ -0,0 +1,117 @@
+#include "stringsorter.h"
+
+namespace qqsfpm {
+
+/*!
+    \qmltype StringSorter
+    \inherits RoleSorter
+    \inqmlmodule SortFilterProxyModel
+    \ingroup Sorters
+    \brief Sorts rows based on a source model string role.
+
+    \l StringSorter is a specialized \l RoleSorter that sorts rows based on a source model string role.
+    \l StringSorter compares strings according to a localized collation algorithm.
+
+    In the following example, rows with be sorted by their \c lastName role :
+    \code
+    SortFilterProxyModel {
+       sourceModel: contactModel
+       sorters: StringSorter { roleName: "lastName" }
+    }
+    \endcode
+*/
+
+/*!
+    \qmlproperty Qt.CaseSensitivity StringSorter::caseSensitivity
+
+    This property holds the case sensitivity of the sorter.
+*/
+Qt::CaseSensitivity StringSorter::caseSensitivity() const
+{
+    return m_collator.caseSensitivity();
+}
+
+void StringSorter::setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)
+{
+    if (m_collator.caseSensitivity() == caseSensitivity)
+        return;
+
+    m_collator.setCaseSensitivity(caseSensitivity);
+    Q_EMIT caseSensitivityChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty bool StringSorter::ignorePunctation
+
+    This property holds whether the sorter ignores punctation.
+    if \c ignorePunctuation is \c true, punctuation characters and symbols are ignored when determining sort order.
+
+    \note This property is not currently supported on Apple platforms or if Qt is configured to not use ICU on Linux.
+*/
+bool StringSorter::ignorePunctation() const
+{
+    return m_collator.ignorePunctuation();
+}
+
+void StringSorter::setIgnorePunctation(bool ignorePunctation)
+{
+    if (m_collator.ignorePunctuation() == ignorePunctation)
+        return;
+
+    m_collator.setIgnorePunctuation(ignorePunctation);
+    Q_EMIT ignorePunctationChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty Locale StringSorter::locale
+
+    This property holds the locale of the sorter.
+*/
+QLocale StringSorter::locale() const
+{
+    return m_collator.locale();
+}
+
+void StringSorter::setLocale(const QLocale &locale)
+{
+    if (m_collator.locale() == locale)
+        return;
+
+    m_collator.setLocale(locale);
+    Q_EMIT localeChanged();
+    invalidate();
+}
+
+/*!
+    \qmlproperty bool StringSorter::numericMode
+
+    This property holds whether the numeric mode of the sorter is enabled.
+    This will enable proper sorting of numeric digits, so that e.g. 100 sorts after 99.
+    By default this mode is off.
+*/
+bool StringSorter::numericMode() const
+{
+    return m_collator.numericMode();
+}
+
+void StringSorter::setNumericMode(bool numericMode)
+{
+    if (m_collator.numericMode() == numericMode)
+        return;
+
+    m_collator.setNumericMode(numericMode);
+    Q_EMIT numericModeChanged();
+    invalidate();
+}
+
+int StringSorter::compare(const QModelIndex &sourceLeft, const QModelIndex &sourceRight, const QQmlSortFilterProxyModel& proxyModel) const
+{
+    QPair<QVariant, QVariant> pair = sourceData(sourceLeft, sourceRight, proxyModel);
+    QString leftValue = pair.first.toString();
+    QString rightValue = pair.second.toString();
+    return m_collator.compare(leftValue, rightValue);
+}
+
+}

client/3rd/SortFilterProxyModel/sorters/stringsorter.h

@@ -0,0 +1,47 @@
+#ifndef STRINGSORTER_H
+#define STRINGSORTER_H
+
+#include "rolesorter.h"
+#include <QCollator>
+
+namespace qqsfpm {
+
+class StringSorter : public RoleSorter
+{
+    Q_OBJECT
+    Q_PROPERTY(Qt::CaseSensitivity caseSensitivity READ caseSensitivity WRITE setCaseSensitivity NOTIFY caseSensitivityChanged)
+    Q_PROPERTY(bool ignorePunctation READ ignorePunctation WRITE setIgnorePunctation NOTIFY ignorePunctationChanged)
+    Q_PROPERTY(QLocale locale READ locale WRITE setLocale NOTIFY localeChanged)
+    Q_PROPERTY(bool numericMode READ numericMode WRITE setNumericMode NOTIFY numericModeChanged)
+
+public:
+    using RoleSorter::RoleSorter;
+
+    Qt::CaseSensitivity caseSensitivity() const;
+    void setCaseSensitivity(Qt::CaseSensitivity caseSensitivity);
+
+    bool ignorePunctation() const;
+    void setIgnorePunctation(bool ignorePunctation);
+
+    QLocale locale() const;
+    void setLocale(const QLocale& locale);
+
+    bool numericMode() const;
+    void setNumericMode(bool numericMode);
+
+Q_SIGNALS:
+    void caseSensitivityChanged();
+    void ignorePunctationChanged();
+    void localeChanged();
+    void numericModeChanged();
+
+protected:
+    int compare(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel& proxyModel) const override;
+
+private:
+    QCollator m_collator;
+};
+
+}
+
+#endif // STRINGSORTER_H

client/3rd/SortFilterProxyModel/sortfilterproxymodel.qdocconf

@@ -0,0 +1,13 @@
+project = SortFilterProxyModel
+
+sourcedirs = .
+
+sources.fileextensions = "*.cpp *.qdoc *.qml"
+headers.fileextensions = "*.h"
+
+outputdir = docs/
+
+HTML.templatedir = .
+HTML.stylesheets = "offline.css"
+
+HTML.headerstyles = "  <link rel=\"stylesheet\" type=\"text/css\" href=\"style/offline.css\" />\n"

client/client.pro

@@ -12,6 +12,7 @@ include("3rd/QtSsh/src/ssh/qssh.pri")
 include("3rd/QtSsh/src/botan/botan.pri")
 !android:!ios:include("3rd/SingleApplication/singleapplication.pri")
 include("3rd/QRCodeGenerator/QRCodeGenerator.pri")
+include ("3rd/SortFilterProxyModel/SortFilterProxyModel.pri")
 
 HEADERS  += \
     ../ipc/ipc.h \
@@ -55,6 +56,7 @@ HEADERS  += \
     ui/pages_logic/WizardLogic.h \
    ui/pages_logic/protocols/CloakLogic.h \
    ui/pages_logic/protocols/OpenVpnLogic.h \
+   ui/pages_logic/protocols/PageProtocolLogicBase.h \
    ui/pages_logic/protocols/ShadowSocksLogic.h \
     ui/property_helper.h \
     ui/models/servers_model.h \
@@ -105,6 +107,7 @@ SOURCES  += \
     ui/pages_logic/WizardLogic.cpp \
    ui/pages_logic/protocols/CloakLogic.cpp \
    ui/pages_logic/protocols/OpenVpnLogic.cpp \
+   ui/pages_logic/protocols/PageProtocolLogicBase.cpp \
    ui/pages_logic/protocols/ShadowSocksLogic.cpp \
     ui/models/servers_model.cpp \
     ui/uilogic.cpp \

client/containers/containers_defs.h

@@ -8,6 +8,7 @@
 using namespace amnezia;
 
 namespace amnezia {
+Q_NAMESPACE
 
 enum class DockerContainer {
     None,
@@ -16,6 +17,7 @@ enum class DockerContainer {
     OpenVpnOverCloak,
     WireGuard
 };
+Q_ENUM_NS(DockerContainer)
 
 DockerContainer containerFromString(const QString &container);
 QString containerToString(DockerContainer container);

client/main.cpp

@@ -116,10 +116,16 @@ int main(int argc, char *argv[])
 
     app.setQuitOnLastWindowClosed(false);
 
+    qRegisterMetaType<amnezia::DockerContainer>("amnezia::DockerContainer");
+    qRegisterMetaType<amnezia::Protocol>("amnezia::Protocol");
+
     UiLogic *uiLogic = new UiLogic;
 
     QQmlApplicationEngine engine;
+
     PageEnumNS::declareQML();
+    declareQmlProtocolEnum();
+
     const QUrl url(QStringLiteral("qrc:/ui/qml/main.qml"));
     QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
                      &app, [url](QObject *obj, const QUrl &objUrl) {

client/protocols/protocols_defs.cpp

@@ -29,6 +29,7 @@ QString amnezia::protoToString(amnezia::Protocol proto){
 QVector<amnezia::Protocol> amnezia::allProtocols()
 {
     return QVector<amnezia::Protocol> {
+        Protocol::Any,
         Protocol::OpenVpn,
         Protocol::ShadowSocks,
         Protocol::Cloak,

client/protocols/protocols_defs.h

@@ -113,6 +113,7 @@ constexpr char serverPskKeyPath[] = "/opt/amnezia/wireguard/wireguard_psk.key";
 
 } // namespace protocols
 
+Q_NAMESPACE
 enum class Protocol {
     Any,
     OpenVpn,
@@ -120,6 +121,8 @@ enum class Protocol {
     Cloak,
     WireGuard
 };
+Q_ENUM_NS(Protocol)
+
 QVector<Protocol> allProtocols();
 
 Protocol protoFromString(QString proto);
@@ -129,6 +132,16 @@ QMap<Protocol, QString> protocolHumanNames();
 QMap<Protocol, QString> protocolDescriptions();
 bool isProtocolVpnType(Protocol p);
 
+static void declareQmlProtocolEnum() {
+    qmlRegisterUncreatableMetaObject(
+                PageEnumNS::staticMetaObject,
+                "ProtocolEnum",
+                1, 0,
+                "ProtocolEnum",
+                "Error: only enums"
+                );
+}
+
 } // namespace amnezia
 
 QDebug operator<<(QDebug debug, const amnezia::Protocol &p);

client/ui/models/protocols_model.cpp

@@ -9,7 +9,7 @@ ProtocolsModel::ProtocolsModel(QObject *parent) :
 int ProtocolsModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
-    return amnezia::allContainers().size();
+    return amnezia::allProtocols().size();
 }
 
 QHash<int, QByteArray> ProtocolsModel::roleNames() const {
@@ -55,7 +55,7 @@ void ProtocolsModel::setSelectedServerIndex(int index)
     endResetModel();
 }
 
-void ProtocolsModel::setSelectedDockerContainer(DockerContainer c)
+void ProtocolsModel::setSelectedDockerContainer(amnezia::DockerContainer c)
 {
     beginResetModel();
     m_selectedDockerContainer = c;

client/ui/models/protocols_model.h

@@ -26,8 +26,8 @@ public:
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
 
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
-    void setSelectedServerIndex(int index);
-    void setSelectedDockerContainer(DockerContainer c);
+    Q_INVOKABLE void setSelectedServerIndex(int index);
+    Q_INVOKABLE void setSelectedDockerContainer(amnezia::DockerContainer c);
 
 protected:
     QHash<int, QByteArray> roleNames() const override;

client/ui/pages_logic/PageLogicBase.cpp

@@ -8,3 +8,16 @@ PageLogicBase::PageLogicBase(UiLogic *logic, QObject *parent):
 {
 
 }
+
+Page PageLogicBase::pageForProto(Protocol p)
+{
+    switch (p) {
+    case Protocol::OpenVpn: return Page::OpenVpnSettings;
+    case Protocol::ShadowSocks: return Page::ShadowSocksSettings;
+    case Protocol::OpenVpn: return Page::OpenVpnSettings;
+    case Protocol::OpenVpn: return Page::OpenVpnSettings;
+
+    default:
+        break;
+    }
+}

client/ui/pages_logic/PageLogicBase.h

@@ -20,6 +20,7 @@ public:
     ~PageLogicBase() = default;
 
     Q_INVOKABLE virtual void updatePage() {}
+    Q_INVOKABLE Page pageForProto(amnezia::Protocol p);
 
 protected:
     UiLogic *uiLogic() const { return m_uiLogic; }

client/ui/pages_logic/ServerContainersLogic.cpp

@@ -1,4 +1,4 @@
-#include "ServerContainersLogic.h"
+#include "ServerContainersLogic.h"
 #include "ShareConnectionLogic.h"
 #include "protocols/CloakLogic.h"
 #include "protocols/OpenVpnLogic.h"
@@ -50,8 +50,11 @@ void ServerContainersLogic::updateServerContainersPage()
 {
     set_progressBarProtocolsContainerReinstallVisible(false);
 
-    ContainersModel *model = qobject_cast<ContainersModel *>(uiLogic()->containersModel());
-    model->setSelectedServerIndex(uiLogic()->selectedServerIndex);
+    ContainersModel *c_model = qobject_cast<ContainersModel *>(uiLogic()->containersModel());
+    c_model->setSelectedServerIndex(uiLogic()->selectedServerIndex);
+
+    ProtocolsModel *p_model = qobject_cast<ProtocolsModel *>(uiLogic()->protocolsModel());
+    p_model->setSelectedServerIndex(uiLogic()->selectedServerIndex);
 
     auto containers = m_settings.containers(uiLogic()->selectedServerIndex);
     DockerContainer defaultContainer = m_settings.defaultContainer(uiLogic()->selectedServerIndex);
@@ -118,6 +121,16 @@ void ServerContainersLogic::updateServerContainersPage()
     }
 }
 
+void ServerContainersLogic::onPushButtonProtoSettingsClicked(amnezia::DockerContainer c, amnezia::Protocol p)
+{
+    uiLogic()->selectedDockerContainer = c;
+    uiLogic()->protocolLogic(p)->updateProtocolPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, p),
+                      uiLogic()->selectedDockerContainer,
+                      m_settings.haveAuthData(uiLogic()->selectedServerIndex));
+
+    emit uiLogic()->goToPage(Page::OpenVpnSettings);
+}
+
 
 void ServerContainersLogic::setupProtocolsPageConnections()
 {
@@ -245,50 +258,50 @@ void ServerContainersLogic::setupProtocolsPageConnections()
     }
 }
 
-void ServerContainersLogic::onPushButtonProtoCloakOpenVpnContOpenvpnConfigClicked()
-{
-    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverCloak;
-    uiLogic()->openVpnLogic()->updateOpenVpnPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::OpenVpn),
-                      uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
-    uiLogic()->goToPage(Page::OpenVpnSettings);
-}
+//void ServerContainersLogic::onPushButtonProtoCloakOpenVpnContOpenvpnConfigClicked()
+//{
+//    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverCloak;
+//    uiLogic()->openVpnLogic()->updateOpenVpnPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::OpenVpn),
+//                      uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
+//    uiLogic()->goToPage(Page::OpenVpnSettings);
+//}
 
-void ServerContainersLogic::onPushButtonProtoCloakOpenVpnContSsConfigClicked()
-{
-    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverCloak;
-    uiLogic()->shadowSocksLogic()->updateShadowSocksPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::ShadowSocks),
-                          uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
-    uiLogic()->goToPage(Page::ShadowSocksSettings);
-}
+//void ServerContainersLogic::onPushButtonProtoCloakOpenVpnContSsConfigClicked()
+//{
+//    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverCloak;
+//    uiLogic()->shadowSocksLogic()->updateShadowSocksPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::ShadowSocks),
+//                          uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
+//    uiLogic()->goToPage(Page::ShadowSocksSettings);
+//}
 
-void ServerContainersLogic::onPushButtonProtoCloakOpenVpnContCloakConfigClicked()
-{
-    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverCloak;
-    uiLogic()->cloakLogic()->updateCloakPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::Cloak),
-                    uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
-    uiLogic()->goToPage(Page::CloakSettings);
-}
+//void ServerContainersLogic::onPushButtonProtoCloakOpenVpnContCloakConfigClicked()
+//{
+//    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverCloak;
+//    uiLogic()->cloakLogic()->updateCloakPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::Cloak),
+//                    uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
+//    uiLogic()->goToPage(Page::CloakSettings);
+//}
 
-void ServerContainersLogic::onPushButtonProtoOpenVpnContOpenvpnConfigClicked()
-{
-    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpn;
-    uiLogic()->openVpnLogic()->updateOpenVpnPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::OpenVpn),
-                      uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
-    uiLogic()->goToPage(Page::OpenVpnSettings);
-}
+//void ServerContainersLogic::onPushButtonProtoOpenVpnContOpenvpnConfigClicked()
+//{
+//    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpn;
+//    uiLogic()->openVpnLogic()->updateOpenVpnPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::OpenVpn),
+//                      uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
+//    uiLogic()->goToPage(Page::OpenVpnSettings);
+//}
 
-void ServerContainersLogic::onPushButtonProtoSsOpenVpnContOpenvpnConfigClicked()
-{
-    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverShadowSocks;
-    uiLogic()->openVpnLogic()->updateOpenVpnPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::OpenVpn),
-                      uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
-    uiLogic()->goToPage(Page::OpenVpnSettings);
-}
+//void ServerContainersLogic::onPushButtonProtoSsOpenVpnContOpenvpnConfigClicked()
+//{
+//    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverShadowSocks;
+//    uiLogic()->openVpnLogic()->updateOpenVpnPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::OpenVpn),
+//                      uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
+//    uiLogic()->goToPage(Page::OpenVpnSettings);
+//}
 
-void ServerContainersLogic::onPushButtonProtoSsOpenVpnContSsConfigClicked()
-{
-    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverShadowSocks;
-    uiLogic()->shadowSocksLogic()->updateShadowSocksPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::ShadowSocks),
-                          uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
-    uiLogic()->goToPage(Page::ShadowSocksSettings);
-}
+//void ServerContainersLogic::onPushButtonProtoSsOpenVpnContSsConfigClicked()
+//{
+//    uiLogic()->selectedDockerContainer = DockerContainer::OpenVpnOverShadowSocks;
+//    uiLogic()->shadowSocksLogic()->updateShadowSocksPage(m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::ShadowSocks),
+//                          uiLogic()->selectedDockerContainer, m_settings.haveAuthData(uiLogic()->selectedServerIndex));
+//    uiLogic()->goToPage(Page::ShadowSocksSettings);
+//}

client/ui/pages_logic/ServerContainersLogic.h

@@ -43,12 +43,14 @@ class ServerContainersLogic : public PageLogicBase
 public:
     Q_INVOKABLE void updateServerContainersPage();
 
-    Q_INVOKABLE void onPushButtonProtoCloakOpenVpnContOpenvpnConfigClicked();
-    Q_INVOKABLE void onPushButtonProtoCloakOpenVpnContSsConfigClicked();
-    Q_INVOKABLE void onPushButtonProtoCloakOpenVpnContCloakConfigClicked();
-    Q_INVOKABLE void onPushButtonProtoOpenVpnContOpenvpnConfigClicked();
-    Q_INVOKABLE void onPushButtonProtoSsOpenVpnContOpenvpnConfigClicked();
-    Q_INVOKABLE void onPushButtonProtoSsOpenVpnContSsConfigClicked();
+//    Q_INVOKABLE void onPushButtonProtoCloakOpenVpnContOpenvpnConfigClicked();
+//    Q_INVOKABLE void onPushButtonProtoCloakOpenVpnContSsConfigClicked();
+//    Q_INVOKABLE void onPushButtonProtoCloakOpenVpnContCloakConfigClicked();
+//    Q_INVOKABLE void onPushButtonProtoOpenVpnContOpenvpnConfigClicked();
+//    Q_INVOKABLE void onPushButtonProtoSsOpenVpnContOpenvpnConfigClicked();
+//    Q_INVOKABLE void onPushButtonProtoSsOpenVpnContSsConfigClicked();
+
+    Q_INVOKABLE void onPushButtonProtoSettingsClicked(amnezia::DockerContainer c, amnezia::Protocol p);
 
 public:
     explicit ServerContainersLogic(UiLogic *uiLogic, QObject *parent = nullptr);

client/ui/pages_logic/protocols/CloakLogic.cpp

@@ -7,7 +7,7 @@ using namespace amnezia;
 using namespace PageEnumNS;
 
 CloakLogic::CloakLogic(UiLogic *logic, QObject *parent):
-    PageLogicBase(logic, parent),
+    PageProtocolLogicBase(logic, parent),
     m_comboBoxProtoCloakCipherText{"chacha20-poly1305"},
     m_lineEditProtoCloakSiteText{"tile.openstreetmap.org"},
     m_lineEditProtoCloakPortText{},
@@ -24,7 +24,7 @@ CloakLogic::CloakLogic(UiLogic *logic, QObject *parent):
 
 }
 
-void CloakLogic::updateCloakPage(const QJsonObject &ckConfig, DockerContainer container, bool haveAuthData)
+void CloakLogic::updateProtocolPage(const QJsonObject &ckConfig, DockerContainer container, bool haveAuthData)
 {
     set_widgetProtoCloakEnabled(haveAuthData);
     set_pushButtonCloakSaveVisible(haveAuthData);
@@ -42,7 +42,7 @@ void CloakLogic::updateCloakPage(const QJsonObject &ckConfig, DockerContainer co
     set_lineEditProtoCloakPortEnabled(container == DockerContainer::OpenVpnOverCloak);
 }
 
-QJsonObject CloakLogic::getCloakConfigFromPage(QJsonObject oldConfig)
+QJsonObject CloakLogic::getProtocolConfigFromPage(QJsonObject oldConfig)
 {
     oldConfig.insert(config_key::cipher, comboBoxProtoCloakCipherText());
     oldConfig.insert(config_key::site, lineEditProtoCloakSiteText());
@@ -54,7 +54,7 @@ QJsonObject CloakLogic::getCloakConfigFromPage(QJsonObject oldConfig)
 void CloakLogic::onPushButtonProtoCloakSaveClicked()
 {
     QJsonObject protocolConfig = m_settings.protocolConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer, Protocol::Cloak);
-    protocolConfig = getCloakConfigFromPage(protocolConfig);
+    protocolConfig = getProtocolConfigFromPage(protocolConfig);
 
     QJsonObject containerConfig = m_settings.containerConfig(uiLogic()->selectedServerIndex, uiLogic()->selectedDockerContainer);
     QJsonObject newContainerConfig = containerConfig;

client/ui/pages_logic/protocols/CloakLogic.h

@@ -1,11 +1,11 @@
 #ifndef CLOAK_LOGIC_H
 #define CLOAK_LOGIC_H
 
-#include "../PageLogicBase.h"
+#include "PageProtocolLogicBase.h"
 
 class UiLogic;
 
-class CloakLogic : public PageLogicBase
+class CloakLogic : public PageProtocolLogicBase
 {
     Q_OBJECT
 
@@ -29,8 +29,8 @@ public:
     explicit CloakLogic(UiLogic *uiLogic, QObject *parent = nullptr);
     ~CloakLogic() = default;
 
-    void updateCloakPage(const QJsonObject &ckConfig, DockerContainer container, bool haveAuthData);
-    QJsonObject getCloakConfigFromPage(QJsonObject oldConfig);
+    void updateProtocolPage (const QJsonObject &ckConfig, DockerContainer container, bool haveAuthData) override;
+    QJsonObject getProtocolConfigFromPage(QJsonObject oldConfig) override;
 
 private:
     Settings m_settings;

client/ui/pages_logic/protocols/OpenVpnLogic.cpp

@@ -7,7 +7,7 @@ using namespace amnezia;
 using namespace PageEnumNS;
 
 OpenVpnLogic::OpenVpnLogic(UiLogic *logic, QObject *parent):
-    PageLogicBase(logic, parent),
+    PageProtocolLogicBase(logic, parent),
     m_lineEditProtoOpenVpnSubnetText{},
     m_radioButtonProtoOpenVpnUdpChecked{false},
     m_checkBoxProtoOpenVpnAutoEncryptionChecked{},
@@ -34,7 +34,7 @@ OpenVpnLogic::OpenVpnLogic(UiLogic *logic, QObject *parent):
 
 }
 
-void OpenVpnLogic::updateOpenVpnPage(const QJsonObject &openvpnConfig, DockerContainer container, bool haveAuthData)
+void OpenVpnLogic::updateProtocolPage(const QJsonObject &openvpnConfig, DockerContainer container, bool haveAuthData)
 {
     set_widgetProtoOpenVpnEnabled(haveAuthData);
     set_pushButtonOpenvpnSaveVisible(haveAuthData);
@@ -136,7 +136,7 @@ void OpenVpnLogic::onPushButtonProtoOpenVpnSaveClicked()
     qDebug() << "Protocol saved with code:" << e << "for" << uiLogic()->selectedServerIndex << uiLogic()->selectedDockerContainer;
 }
 
-QJsonObject OpenVpnLogic::getOpenVpnConfigFromPage(QJsonObject oldConfig)
+QJsonObject OpenVpnLogic::getProtocolConfigFromPage(QJsonObject oldConfig)
 {
     oldConfig.insert(config_key::subnet_address, lineEditProtoOpenVpnSubnetText());
     oldConfig.insert(config_key::transport_proto, radioButtonProtoOpenVpnUdpChecked() ? protocols::UDP : protocols::TCP);

client/ui/pages_logic/protocols/OpenVpnLogic.h

@@ -1,11 +1,11 @@
 #ifndef OPENVPN_LOGIC_H
 #define OPENVPN_LOGIC_H
 
-#include "../PageLogicBase.h"
+#include "PageProtocolLogicBase.h"
 
 class UiLogic;
 
-class OpenVpnLogic : public PageLogicBase
+class OpenVpnLogic : public PageProtocolLogicBase
 {
     Q_OBJECT
 
@@ -42,8 +42,8 @@ public:
     explicit OpenVpnLogic(UiLogic *uiLogic, QObject *parent = nullptr);
     ~OpenVpnLogic() = default;
 
-    void updateOpenVpnPage(const QJsonObject &openvpnConfig, DockerContainer container, bool haveAuthData);
-    QJsonObject getOpenVpnConfigFromPage(QJsonObject oldConfig);
+    void updateProtocolPage(const QJsonObject &openvpnConfig, DockerContainer container, bool haveAuthData) override;
+    QJsonObject getProtocolConfigFromPage(QJsonObject oldConfig) override;
 
 private:
     Settings m_settings;

client/ui/pages_logic/protocols/PageProtocolLogicBase.cpp

@@ -0,0 +1,8 @@
+#include "PageProtocolLogicBase.h"
+
+
+PageProtocolLogicBase::PageProtocolLogicBase(UiLogic *logic, QObject *parent):
+    PageLogicBase(logic, parent)
+{
+
+}

client/ui/pages_logic/protocols/PageProtocolLogicBase.h

@@ -0,0 +1,24 @@
+#ifndef PAGE_PROTOCOL_LOGIC_BASE_H
+#define PAGE_PROTOCOL_LOGIC_BASE_H
+
+#include "settings.h"
+#include "../PageLogicBase.h"
+
+using namespace amnezia;
+using namespace PageEnumNS;
+
+class UiLogic;
+
+class PageProtocolLogicBase : public PageLogicBase
+{
+    Q_OBJECT
+
+public:
+    explicit PageProtocolLogicBase(UiLogic *uiLogic, QObject *parent = nullptr);
+    ~PageProtocolLogicBase() = default;
+
+    virtual void updateProtocolPage(const QJsonObject &config, DockerContainer container, bool haveAuthData) {}
+    virtual QJsonObject getProtocolConfigFromPage(QJsonObject oldConfig) { return QJsonObject(); }
+
+};
+#endif // PAGE_PROTOCOL_LOGIC_BASE_H

client/ui/pages_logic/protocols/ShadowSocksLogic.cpp

@@ -7,7 +7,7 @@ using namespace amnezia;
 using namespace PageEnumNS;
 
 ShadowSocksLogic::ShadowSocksLogic(UiLogic *logic, QObject *parent):
-    PageLogicBase(logic, parent),
+    PageProtocolLogicBase(logic, parent),
     m_widgetProtoShadowSocksEnabled{false},
     m_comboBoxProtoShadowSocksCipherText{"chacha20-poly1305"},
     m_lineEditProtoShadowSocksPortText{},
@@ -23,7 +23,7 @@ ShadowSocksLogic::ShadowSocksLogic(UiLogic *logic, QObject *parent):
 
 }
 
-void ShadowSocksLogic::updateShadowSocksPage(const QJsonObject &ssConfig, DockerContainer container, bool haveAuthData)
+void ShadowSocksLogic::updateProtocolPage(const QJsonObject &ssConfig, DockerContainer container, bool haveAuthData)
 {
     set_widgetProtoShadowSocksEnabled(haveAuthData);
     set_pushButtonShadowSocksSaveVisible(haveAuthData);
@@ -38,7 +38,7 @@ void ShadowSocksLogic::updateShadowSocksPage(const QJsonObject &ssConfig, Docker
     set_lineEditProtoShadowSocksPortEnabled(container == DockerContainer::OpenVpnOverShadowSocks);
 }
 
-QJsonObject ShadowSocksLogic::getShadowSocksConfigFromPage(QJsonObject oldConfig)
+QJsonObject ShadowSocksLogic::getProtocolConfigFromPage(QJsonObject oldConfig)
 {
     oldConfig.insert(config_key::cipher, comboBoxProtoShadowSocksCipherText());
     oldConfig.insert(config_key::port, lineEditProtoShadowSocksPortText());

client/ui/pages_logic/protocols/ShadowSocksLogic.h

@@ -1,11 +1,11 @@
 #ifndef SHADOWSOCKS_LOGIC_H
 #define SHADOWSOCKS_LOGIC_H
 
-#include "../PageLogicBase.h"
+#include "PageProtocolLogicBase.h"
 
 class UiLogic;
 
-class ShadowSocksLogic : public PageLogicBase
+class ShadowSocksLogic : public PageProtocolLogicBase
 {
     Q_OBJECT
 
@@ -28,8 +28,8 @@ public:
     explicit ShadowSocksLogic(UiLogic *uiLogic, QObject *parent = nullptr);
     ~ShadowSocksLogic() = default;
 
-    void updateShadowSocksPage(const QJsonObject &ssConfig, DockerContainer container, bool haveAuthData);
-    QJsonObject getShadowSocksConfigFromPage(QJsonObject oldConfig);
+    void updateProtocolPage(const QJsonObject &ssConfig, DockerContainer container, bool haveAuthData) override;
+    QJsonObject getProtocolConfigFromPage(QJsonObject oldConfig) override;
 
 private:
     Settings m_settings;

client/ui/qml/Controls/SettingButtonType.qml

@@ -3,6 +3,8 @@ import QtQuick.Controls 2.12
 
 BasicButtonType {
     id: root
+    property alias textItem: textItem
+
     background: Item {}
     contentItem: Item {
         anchors.fill: parent
@@ -12,6 +14,7 @@ BasicButtonType {
             anchors.verticalCenter: parent.verticalCenter
         }
         Text {
+            id: textItem
             anchors.fill: parent
             leftPadding: 30
             text: root.text

client/ui/qml/Pages/InstallSettings/SelectContainer.qml

@@ -1,5 +1,6 @@
 import QtQuick 2.12
 import QtQuick.Controls 2.12
+import SortFilterProxyModel 0.2
 import "./"
 import "../../Controls"
 import "../../Config"
@@ -8,7 +9,7 @@ Drawer {
     id: root
     signal containerSelected(int id)
     property alias selectedIndex: tb.currentIndex
-    property var filter: function (item){ return item.is_vpn_role }
+    property alias modelFilters: proxyModel.filters
 
     z: -3
 
@@ -21,6 +22,20 @@ Drawer {
     modal: true
     interactive: true
 
+    SortFilterProxyModel {
+        id: proxyModel
+        sourceModel: UiLogic.containersModel
+        filters: [
+            ValueFilter {
+                roleName: "is_installed_role"
+                value: false },
+            ValueFilter {
+                roleName: "is_vpn_role"
+                value: true }
+        ]
+
+    }
+
     Flickable {
         clip: true
         anchors.fill: parent
@@ -48,21 +63,12 @@ Drawer {
                 width: parent.width - 40
                 height: contentItem.height
 
-                spacing: 1
+                spacing: 0
                 clip: true
                 interactive: false
-                model: UiLogic.containersModel
+                model: proxyModel
 
                 delegate: Item {
-                    required property int index
-
-                    required property string name_role
-                    required property string desc_role
-                    required property bool is_vpn_role
-                    required property bool is_other_role
-                    required property bool is_installed_role
-
-                    visible: filter(this)
                     implicitWidth: 170 * 2
                     implicitHeight: 30
                     Item {

client/ui/qml/Pages/PageBase.qml

@@ -7,10 +7,9 @@ import "../Config"
 
 Item {
     id: root
-    property int page: PageEnum.Start
+    property int protocol: PageEnum.Start
     property var logic: null
 //    width: GC.screenWidth
 //    height: GC.screenHeight
 
-    anchors.fill: parent
 }

client/ui/qml/Pages/PageNewServerProtocols.qml

@@ -49,7 +49,6 @@ PageBase {
 
     SelectContainer {
         id: container_selector
-        //filter: function (){ return is_vpn_role }
     }
 
     Column {

client/ui/qml/Pages/PageServerContainers.qml

@@ -1,5 +1,6 @@
 import QtQuick 2.12
 import QtQuick.Controls 2.12
+import SortFilterProxyModel 0.2
 import PageEnum 1.0
 import "./"
 import "../Controls"
@@ -34,7 +35,6 @@ PageBase {
     }
     SelectContainer {
         id: container_selector
-        filter: function (item){ return ! item.is_installed_role &&  (item.is_vpn_role || item.is_other_role)}
     }
 
     Flickable {
@@ -60,64 +60,168 @@ PageBase {
 
             }
 
+            SortFilterProxyModel {
+                id: proxyContainersModel
+                sourceModel: UiLogic.containersModel
+                filters: ValueFilter {
+                    roleName: "is_installed_role"
+                    value: true
+                }
+            }
+
+            SortFilterProxyModel {
+                id: proxyProtocolsModel
+                sourceModel: UiLogic.protocolsModel
+                filters: ValueFilter {
+                    roleName: "is_installed_role"
+                    value: true
+                }
+            }
+
+
             ListView {
-                id: tb
+                id: tb_c
                 x: 10
                 width: parent.width - 40
-                height: contentItem.height
-
-                spacing: 1
+                height: tb_c.contentItem.height
+                currentIndex: -1
+                spacing: 5
                 clip: true
                 interactive: false
-                model: UiLogic.containersModel
+                model: proxyContainersModel
 
                 delegate: Item {
-                    required property int index
-
-                    required property string name_role
-                    required property string desc_role
-                    required property bool is_vpn_role
-                    required property bool is_other_role
-                    required property bool is_installed_role
-
-                    visible: true
-                    implicitWidth: 170 * 2
-                    implicitHeight: 30
+                    implicitWidth: tb_c.width - 10
+                    implicitHeight: c_item.height
                     Item {
+                        id: c_item
                         width: parent.width
-                        height: 30
+                        height: lb_container_name.height + tb_p.height
                         anchors.left: parent.left
-                        id: c1
                         Rectangle {
                             anchors.top: parent.top
                             width: parent.width
                             height: 1
                             color: "lightgray"
-                            visible: index !== tb.currentIndex
+                            visible: index !== tb_c.currentIndex
                         }
                         Rectangle {
-                            anchors.fill: parent
-                            color: "#63B4FB"
-                            visible: index === tb.currentIndex
+                            anchors.top: lb_container_name.top
+                            anchors.bottom: lb_container_name.bottom
+                            anchors.left: parent.left
+                            anchors.right: parent.right
 
+                            color: "#63B4FB"
+                            visible: index === tb_c.currentIndex
                         }
                         Text {
-                            id: text_name
+                            id: lb_container_name
                             text: name_role
-                            font.pixelSize: 16
-                            anchors.fill: parent
+                            font.pixelSize: 17
+                            //font.bold: true
+                            color: "#100A44"
+                            topPadding: 5
+                            bottomPadding: 5
                             leftPadding: 10
                             verticalAlignment: Text.AlignVCenter
                             wrapMode: Text.WordWrap
                         }
-                    }
 
-                    MouseArea {
-                        anchors.fill: parent
-                        onClicked: {
-                            tb.currentIndex = index
-                            containerSelected(index)
-                            root.close()
+                        MouseArea {
+                            anchors.top: lb_container_name.top
+                            anchors.bottom: lb_container_name.bottom
+                            anchors.left: parent.left
+                            anchors.right: parent.right
+                            propagateComposedEvents: true
+                            onClicked: {
+                                tb_c.currentIndex = index
+                                UiLogic.protocolsModel.setSelectedDockerContainer(proxyContainersModel.mapToSource(index))
+                                //container_selector.containerSelected(index)
+                                //root.close()
+                            }
+                        }
+
+                        ListView {
+                            id: tb_p
+                            currentIndex: -1
+                            visible: index === tb_c.currentIndex
+                            x: 10
+                            anchors.top: lb_container_name.bottom
+
+                            width: parent.width - 40
+                            height: visible ? tb_p.contentItem.height : 0
+
+                            spacing: 0
+                            clip: true
+                            interactive: false
+                            model: proxyProtocolsModel
+
+                            delegate: Item {
+                                id: dp_item
+
+                                implicitWidth: tb_p.width - 10
+                                implicitHeight: p_item.height
+                                Item {
+                                    id: p_item
+                                    width: parent.width
+                                    height: lb_protocol_name.height
+                                    anchors.left: parent.left
+                                    Rectangle {
+                                        anchors.top: parent.top
+                                        width: parent.width
+                                        height: 1
+                                        color: "lightgray"
+                                        visible: index !== tb_p.currentIndex
+                                    }
+//                                    Rectangle {
+//                                        anchors.top: lb_protocol_name.top
+//                                        anchors.bottom: lb_protocol_name.bottom
+//                                        width: parent.width
+
+//                                        color: "#63B4FB"
+//                                        visible: index === tb_p.currentIndex
+//                                    }
+
+//                                    Text {
+//                                        id: lb_protocol_name
+//                                        text: name_role
+//                                        font.pixelSize: 16
+//                                        topPadding: 5
+//                                        bottomPadding: 5
+//                                        leftPadding: 10
+//                                        verticalAlignment: Text.AlignVCenter
+//                                        wrapMode: Text.WordWrap
+//                                    }
+
+                                    SettingButtonType {
+                                        id: lb_protocol_name
+
+//                                        anchors.top: lb_protocol_name.top
+//                                        anchors.bottom: lb_protocol_name.bottom
+                                        topPadding: 10
+                                        bottomPadding: 10
+                                        leftPadding: 10
+
+                                        anchors.left: parent.left
+
+                                        width: parent.width
+                                        height: 30
+                                        text: qsTr(name_role + " settings")
+                                        textItem.font.pixelSize: 16
+                                        icon.source: "qrc:/images/settings.png"
+                                        onClicked: {
+                                            ServerContainersLogic.onPushButtonProtoCloakOpenVpnContSsConfigClicked()
+                                        }
+                                    }
+                                }
+
+//                                MouseArea {
+//                                    anchors.fill: parent
+//                                    onClicked: {
+//                                        tb_p.currentIndex = index
+//                                    }
+//                                }
+                            }
                         }
                     }
                 }

client/ui/qml/main.qml

@@ -13,6 +13,7 @@ import "Config"
 
 Window  {
     property var pages: ({})
+    property var protocolPages: ({})
 
     id: root
     visible: true

client/ui/uilogic.cpp

@@ -75,6 +75,7 @@ UiLogic::UiLogic(QObject *parent) :
     m_dialogConnectErrorText{}
 {
     m_containersModel = new ContainersModel(this);
+    m_protocolsModel = new ProtocolsModel(this);
     m_vpnConnection = new VpnConnection(this);
 
     m_appSettingsLogic = new AppSettingsLogic(this);
@@ -94,6 +95,11 @@ UiLogic::UiLogic(QObject *parent) :
     m_openVpnLogic = new OpenVpnLogic(this);
     m_shadowSocksLogic = new ShadowSocksLogic(this);
     m_cloakLogic = new CloakLogic(this);
+
+    m_protocolLogicMap->insert(Protocol::OpenVpn, new OpenVpnLogic(this));
+    m_protocolLogicMap->insert(Protocol::ShadowSocks, new ShadowSocksLogic(this));
+    m_protocolLogicMap->insert(Protocol::Cloak, new CloakLogic(this));
+    //m_protocolLogicMap->insert(Protocol::WireGuard, new WireguardLogic(this));
 }
 
 void UiLogic::initalizeUiLogic()

client/ui/uilogic.h

@@ -9,7 +9,9 @@
 #include "pages.h"
 #include "protocols/vpnprotocol.h"
 #include "containers/containers_defs.h"
+
 #include "models/containers_model.h"
+#include "models/protocols_model.h"
 
 #include "settings.h"
 
@@ -27,6 +29,7 @@ class StartPageLogic;
 class VpnLogic;
 class WizardLogic;
 
+class PageProtocolLogicBase;
 class OpenVpnLogic;
 class ShadowSocksLogic;
 class CloakLogic;
@@ -39,6 +42,7 @@ class UiLogic : public QObject
     Q_OBJECT
 
     READONLY_PROPERTY(QObject *, containersModel)
+    READONLY_PROPERTY(QObject *, protocolsModel)
 
     Q_PROPERTY(int currentPageValue READ getCurrentPageValue WRITE setCurrentPageValue NOTIFY currentPageValueChanged)
     Q_PROPERTY(QString trayIconUrl READ getTrayIconUrl WRITE setTrayIconUrl NOTIFY trayIconUrlChanged)
@@ -66,6 +70,7 @@ public:
     friend class VpnLogic;
     friend class WizardLogic;
 
+    friend class PageProtocolLogicBase;
     friend class OpenVpnLogic;
     friend class ShadowSocksLogic;
     friend class CloakLogic;
@@ -175,6 +180,8 @@ public:
     ShadowSocksLogic *shadowSocksLogic()                    { return m_shadowSocksLogic; }
     CloakLogic *cloakLogic()                                { return m_cloakLogic; }
 
+    Q_INVOKABLE PageProtocolLogicBase *protocolLogic(amnezia::Protocol p) { return m_protocolLogicMap->value(p); }
+
 private:
     AppSettingsLogic *m_appSettingsLogic;
     GeneralSettingsLogic *m_generalSettingsLogic;
@@ -194,6 +201,8 @@ private:
     ShadowSocksLogic *m_shadowSocksLogic;
     CloakLogic *m_cloakLogic;
 
+    QMap<Protocol, PageProtocolLogicBase *> *m_protocolLogicMap;
+
     VpnConnection* m_vpnConnection;
     Settings m_settings;